Passer au contenu principal
Il s’agit d’un notebook interactif. Vous pouvez l’exécuter en local ou utiliser les liens suivants :
Ce notebook présente les évaluations W&B Weave à travers un exemple minimal de bout en bout. Vous définissez un Model Weave, l’exécutez sur un petit jeu de données, attribuez un score aux sorties avec une fonction de score personnalisée, puis examinez les résultats dans Weave. Il s’adresse aux développeurs qui découvrent Weave et souhaitent un point de départ rapide et pratique avant d’explorer des flux de travail d’évaluation plus avancés.

​
Prérequis

Avant de pouvoir exécuter une évaluation Weave, assurez-vous d’avoir effectué les prérequis suivants.
  1. Installez le SDK W&B Weave et connectez-vous avec votre clé API.
  2. Installez l’OpenAI SDK et connectez-vous avec votre clé API.
  3. Initialisez votre projet W&B.
# Installer les dépendances et importer les modules
!pip install wandb weave openai -q

import os
from getpass import getpass

from openai import OpenAI
from pydantic import BaseModel

import weave

# 🔑 Configurer vos clés API
# L'exécution de cette cellule vous demandera votre clé API via `getpass` et ne l'affichera pas dans le terminal.
#####
print("---")
print(
    "Create a W&B API key at: https://wandb.ai/settings#apikeys"
)
os.environ["WANDB_API_KEY"] = getpass("Enter your W&B API key: ")
print("---")
print("You can generate your OpenAI API key here: https://platform.openai.com/api-keys")
os.environ["OPENAI_API_KEY"] = getpass("Enter your OpenAI API key: ")
print("---")
#####

# 🏠 Entrez le nom de votre projet W&B
weave_client = weave.init("MY_PROJECT_NAME")  # 🐝 Le nom de votre projet W&B

​
Lancez votre première évaluation

Une fois votre environnement configuré, vous êtes prêt à définir et à exécuter une évaluation. L’exemple de code suivant montre comment évaluer un LLM à l’aide des API Model et Evaluation de Weave. Commencez par définir un modèle Weave en héritant de weave.Model, en indiquant le nom du modèle et le format du prompt, puis en assurant le suivi d’une méthode predict avec @weave.op. La méthode predict envoie un prompt à OpenAI et convertit la réponse en une sortie structurée à l’aide d’un schéma Pydantic (FruitExtract). Créez ensuite un petit jeu de données d’évaluation composé de phrases en entrée et de cibles attendues. Définissez ensuite une fonction de score personnalisée (également suivie avec @weave.op) qui compare la sortie du modèle au libellé cible. Enfin, encapsulez le tout dans un weave.Evaluation, en spécifiant votre jeu de données et vos évaluateurs, puis appelez evaluate() pour exécuter le pipeline d’évaluation de manière asynchrone. 
# 1. Construire un modèle Weave
class FruitExtract(BaseModel):
    fruit: str
    color: str
    flavor: str

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

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

        response = client.beta.chat.completions.parse(
            model=self.model_name,
            messages=[
                {
                    "role": "user",
                    "content": self.prompt_template.format(sentence=sentence),
                }
            ],
            response_format=FruitExtract,
        )
        result = response.choices[0].message.parsed
        return result

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

# 2. Collecter quelques exemples
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": "green", "flavor": "savory"},
    {"fruit": "glowls", "color": "orange", "flavor": "sour, 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]},
]

# 3. Définir une fonction de score pour votre évaluation
@weave.op()
def fruit_name_score(target: dict, output: FruitExtract) -> dict:
    target_flavors = [f.strip().lower() for f in target["flavor"].split(",")]
    output_flavors = [f.strip().lower() for f in output.flavor.split(",")]
    # Vérifier si l'un des arômes cibles est présent dans les arômes de sortie
    matches = any(tf in of for tf in target_flavors for of in output_flavors)
    return {"correct": matches}

# 4. Exécuter votre évaluation
evaluation = weave.Evaluation(
    name="fruit_eval",
    dataset=examples,
    scorers=[fruit_name_score],
)
await evaluation.evaluate(model)
Une fois l’évaluation terminée, Weave journalise le modèle, le jeu de données et les scores par exemple dans votre projet afin que vous puissiez inspecter les résultats dans l’interface Weave.

​
Vous cherchez d’autres exemples

Maintenant que vous avez exécuté une évaluation de base, vous pouvez explorer des flux de travail plus avancés dans les tutoriels suivants :