Créer une évaluation - CoreWeave Docs

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 et Evaluation. Ces API reposent sur un minimum d’hypothèses, ce qui leur permet de s’adapter à de nombreux cas d’usage. Illustration des évaluations

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
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 définie dans une variable d’environnement.

Importer les bibliothèques et 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 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
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.
// 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": <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 (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
TypeScript

# 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": <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 Jupyter Notebook, 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 dataset

Maintenant que votre Model est défini, il vous faut un dataset sur lequel l’évaluer. Un Dataset 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
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 dataset à l’aide de la classe weave.Dataset(), puis 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 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
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 Évaluateurs. 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.

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. 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. L’exemple suivant évalue ExtractFruitsModel sur le dataset fruits à l’aide des deux fonctions de score, puis 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 Jupyter Notebook, 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 le code depuis un script Python, vous devez utiliser asyncio.run. En revanche, depuis un notebook Jupyter, vous pouvez utiliser await directement.

Exemple complet

Pipeline d’évaluation complet dans un seul script :

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

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": <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 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. Résultats de 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.
Consultez les fonctions de score intégrées de Weave.
Découvrez l’évaluation basée sur des modèles, qui utilise des LLM comme juges.

Étapes suivantes

Créez une application RAG pour découvrir comment évaluer la génération augmentée par récupération.

​Ce que vous allez apprendre

​Prérequis

​Importer les bibliothèques et fonctions nécessaires

​Créer un Model

​Créer un dataset

​Définir des fonctions de score personnalisées

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

​Exemple complet

​Afficher les résultats de votre évaluation

​En savoir plus sur les évaluations Weave

​Étapes suivantes

Ce que vous allez apprendre

Prérequis

Importer les bibliothèques et fonctions nécessaires

Créer un `Model`

Créer un dataset

Définir des fonctions de score personnalisées

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

Exemple complet

Afficher les résultats de votre évaluation

En savoir plus sur les évaluations Weave

Étapes suivantes