Créer une évaluation - Weights & Biases Documentation

Ce tutoriel vous guide dans la création d’un pipeline d’évaluation de bout en bout dans Weave afin que vous puissiez mesurer et suivre la qualité d’une application LLM au fil de vos itérations. Les évaluations vous aident à comparer les modifications à un ensemble cohérent d’exemples et à détecter les régressions avant qu’elles n’atteignent les utilisateurs. Ce tutoriel s’adresse aux développeurs qui créent des applications basées sur des LLM et souhaitent disposer d’une méthode reproductible pour les tester. Weave offre une prise en charge native du suivi des évaluations avec les classes Model et Evaluation. Les API sont conçues pour faire le moins d’hypothèses possible, ce qui les rend flexibles pour un large éventail de cas d’usage.

Ce que vous allez apprendre

Ce guide vous montre comment :

Configurer un Model.
Créer un jeu de données de référence pour tester les réponses d’un LLM.
Définir une fonction de score pour comparer les sorties du modèle aux sorties attendues.
Exécuter une évaluation qui teste le modèle sur le jeu de données à l’aide de la fonction de score et d’un scorer intégré supplémentaire.
Afficher les résultats de l’évaluation dans l’interface Weave.

À la fin, vous disposerez d’un pipeline d’évaluation opérationnel qui attribue des scores à un modèle d’exemple sur un jeu de données et journalise les résultats vers Weave.

Prérequis

Un compte W&B
Python 3.10+ ou Node.js 18+
Packages requis :
- Python: pip install weave openai
- TypeScript: npm install weave openai
Une clé API OpenAI configurée comme variable d’environnement.

Importez les bibliothèques et les fonctions nécessaires

Importez les bibliothèques suivantes dans votre script :

Python
TypeScript

import json
import openai
import asyncio
import weave
from weave.scorers import MultiTaskBinaryClassificationF1

import * as weave from 'weave';
import OpenAI from 'openai';

Créer un `Model`

Une fois les bibliothèques en place, l’étape suivante consiste à définir le modèle que vous souhaitez évaluer. Dans Weave, les Models sont des objets qui capturent à la fois le comportement de votre modèle ou agent (logique, prompt, paramètres) et ses métadonnées versionnées (paramètres, code, micro-configuration), afin que vous puissiez le suivre, le comparer, l’évaluer et itérer dessus en toute fiabilité. Lorsque vous instanciez un Model, Weave capture automatiquement sa configuration et son comportement, puis met à jour sa version lorsqu’il change. Vous pouvez ainsi suivre ses performances au fil du temps à mesure que vous l’améliorez. Pour déclarer un Model, créez une sous-classe de Model et implémentez une fonction predict qui prend un exemple en entrée et renvoie la réponse. Le modèle d’exemple suivant utilise OpenAI pour extraire les noms, les couleurs et les saveurs de fruits extraterrestres à partir de phrases d’entrée.

Python
TypeScript

class ExtractFruitsModel(weave.Model):
    model_name: str
    prompt_template: str

    @weave.op()
    async def predict(self, sentence: str) -> dict:
        client = openai.AsyncClient()

        response = await client.chat.completions.create(
            model=self.model_name,
            messages=[
                {"role": "user", "content": self.prompt_template.format(sentence=sentence)}
            ],
        )
        result = response.choices[0].message.content
        if result is None:
            raise ValueError("No response from model")
        parsed = json.loads(result)
        return parsed

// Remarque : weave.Model n'est pas encore pris en charge en TypeScript.
// À la place, encapsulez votre fonction de type modèle avec weave.op

import * as weave from 'weave';
import OpenAI from 'openai';

const openaiClient = new OpenAI();

const model = weave.op(async function myModel({datasetRow}) {
  const prompt = `Extract fields ("fruit": <str>, "color": <str>, "flavor") from the following text, as json: ${datasetRow.sentence}`;
  const response = await openaiClient.chat.completions.create({
    model: 'gpt-3.5-turbo',
    messages: [{ role: 'user', content: prompt }],
    response_format: { type: 'json_object' }
  });
  return JSON.parse(response.choices[0].message.content);
});

La classe ExtractFruitsModel hérite de weave.Model, ce qui permet à Weave de suivre l’objet instancié. @weave.op décore la fonction predict pour suivre ses entrées et ses sorties. Vous pouvez instancier des objets Model comme ceci :

Python
TypeScript

# Définissez votre équipe et le nom du projet
weave.init('[YOUR-TEAM]/eval_pipeline_quickstart')

model = ExtractFruitsModel(
    model_name='gpt-3.5-turbo-1106',
    prompt_template='Extract fields ("fruit": <str>, "color": <str>, "flavor": <str>) from the following text, as json: {sentence}'
)

sentence = "There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy."

print(asyncio.run(model.predict(sentence)))
# si vous êtes dans un notebook Jupyter, exécutez :
# await model.predict(sentence)

await weave.init('eval_pipeline_quickstart');

const sentence = "There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy.";

const result = await model({ datasetRow: { sentence } });

console.log(result);

Créer un jeu de données

Une fois un Model défini, vous avez maintenant besoin d’un jeu de données pour l’évaluer. Un Dataset est une collection d’exemples stockée comme objet Weave. Publier le jeu de données dans Weave le versionne et le rend réutilisable dans plusieurs runs d’évaluation. L’exemple de jeu de données suivant définit trois phrases d’entrée et leurs réponses correctes (labels), puis les met en forme dans un tableau JSON que les fonctions de scoring peuvent lire. Cet exemple construit une liste d’exemples dans le code, mais vous pouvez aussi les journaliser une par une depuis votre application en cours d’exécution.

Python
TypeScript

sentences = ["There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy.",
"Pounits are a bright green color and are more savory than sweet.",
"Finally, there are fruits called glowls, which have a very sour and bitter taste which is acidic and caustic, and a pale orange tinge to them."]
labels = [
    {'fruit': 'neoskizzles', 'color': 'purple', 'flavor': 'candy'},
    {'fruit': 'pounits', 'color': 'bright green', 'flavor': 'savory'},
    {'fruit': 'glowls', 'color': 'pale orange', 'flavor': 'sour and bitter'}
]
examples = [
    {'id': '0', 'sentence': sentences[0], 'target': labels[0]},
    {'id': '1', 'sentence': sentences[1], 'target': labels[1]},
    {'id': '2', 'sentence': sentences[2], 'target': labels[2]}
]

const sentences = [
  "There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy.",
  "Pounits are a bright green color and are more savory than sweet.",
  "Finally, there are fruits called glowls, which have a very sour and bitter taste which is acidic and caustic, and a pale orange tinge to them."
];
const labels = [
  { fruit: 'neoskizzles', color: 'purple', flavor: 'candy' },
  { fruit: 'pounits', color: 'bright green', flavor: 'savory' },
  { fruit: 'glowls', color: 'pale orange', flavor: 'sour and bitter' }
];
const examples = sentences.map((sentence, i) => ({
  id: i.toString(),
  sentence,
  target: labels[i]
}));

Créez ensuite votre jeu de données avec la classe weave.Dataset() et publiez-le :

Python
TypeScript

weave.init('eval_pipeline_quickstart')
dataset = weave.Dataset(name='fruits', rows=examples)
weave.publish(dataset)

import * as weave from 'weave';
await weave.init('eval_pipeline_quickstart');
const dataset = new weave.Dataset({
  name: 'fruits',
  rows: examples
});
await dataset.save();

Définir des fonctions de score personnalisées

Maintenant que vous avez un modèle et un jeu de données, vous avez besoin d’un moyen de mesurer les performances du modèle sur chaque exemple. Les fonctions de score comparent l’output du modèle à la cible attendue et produisent les métriques qu’une évaluation rapporte. Lorsque vous utilisez les évaluations Weave, Weave s’attend à recevoir une target à comparer à output. La fonction de score suivante prend deux dictionnaires (target et output) et renvoie un dictionnaire de valeurs booléennes indiquant si la sortie correspond à la cible. Le décorateur @weave.op() permet à Weave de suivre l’exécution de la fonction de score.

Python
TypeScript

@weave.op()
def fruit_name_score(target: dict, output: dict) -> dict:
    return {'correct': target['fruit'] == output['fruit']}

import * as weave from 'weave';

const fruitNameScorer = weave.op(
  function fruitNameScore({target, output}) {
    return { correct: target.fruit === output.fruit };
  }
);

Pour plus d’informations sur la création de votre propre fonction de score, consultez le guide Scorers. Dans certaines applications, vous souhaiterez peut-être créer des classes Scorer personnalisées. Par exemple, vous pouvez créer une classe LLMJudge standardisée avec des paramètres spécifiques (comme un modèle de chat ou un prompt), une logique de scoring par ligne spécifique et un calcul de score agrégé. Pour plus d’informations, voir le tutoriel sur la définition d’une classe Scorer dans l’évaluation des applications RAG basée sur des modèles.

Utiliser un évaluateur intégré et exécuter l’évaluation

Avec le modèle, le jeu de données et un évaluateur personnalisé en place, vous êtes prêt à tout intégrer dans un run d’évaluation. En plus des fonctions de score personnalisées, vous pouvez aussi utiliser les évaluateurs intégrés de Weave. Dans l’évaluation suivante, weave.Evaluation() utilise la fonction fruit_name_score définie dans la section précédente ainsi que l’évaluateur intégré MultiTaskBinaryClassificationF1, qui calcule les scores F1. L’exemple suivant exécute une évaluation de ExtractFruitsModel sur le jeu de données fruits à l’aide de ces deux fonctions de score et journalise les résultats dans Weave.

Python
TypeScript

weave.init('eval_pipeline_quickstart')

evaluation = weave.Evaluation(
    name='fruit_eval',
    dataset=dataset, 
    scorers=[
        MultiTaskBinaryClassificationF1(class_names=["fruit", "color", "flavor"]), 
        fruit_name_score
    ],
)
print(asyncio.run(evaluation.evaluate(model)))
# si vous êtes dans un notebook Jupyter, exécutez :
# await evaluation.evaluate(model)

import * as weave from 'weave';

await weave.init('eval_pipeline_quickstart');

const evaluation = new weave.Evaluation({
  name: 'fruit_eval',
  dataset: dataset,
  scorers: [fruitNameScorer],
});
const results = await evaluation.evaluate(model);
console.log(results);

Si vous exécutez ce code depuis un script Python, vous devrez utiliser asyncio.run. En revanche, si vous l’exécutez dans un notebook Jupyter, vous pouvez utiliser directement await.

Exemple complet

Pipeline d’évaluation complet dans un script unique :

Python
TypeScript

import json
import asyncio
import openai
import weave
from weave.scorers import MultiTaskBinaryClassificationF1

# Initialiser Weave une seule fois
weave.init('eval_pipeline_quickstart')

# 1. Définir le modèle
class ExtractFruitsModel(weave.Model):
    model_name: str
    prompt_template: str

    @weave.op()
    async def predict(self, sentence: str) -> dict:
        client = openai.AsyncClient()
        response = await client.chat.completions.create(
            model=self.model_name,
            messages=[{"role": "user", "content": self.prompt_template.format(sentence=sentence)}],
        )
        result = response.choices[0].message.content
        if result is None:
            raise ValueError("No response from model")
        return json.loads(result)

# 2. Instancier le modèle
model = ExtractFruitsModel(
    model_name='gpt-3.5-turbo-1106',
    prompt_template='Extract fields ("fruit": <str>, "color": <str>, "flavor": <str>) from the following text, as json: {sentence}'
)

# 3. Créer le dataset
sentences = ["There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy.",
"Pounits are a bright green color and are more savory than sweet.",
"Finally, there are fruits called glowls, which have a very sour and bitter taste which is acidic and caustic, and a pale orange tinge to them."]
labels = [
    {'fruit': 'neoskizzles', 'color': 'purple', 'flavor': 'candy'},
    {'fruit': 'pounits', 'color': 'bright green', 'flavor': 'savory'},
    {'fruit': 'glowls', 'color': 'pale orange', 'flavor': 'sour and bitter'}
]
examples = [
    {'id': '0', 'sentence': sentences[0], 'target': labels[0]},
    {'id': '1', 'sentence': sentences[1], 'target': labels[1]},
    {'id': '2', 'sentence': sentences[2], 'target': labels[2]}
]

dataset = weave.Dataset(name='fruits', rows=examples)
weave.publish(dataset)

# 4. Définir la fonction de score
@weave.op()
def fruit_name_score(target: dict, output: dict) -> dict:
    return {'correct': target['fruit'] == output['fruit']}

# 5. Lancer l'évaluation
evaluation = weave.Evaluation(
    name='fruit_eval',
    dataset=dataset,
    scorers=[
        MultiTaskBinaryClassificationF1(class_names=["fruit", "color", "flavor"]),
        fruit_name_score
    ],
)
print(asyncio.run(evaluation.evaluate(model)))

import * as weave from 'weave';
import OpenAI from 'openai';

// Initialiser Weave une seule fois
await weave.init('eval_pipeline_quickstart');

// 1. Définir le modèle
// Remarque : weave.Model n'est pas encore pris en charge en TypeScript.
// À la place, encapsulez votre fonction de type modèle avec weave.op
const openaiClient = new OpenAI();

const model = weave.op(async function myModel({datasetRow}) {
  const prompt = `Extract fields ("fruit": <str>, "color": <str>, "flavor": <str>) from the following text, as json: ${datasetRow.sentence}`;
  const response = await openaiClient.chat.completions.create({
    model: 'gpt-3.5-turbo',
    messages: [{ role: 'user', content: prompt }],
    response_format: { type: 'json_object' }
  });
  return JSON.parse(response.choices[0].message.content);
});

// 2. Créer le dataset
const sentences = [
  "There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy.",
  "Pounits are a bright green color and are more savory than sweet.",
  "Finally, there are fruits called glowls, which have a very sour and bitter taste which is acidic and caustic, and a pale orange tinge to them."
];
const labels = [
  { fruit: 'neoskizzles', color: 'purple', flavor: 'candy' },
  { fruit: 'pounits', color: 'bright green', flavor: 'savory' },
  { fruit: 'glowls', color: 'pale orange', flavor: 'sour and bitter' }
];
const examples = sentences.map((sentence, i) => ({
  id: i.toString(),
  sentence,
  target: labels[i]
}));

const dataset = new weave.Dataset({
  name: 'fruits',
  rows: examples
});
await dataset.save();

// 3. Définir la fonction de score
const fruitNameScorer = weave.op(
  function fruitNameScore({target, output}) {
    return { correct: target.fruit === output.fruit };
  }
);

// 4. Lancer l'évaluation
const evaluation = new weave.Evaluation({
  name: 'fruit_eval',
  dataset: dataset,
  scorers: [fruitNameScorer],
});
const results = await evaluation.evaluate(model);
console.log(results);

Consultez les résultats de votre évaluation

Une fois l’évaluation terminée, vous pouvez inspecter chaque prédiction et chaque résultat du scorer dans l’interface Weave. Weave capture automatiquement les traces de chaque prédiction et de chaque score. Cliquez sur le lien affiché par l’évaluation pour consulter les résultats dans l’interface Weave.

En savoir plus sur les évaluations Weave

Vous disposez maintenant d’un pipeline d’évaluation complet. Pour approfondir les fonctionnalités d’évaluation de Weave, consultez les ressources suivantes :

Découvrez comment créer et utiliser des évaluateurs.
Découvrez les fonctions de scoring intégrées de Weave.
Découvrez l’Évaluation basée sur des modèles pour utiliser des LLM comme juges.

Étapes suivantes

Créez une application RAG pour découvrir l’évaluation de la génération augmentée par récupération.

​Ce que vous allez apprendre

​Prérequis

​Importez les bibliothèques et les fonctions nécessaires

​Créer un Model

​Créer un jeu de données

​Définir des fonctions de score personnalisées

​Utiliser un évaluateur intégré et exécuter l’évaluation

​Exemple complet

​Consultez les résultats de votre évaluation

​En savoir plus sur les évaluations Weave

​Étapes suivantes

Ce que vous allez apprendre

Prérequis

Importez les bibliothèques et les fonctions nécessaires

Créer un `Model`

Créer un jeu de données

Définir des fonctions de score personnalisées

Utiliser un évaluateur intégré et exécuter l’évaluation

Exemple complet

Consultez les résultats de votre évaluation

En savoir plus sur les évaluations Weave

Étapes suivantes