> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Verdict
> Utilisez le framework d’évaluation Verdict avec Weave pour tracer et surveiller vos pipelines d’évaluation de LLM
Weave est conçu pour suivre et consigner automatiquement tous les appels effectués via la [bibliothèque Python Verdict](https://verdict.haizelabs.com/docs/).
Lorsque vous travaillez avec des pipelines d’évaluation d’IA, le débogage est important. Qu’une étape du pipeline échoue, que les résultats soient inattendus ou que des opérations imbriquées sèment la confusion, il peut être difficile d’identifier précisément l’origine des problèmes. Les applications Verdict se composent souvent de plusieurs étapes de pipeline, de juges et de transformations, il est donc utile de comprendre le fonctionnement interne de vos flux de travail d’évaluation.
Weave fluidifie ce processus en capturant automatiquement les traces de vos applications [Verdict](https://verdict.readthedocs.io/). Cela vous permet de surveiller et d’analyser les performances de votre pipeline afin de déboguer et d’optimiser vos flux de travail d’évaluation d’IA.
## Prise en main
Pour activer le traçage Weave pour vos pipelines Verdict, appelez `weave.init(project=...)` au début de votre script. Utilisez l’argument `project` pour journaliser vers un nom de Teams W\&B spécifique au format `team-name/project-name`, ou utilisez `project-name` pour journaliser vers votre équipe ou entité par défaut.
```python lines {7} theme={null}
import weave
from verdict import Pipeline
from verdict.common.judge import JudgeUnit
from verdict.schema import Schema
# Initialize Weave with your project name
weave.init("verdict_demo")
# Create a simple evaluation pipeline
pipeline = Pipeline()
pipeline = pipeline >> JudgeUnit().prompt("Rate the quality of this text: {source.text}")
# Create sample data
data = Schema.of(text="This is a sample text for evaluation.")
# Exécutez le pipeline - Weave le trace automatiquement
output = pipeline.run(data)
print(output)
```
## Suivi des métadonnées des appels
Pour associer des métadonnées personnalisées aux appels de votre pipeline Verdict, utilisez le gestionnaire de contexte [`weave.attributes`](/fr/weave/reference/python-sdk#function-attributes). Ce gestionnaire de contexte vous permet de baliser un bloc de code spécifique, comme un run de pipeline ou un lot d’évaluation, afin de pouvoir ensuite filtrer et regrouper les traces associées dans l’interface Weave.
```python lines {7,14} theme={null}
import weave
from verdict import Pipeline
from verdict.common.judge import JudgeUnit
from verdict.schema import Schema
# Initialisez Weave avec le nom de votre projet
weave.init("verdict_demo")
pipeline = Pipeline()
pipeline = pipeline >> JudgeUnit().prompt("Evaluate sentiment: {source.text}")
data = Schema.of(text="I love this product!")
with weave.attributes({"evaluation_type": "sentiment", "batch_id": "batch_001"}):
output = pipeline.run(data)
print(output)
```
Weave suit automatiquement les métadonnées de la trace de l’appel du pipeline Verdict. Vous pouvez afficher les métadonnées dans l’interface web de Weave.
## Traces
Stocker les traces des pipelines d’évaluation d’IA dans une base de données centralisée est utile aussi bien en développement qu’en production. Ces traces facilitent le débogage et l’amélioration de vos flux de travail d’évaluation, et constituent également un jeu de données utile.
Weave capture automatiquement les traces de vos applications Verdict. Il suit et journalise tous les appels effectués via la bibliothèque Verdict, notamment :
* Les étapes d’exécution de `Pipeline`.
* Les évaluations de `JudgeUnit`.
* Les transformations de `Layer`.
* Les opérations de pooling.
* Les unités et transformations personnalisées.
Vous pouvez consulter les traces dans l’interface web de Weave, qui affiche la structure hiérarchique de l’exécution de votre pipeline.
## Exemple de traçage de pipeline
L’exemple suivant montre comment Weave effectue le traçage d’opérations de pipeline imbriquées, afin que vous puissiez voir comment chaque étape d’un pipeline Verdict à plusieurs phases est capturée :
```python lines {8} theme={null}
import weave
from verdict import Pipeline, Layer
from verdict.common.judge import JudgeUnit
from verdict.transform import MeanPoolUnit
from verdict.schema import Schema
# Initialize Weave with your project name
weave.init("verdict_demo")
# Créer un pipeline avec plusieurs étapes
pipeline = Pipeline()
pipeline = pipeline >> Layer([
JudgeUnit().prompt("Rate coherence: {source.text}"),
JudgeUnit().prompt("Rate relevance: {source.text}"),
JudgeUnit().prompt("Rate accuracy: {source.text}")
], 3)
pipeline = pipeline >> MeanPoolUnit()
# Sample data
data = Schema.of(text="This is an evaluation of text quality across multiple dimensions.")
# Exécuter le pipeline - Weave trace toutes les opérations
result = pipeline.run(data)
print(f"Average score: {result}")
```
Cela crée une trace détaillée affichant :
* L’exécution principale du `Pipeline`.
* Chaque évaluation de `JudgeUnit` au sein de la `Layer`.
* L’étape d’agrégation de `MeanPoolUnit`.
* Les informations de durée d’exécution pour chaque opération.
## Configuration
Lorsque vous appelez `weave.init()`, Weave active automatiquement le traçage pour les pipelines Verdict. L’intégration fonctionne en patchant la méthode `Pipeline.__init__()` afin d’injecter un `VerdictTracer` qui transmet toutes les données de trace à Weave.
Vous n’avez besoin d’aucune configuration supplémentaire. Weave effectue automatiquement les actions suivantes :
* Capturer toutes les opérations des pipelines.
* Suivre la durée d’exécution.
* Journaliser les entrées et les sorties.
* Maintenir la hiérarchie des traces.
* Gérer l’exécution concurrente des pipelines.
## Traceurs personnalisés et Weave
Si vous utilisez déjà des traceurs Verdict personnalisés dans votre application, le `VerdictTracer` de Weave peut être utilisé à leurs côtés afin que vous n'ayez pas à choisir entre les intégrations :
```python lines {8} theme={null}
import weave
from verdict import Pipeline
from verdict.common.judge import JudgeUnit
from verdict.util.tracing import ConsoleTracer
from verdict.schema import Schema
# Initialize Weave with your project name
weave.init("verdict_demo")
# You can still use Verdict's built-in tracers
console_tracer = ConsoleTracer()
# Create pipeline with both Weave (automatic) and Console tracing
pipeline = Pipeline(tracer=[console_tracer]) # Weave tracer is added automatically
pipeline = pipeline >> JudgeUnit().prompt("Evaluate: {source.text}")
data = Schema.of(text="Sample evaluation text")
# Ceci envoie les traces à la fois vers Weave et la console
result = pipeline.run(data)
```
## Models et évaluations
Organiser et évaluer des systèmes d’IA composés de plusieurs composants de pipeline peut être complexe. En utilisant [`weave.Model`](/fr/weave/guides/core-types/models), vous pouvez capturer et organiser des informations expérimentales telles que les prompts, les configurations de pipeline et les paramètres d’évaluation, ce qui facilite la comparaison des différentes itérations.
L’exemple suivant montre comment encapsuler un pipeline Verdict dans un `weave.Model` :
```python lines {8,10,14} theme={null}
import asyncio
import weave
from verdict import Pipeline
from verdict.common.judge import JudgeUnit
from verdict.schema import Schema
# Initialisez Weave avec le nom de votre projet
weave.init("verdict_demo")
class TextQualityEvaluator(weave.Model):
judge_prompt: str
pipeline_name: str
@weave.op()
async def predict(self, text: str) -> dict:
pipeline = Pipeline(name=self.pipeline_name)
pipeline = pipeline >> JudgeUnit().prompt(self.judge_prompt)
data = Schema.of(text=text)
result = pipeline.run(data)
return {
"text": text,
"quality_score": result.score if hasattr(result, 'score') else result,
"evaluation_prompt": self.judge_prompt
}
model = TextQualityEvaluator(
judge_prompt="Rate the quality of this text on a scale of 1-10: {source.text}",
pipeline_name="text_quality_evaluator"
)
text = "This is a well-written and informative piece of content that provides clear value to readers."
prediction = asyncio.run(model.predict(text))
# si vous utilisez un Jupyter Notebook, exécutez :
# prediction = await model.predict(text)
print(prediction)
```
Ce code crée un modèle que vous pouvez visualiser dans la Weave UI, en affichant à la fois la structure du pipeline et les résultats de l’évaluation.
### Évaluations
Les évaluations vous aident à mesurer les performances de vos propres pipelines d’évaluation. En utilisant la classe [`weave.Evaluation`](/fr/weave/guides/core-types/evaluations), vous pouvez capturer le niveau de performance de vos pipelines Verdict sur des tâches ou des jeux de données spécifiques :
```python lines {8} theme={null}
import asyncio
import weave
from verdict import Pipeline
from verdict.common.judge import JudgeUnit
from verdict.schema import Schema
# Initialiser Weave
weave.init("verdict_demo")
# Créer le modèle d'évaluation
class SentimentEvaluator(weave.Model):
@weave.op()
async def predict(self, text: str) -> dict:
pipeline = Pipeline()
pipeline = pipeline >> JudgeUnit().prompt(
"Classify sentiment as positive, negative, or neutral: {source.text}"
)
data = Schema.of(text=text)
result = pipeline.run(data)
return {"sentiment": result}
# Données de test
texts = [
"I love this product, it's amazing!",
"This is terrible, worst purchase ever.",
"The weather is okay today."
]
labels = ["positive", "negative", "neutral"]
examples = [
{"id": str(i), "text": texts[i], "target": labels[i]}
for i in range(len(texts))
]
# Fonction de scoring
@weave.op()
def sentiment_accuracy(target: str, output: dict) -> dict:
predicted = output.get("sentiment", "").lower()
return {"correct": target.lower() in predicted}
model = SentimentEvaluator()
evaluation = weave.Evaluation(
dataset=examples,
scorers=[sentiment_accuracy],
)
scores = asyncio.run(evaluation.evaluate(model))
# si vous êtes dans un Jupyter Notebook, exécutez :
# scores = await evaluation.evaluate(model)
print(scores)
```
Cela crée une trace d’évaluation qui montre les performances de votre pipeline Verdict sur différents cas de test.
## Bonnes pratiques
Les sections suivantes décrivent les bonnes pratiques pour surveiller les performances et gérer les erreurs lorsque vous utilisez Weave avec les pipelines Verdict.
### Suivi des performances
Weave capture automatiquement les informations de durée d’exécution pour toutes les opérations du pipeline, que vous pouvez utiliser pour identifier les goulots d’étranglement en matière de performances d’un run à l’autre :
```python lines {6} theme={null}
import weave
from verdict import Pipeline, Layer
from verdict.common.judge import JudgeUnit
from verdict.schema import Schema
weave.init("verdict_demo")
# Créer un pipeline susceptible de présenter des variations de performances
pipeline = Pipeline()
pipeline = pipeline >> Layer([
JudgeUnit().prompt("Quick evaluation: {source.text}"),
JudgeUnit().prompt("Detailed analysis: {source.text}"), # Ceci peut être plus lent
], 2)
data = Schema.of(text="Sample text for performance testing")
# Exécuter plusieurs fois pour observer les tendances de durée d'exécution
for i in range(3):
with weave.attributes({"run_number": i}):
result = pipeline.run(data)
```
### Gestion des erreurs
Weave capture automatiquement les exceptions qui se produisent pendant l’exécution du pipeline, de sorte que Weave enregistre les échecs dans la trace même lorsque votre application gère l’exception :
```python lines {6} theme={null}
import weave
from verdict import Pipeline
from verdict.common.judge import JudgeUnit
from verdict.schema import Schema
weave.init("verdict_demo")
pipeline = Pipeline()
pipeline = pipeline >> JudgeUnit().prompt("Process: {source.invalid_field}") # Cela provoque une erreur
data = Schema.of(text="Sample text")
try:
result = pipeline.run(data)
except Exception as e:
print(f"Pipeline failed: {e}")
# Les détails de l'erreur sont capturés dans la trace Weave
```
En intégrant Weave à Verdict, vous gagnez en visibilité sur vos pipelines d’évaluation IA, ce qui facilite le débogage, l’optimisation et la compréhension de vos flux de travail d’évaluation.