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.

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. 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.

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. 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.

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 :

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 :

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, 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 :

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, vous pouvez capturer le niveau de performance de vos pipelines Verdict sur des tâches ou des jeux de données spécifiques :

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 :

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 :

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.