> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-sdk-testing-latest.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Créer une évaluation
> Découvrez comment créer un pipeline d’évaluation avec Weave Models et Evaluations
export const GitHubLink = ({url}) =>
Source GitHub
;
export const ColabLink = ({url}) =>
Essayer sur Colab
;
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`](/fr/weave/guides/core-types/models) et [`Evaluation`](/fr/weave/guides/core-types/evaluations). 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](https://wandb.ai/signup)
* Python 3.10+ ou Node.js 18+
* Packages requis :
* **Python**: `pip install weave openai`
* **TypeScript**: `npm install weave openai`
* Une [clé API OpenAI](https://platform.openai.com/api-keys) configurée comme variable d'environnement.
## Importez les bibliothèques et les fonctions nécessaires
Importez les bibliothèques suivantes dans votre script :
```python lines theme={null}
import json
import openai
import asyncio
import weave
from weave.scorers import MultiTaskBinaryClassificationF1
```
```typescript twoslash lines theme={null}
// @noErrors
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](/fr/weave/guides/core-types/models) 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 lines {1,5} theme={null}
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
```
```typescript twoslash lines {9} theme={null}
// @noErrors
// 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": , "color": , "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 lines theme={null}
# 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": , "color": , "flavor": ) 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)
```
```typescript twoslash theme={null}
// @noErrors
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`](/fr/weave/guides/core-types/datasets) 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 lines theme={null}
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]}
]
```
```typescript twoslash theme={null}
// @noErrors
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 lines {2} theme={null}
weave.init('eval_pipeline_quickstart')
dataset = weave.Dataset(name='fruits', rows=examples)
weave.publish(dataset)
```
```typescript twoslash lines {3-6} theme={null}
// @noErrors
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 lines theme={null}
@weave.op()
def fruit_name_score(target: dict, output: dict) -> dict:
return {'correct': target['fruit'] == output['fruit']}
```
```typescript twoslash theme={null}
// @noErrors
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](/fr/weave/guides/evaluation/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](/fr/weave/tutorial-rag#optional-defining-a-scorer-class).
## 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](/fr/weave/guides/evaluation/builtin_scorers). 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](https://en.wikipedia.org/wiki/F-score).
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 lines {3-10} theme={null}
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)
```
```typescript twoslash lines {5-9} theme={null}
// @noErrors
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
```python lines theme={null}
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": , "color": , "flavor": ) 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)))
```
```typescript twoslash lines theme={null}
// @noErrors
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": , "color": , "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);
});
// 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](/fr/weave/guides/evaluation/scorers).
* Découvrez les [fonctions de scoring intégrées](/fr/weave/guides/evaluation/builtin_scorers) de Weave.
* Découvrez l’[Évaluation basée sur des modèles](/fr/weave/guides/evaluation/scorers#model-based-evaluation) pour utiliser des LLM comme juges.
## Étapes suivantes
[Créez une application RAG](/fr/weave/tutorial-rag) pour découvrir l’évaluation de la génération augmentée par récupération.
