> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Verifiers

> Suivez les environnements d’apprentissage par renforcement Verifiers et l’entraînement d’agents LLM avec Weave, en capturant les conversations à plusieurs tours et les rollouts d’évaluation.

[Verifiers](https://github.com/willccbb/verifiers) est une bibliothèque de composants modulaires qui permet de créer des environnements d’apprentissage par renforcement (RL) et d’entraîner des agents LLM. Les environnements créés avec Verifiers peuvent servir à l’évaluation de LLM, à la création de pipelines de données synthétiques, de harness d’agents pour tout point de terminaison compatible avec OpenAI, ainsi qu’à l’entraînement RL.

En plus d’enregistrer vos métriques d’entraînement avec W\&B, vous pouvez intégrer Weave à vos flux de travail RL Verifiers pour observer les performances de votre modèle pendant l’entraînement. Weave enregistre les entrées, les sorties et les horodatages de chaque étape. Vous pouvez ainsi examiner la transformation des données à chaque tour de conversation, déboguer des conversations complexes à plusieurs tours et optimiser les résultats de l’entraînement.

Vous pouvez également combiner Weave et Verifiers pour réaliser des évaluations.

Ce guide s’adresse aux ingénieurs et chercheurs en ML qui souhaitent ajouter de l’observabilité à leurs flux de travail RL basés sur Verifiers. Il explique comment installer Verifiers, W\&B et Weave, et fournit deux exemples d’utilisation de Verifiers avec Weave et W\&B : le traçage des rollouts pendant l’évaluation, et le fine-tuning d’un modèle avec le suivi des expériences et le traçage activés.

<h2 id="get-started">
  Premiers pas
</h2>

Pour intégrer Verifiers à Weave, commencez par installer la bibliothèque Verifiers avec `uv` ([méthode recommandée par les auteurs de la bibliothèque](https://github.com/willccbb/verifiers?tab=readme-ov-file#setup)). Pour installer la bibliothèque, utilisez l’une des commandes suivantes :

```bash theme={"system"}
# Installe la bibliothèque de base pour le développement local et les modèles accessibles par API
uv add verifiers

# Installe la version complète de la bibliothèque avec toutes les dépendances facultatives, dont PyTorch et la prise en charge des GPU
uv add 'verifiers[all]' && uv pip install flash-attn --no-build-isolation

# Installe la dernière version de la bibliothèque directement depuis GitHub, avec les fonctionnalités et correctifs les plus récents non encore publiés
uv add verifiers @ git+https://github.com/willccbb/verifiers.git
```

Installez ensuite Weave et W\&B :

```bash theme={"system"}
uv pip install weave wandb
```

Weave active par défaut le [patching implicite](/fr/products/wandb/weave/guides/integrations#automatic-implicit-patching) pour la bibliothèque. Vous pouvez ainsi utiliser Weave avec Verifiers sans avoir à appeler explicitement des fonctions de patch.

Une fois les bibliothèques installées, vous pouvez exécuter les exemples des sections suivantes.

<h3 id="trace-rollouts-and-evaluate">
  Tracer les rollouts et évaluer
</h3>

Une fois les bibliothèques nécessaires installées, vous pouvez utiliser Weave conjointement avec Verifiers pour tracer les appels et exécuter des évaluations.

L’exemple de script suivant montre comment exécuter une évaluation avec Verifiers et en journaliser les résultats dans Weave. Le script évalue la capacité du LLM à résoudre des problèmes mathématiques à l’aide du [jeu de données GSM8K](https://huggingface.co/datasets/openai/gsm8k). Il demande à GPT-4 de résoudre deux problèmes mathématiques, extrait la valeur numérique de chaque réponse, puis note chaque tentative en s’appuyant sur Verifiers comme framework d’évaluation.

Exécutez l’exemple et examinez les résultats dans Weave :

```python lines theme={"system"}
import os
from openai import OpenAI
import verifiers as vf
import weave

os.environ["OPENAI_API_KEY"] = "[YOUR-OPENAI-API-KEY]"

# Initialiser Weave
weave.init("verifiers_demo")

# Environnement minimal à un seul tour de conversation
dataset = vf.load_example_dataset("gsm8k", split="train").select(range(2))
parser = vf.ThinkParser()

def correct_answer(parser, completion, answer):
    parsed = parser.parse_answer(completion) or ""
    return 1.0 if parsed.strip() == answer.strip() else 0.0

rubric = vf.Rubric(funcs=[correct_answer, parser.get_format_reward_func()], weights=[1.0, 0.2])

env = vf.SingleTurnEnv(
    dataset=dataset,
    system_prompt="Think step-by-step, then answer.",
    parser=parser,
    rubric=rubric,
)

client = OpenAI()
results = env.evaluate(
    client, "gpt-4.1-mini", num_examples=2, rollouts_per_example=2, max_concurrent=8
)
```

<h3 id="fine-tune-a-model-with-experiment-tracking-and-tracing">
  Effectuer le fine-tuning d’un modèle avec le suivi des expériences et le traçage
</h3>

Weave vous permet de mieux comprendre les performances de vos modèles pendant le fine-tuning par RL. Utilisé conjointement avec W\&B, il vous offre une observabilité sur l’ensemble du flux de travail : W\&B suit les métriques d’entraînement et les graphiques de performances, tandis que Weave capture des traces détaillées de chaque interaction au cours de l’entraînement.

Le dépôt `verifiers` inclut des [exemples](https://github.com/PrimeIntellect-ai/verifiers) prêts à l’emploi pour vous aider à démarrer.

L’exemple de pipeline d’entraînement RL suivant exécute un serveur d’inférence local et entraîne un modèle sur le jeu de données GSM8K. Le modèle répond aux problèmes mathématiques, puis la boucle d’entraînement évalue la sortie et met à jour le modèle en conséquence. W\&B journalise les métriques d’entraînement, telles que la perte, la récompense et la précision, tandis que Weave capture l’entrée, la sortie, le raisonnement et la notation.

Pour utiliser ce pipeline :

1. Installez le framework à partir des sources. Les commandes suivantes installent la bibliothèque Verifiers depuis GitHub ainsi que les dépendances nécessaires :

```bash theme={"system"}
git clone https://github.com/willccbb/verifiers
cd verifiers
uv sync --all-extras && uv pip install flash-attn --no-build-isolation
```

2. Installez un environnement prêt à l’emploi. La commande suivante installe l’environnement d’entraînement GSM8K préconfiguré :

```bash theme={"system"}
vf-install gsm8k --from-repo
```

3. Entraînez votre modèle. Les commandes suivantes lancent respectivement le serveur d'inférence et la boucle d'entraînement. Cet exemple de flux de travail définit `report_to=wandb` par défaut ; vous n'avez donc pas besoin d'appeler `wandb.init()` séparément. Vous serez invité à authentifier cette machine afin de consigner des métriques dans W\&B.

```bash theme={"system"}
# Lance le serveur d’inférence
CUDA_VISIBLE_DEVICES=0 vf-vllm --model willcb/Qwen3-0.6B --enforce-eager --disable-log-requests

# Lance la boucle d’entraînement
CUDA_VISIBLE_DEVICES=1 accelerate launch --num-processes 1 --config-file configs/zero3.yaml examples/grpo/train_gsm8k.py
```

<Note>
  Cet exemple a été testé sur 2 H100, avec les variables d’environnement suivantes définies pour améliorer la stabilité :

  ```bash theme={"system"}
  # In BOTH shells (server and trainer) before launch
  export NCCL_CUMEM_ENABLE=0
  export NCCL_CUMEM_HOST_ENABLE=0
  ```

  Ces variables désactivent la mémoire unifiée CUDA (CuMem) pour les allocations de mémoire du GPU.
</Note>

Une fois l’entraînement lancé, vous pouvez [afficher les traces](/fr/products/wandb/weave/guides/tools/weave-in-workspaces) journalisées pendant votre run dans l’interface utilisateur. W\&B capture les métriques d’entraînement et Weave enregistre les traces de chaque interaction. Vous disposez ainsi à la fois d’une vue d’ensemble des tendances de performances et d’une visibilité détaillée, étape par étape, sur votre run d’entraînement.

Les traces omettent `logprobs` pour les méthodes `Environment.a_generate` et `Rubric.score_rollouts`. Les charges utiles restent ainsi légères, tandis que les données d’origine sont conservées intactes pour l’entraînement.

<h2 id="see-also">
  Voir aussi
</h2>

Verifiers offre une intégration native avec W\&B Models. Pour plus d'informations, voir le [dépôt Verifiers](https://github.com/willccbb/verifiers).


## Related topics

- [Vérifier la disponibilité de la configuration du projet](/fr/model-distillation/reference/management/tasks/check-project-setup-availability.md)