> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/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 les modèles et les évaluations Weave
export const GitHubLink = ({url, compact = false}) =>
{compact ? "View source" : <>
GitHub source
}
;
export const ColabLink = ({url}) =>
Try in Colab
;
Ce tutoriel vous guide dans la création d’un pipeline d’évaluation de bout en bout dans Weave, afin de mesurer et de suivre la qualité d’une application LLM au fil de vos itérations. Les évaluations vous permettent de comparer vos modifications à un ensemble stable d’exemples et de détecter les régressions avant qu’elles n’affectent 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 fournit une prise en charge intégrée du suivi des évaluations grâce aux classes [`Model`](/fr/products/wandb/weave/guides/core-types/models) et [`Evaluation`](/fr/products/wandb/weave/guides/core-types/evaluations). Ces API reposent sur un minimum d’hypothèses, ce qui leur permet de s’adapter à de nombreux cas d’usage.
Ce que vous allez apprendre
Ce guide vous montre comment :
* Configurer un `Model`.
* Créer un dataset sur lequel tester les réponses d'un LLM.
* Définir une fonction de score pour comparer la sortie du modèle aux sorties attendues.
* Exécuter une évaluation qui teste le modèle sur le dataset à l'aide de la fonction de score et d'un évaluateur intégré supplémentaire.
* Afficher les résultats de l'évaluation dans l'interface de Weights & Biases.
À la fin de ce guide, vous disposerez d'un pipeline d'évaluation fonctionnel qui attribue un score à un modèle d'exemple sur un dataset et journalise les résultats dans Weave.
Prérequis
* Un [compte CoreWeave Forge](https://id.coreweave.com/signup)
* Python 3.10+ ou Node.js 18+
* Les paquets requis installés :
* **Python** : `pip install weave openai`
* **TypeScript** : `npm install weave openai`
* Une [clé API OpenAI](https://platform.openai.com/api-keys) définie dans une variable d’environnement.
Importer les bibliothèques et fonctions nécessaires
Importez les bibliothèques suivantes dans votre script :
```python lines theme={"system"}
import json
import openai
import asyncio
import weave
from weave.scorers import MultiTaskBinaryClassificationF1
```
```typescript twoslash lines theme={"system"}
// @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/products/wandb/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 suivre, comparer, évaluer et itérer de manière fiable.
Lorsque vous instanciez un `Model`, Weave capture automatiquement sa configuration et ses comportements, et met à jour la version à chaque modification. Vous pouvez ainsi suivre l’évolution de ses performances au fil de vos itérations.
Pour déclarer un `Model`, créez une sous-classe de `Model` et implémentez une fonction `predict` qui prend un exemple en paramètre et renvoie la réponse.
L’exemple de modèle suivant utilise OpenAI pour extraire le nom, la couleur et la saveur de fruits extraterrestres à partir des phrases fournies en entrée.
```python lines {1,5} theme={"system"}
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={"system"}
// @noErrors
// Remarque : weave.Model n’est pas encore pris en charge en TypeScript.
// Encapsulez plutôt 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` (elle en est une sous-classe) afin que Weave puisse suivre l’objet instancié. Le décorateur `@weave.op` appliqué à la fonction `predict` permet de suivre ses entrées et ses sorties.
Vous pouvez instancier des objets `Model` comme suit :
```python lines theme={"system"}
# Définissez le nom de votre équipe et de votre 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 Jupyter Notebook, exécutez :
# await model.predict(sentence)
```
```typescript twoslash theme={"system"}
// @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 dataset
Maintenant que votre `Model` est défini, il vous faut un dataset sur lequel l’évaluer. Un [`Dataset`](/fr/products/wandb/weave/guides/core-types/datasets) est une collection d’exemples stockée sous forme d’objet Weave. Publier le dataset vers Weave permet de le versionner et de le réutiliser d’un run d’évaluation à l’autre.
L’exemple de dataset suivant définit trois phrases d’entrée et leurs réponses attendues (`labels`), puis les met en forme dans un tableau JSON exploitable par les fonctions de score.
Cet exemple construit une liste d’exemples directement dans le code, mais vous pouvez également les journaliser un par un depuis votre application en cours d’exécution.
```python lines theme={"system"}
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={"system"}
// @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 dataset à l’aide de la classe `weave.Dataset()`, puis publiez-le :
```python lines {2} theme={"system"}
weave.init('eval_pipeline_quickstart')
dataset = weave.Dataset(name='fruits', rows=examples)
weave.publish(dataset)
```
```typescript twoslash lines {3-6} theme={"system"}
// @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 disposez d’un modèle et d’un dataset, il vous faut un moyen de mesurer les performances du modèle sur chaque exemple. Les fonctions de score comparent la sortie du modèle à la cible attendue et produisent les métriques présentées dans les résultats d’une évaluation.
Lorsque vous utilisez les évaluations Weave, Weave attend une `target` à laquelle comparer `output`. La fonction de score suivante prend deux dictionnaires (`target` et `output`) et renvoie un dictionnaire de valeurs booléennes qui indiquent 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={"system"}
@weave.op()
def fruit_name_score(target: dict, output: dict) -> dict:
return {'correct': target['fruit'] == output['fruit']}
```
```typescript twoslash theme={"system"}
// @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 [Évaluateurs](/fr/products/wandb/weave/guides/evaluation/scorers).
Dans certaines applications, il peut être utile de créer des classes `Scorer` personnalisées. Vous pouvez par exemple créer une classe `LLMJudge` standardisée avec des paramètres spécifiques (comme le modèle de chat ou le prompt), une logique de score propre à chaque ligne et un calcul de score agrégé. Pour plus d’informations, consultez le tutoriel sur la définition d’une classe `Scorer` dans [Évaluation d’applications RAG basée sur un modèle](/fr/products/wandb/weave/tutorial-rag#optional-defining-a-scorer-class).
Utiliser un évaluateur intégré et exécuter l’évaluation
Maintenant que le modèle, le dataset et un évaluateur personnalisé sont en place, vous pouvez tout assembler dans un run d’évaluation.
Outre les fonctions de score personnalisées, vous pouvez également utiliser les [évaluateurs intégrés de Weave](/fr/products/wandb/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 des [scores F1](https://en.wikipedia.org/wiki/F-score).
L’exemple suivant évalue `ExtractFruitsModel` sur le dataset `fruits` à l’aide des deux fonctions de score, puis journalise les résultats dans Weave.
```python lines {3-10} theme={"system"}
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 Jupyter Notebook, exécutez :
# await evaluation.evaluate(model)
```
```typescript twoslash lines {5-9} theme={"system"}
// @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 le code depuis un script Python, vous devez utiliser `asyncio.run`. En revanche, depuis un notebook Jupyter, vous pouvez utiliser `await` directement.
Exemple complet
```python lines theme={"system"}
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 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={"system"}
// @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.
// Encapsulez plutôt votre fonction faisant office de 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);
```
Afficher les résultats de votre évaluation
Une fois l’évaluation terminée, vous pouvez examiner chaque prédiction et chaque résultat d’évaluateur dans l’interface de Weights & Biases. Weave capture automatiquement les traces de chaque prédiction et de chaque score. Pour consulter les résultats, cliquez sur le lien affiché par l’évaluation.
En savoir plus sur les évaluations Weave
Vous disposez désormais d’un pipeline d’évaluation complet. Pour aller plus loin avec les fonctionnalités d’évaluation de Weave, consultez les ressources suivantes :
* Découvrez comment [créer et utiliser des évaluateurs](/fr/products/wandb/weave/guides/evaluation/scorers).
* Consultez les [fonctions de score intégrées](/fr/products/wandb/weave/guides/evaluation/builtin_scorers) de Weave.
* Découvrez l’[évaluation basée sur des modèles](/fr/products/wandb/weave/guides/evaluation/scorers#model-based-evaluation), qui utilise des LLM comme juges.
Étapes suivantes
[Créez une application RAG](/fr/products/wandb/weave/tutorial-rag) pour découvrir comment évaluer la génération augmentée par récupération.
## Related topics
- [Créer une évaluation](/fr/products/wandb/weave/reference/service-api/evaluations/evaluation-create.md)
