> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-run-filter-ui-updates.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
;
Les évaluations vous aident à itérer sur vos applications et à les améliorer en les testant sur un ensemble d’exemples après chaque modification. 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 pour évaluer les réponses d'un LLM
* Définir une fonction de scoring pour comparer les résultats du modèle aux résultats attendus
* 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
* Consulter les résultats de l'évaluation dans la Weave UI
## 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 lines theme={null}
import * as weave from 'weave';
import OpenAI from 'openai';
```
## Créer un `Model`
Dans Weave, les [`Models` sont des objets](/fr/weave/guides/core-types/models) qui capturent à la fois le comportement de votre modèle/agent (logique, prompt, paramètres) et ses métadonnées versionnées (paramètres, code, micro-config), afin que vous puissiez le suivre, le comparer, l'évaluer et itérer dessus de manière fiable.
Lorsque vous instanciez un `Model`, Weave capture automatiquement sa configuration et ses comportements, puis met à jour sa version en cas de modification. Cela vous permet de suivre ses performances au fil du temps, à mesure que vous l'améliorez.
Les `Model` sont déclarés en créant une sous-classe de `Model` et en implémentant une fonction `predict`, qui prend un exemple et renvoie la réponse.
L'exemple de modèle suivant utilise OpenAI pour extraire les noms, les couleurs et les saveurs de fruits extraterrestres à partir des phrases qui lui sont envoyées.
```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 lines {9} theme={null}
// 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` (ou en est une sous-classe) afin que Weave puisse 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 le nom de votre team et de votre projet
weave.init('/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 theme={null}
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
Ensuite, vous avez besoin d'un jeu de données sur lequel évaluer votre modèle. Un [`Dataset` est une collection d'exemples stockée comme objet Weave](/fr/weave/guides/core-types/datasets).
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 theme={null}
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 lines {3-6} theme={null}
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 scoring personnalisées
Lorsque vous utilisez les évaluations Weave, Weave s'attend à recevoir une `target` à comparer à `output`. La fonction de scoring 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 scoring.
```python lines theme={null}
@weave.op()
def fruit_name_score(target: dict, output: dict) -> dict:
return {'correct': target['fruit'] == output['fruit']}
```
```typescript theme={null}
import * as weave from 'weave';
const fruitNameScorer = weave.op(
function fruitNameScore({target, output}) {
return { correct: target.fruit === output.fruit };
}
);
```
Pour créer votre propre fonction de scoring, 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 en savoir plus, consultez le tutoriel sur la définition d'une classe `Scorer` dans le chapitre suivant sur [l'évaluation des applications RAG basée sur des modèles](/fr/weave/tutorial-rag#optional-defining-a-scorer-class).
## Utiliser un scorer intégré et exécuter l’évaluation
En plus des fonctions de scoring 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 le scorer 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 scoring et enregistre 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 lines {5-9} theme={null}
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 jeu de données
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 scoring
@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 lines theme={null}
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 similaire à un 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 jeu de données
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. Exécuter 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
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 la Weave UI.
## En savoir plus sur les évaluations Weave
* 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.
