> ## 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.

# Introduction aux évaluations

> Découvrez comment utiliser les évaluations avec W&B Weave grâce à cette introduction

<Note>
  Ceci est un notebook interactif. Vous pouvez l’exécuter localement ou utiliser les liens suivants :

  * [Ouvrir dans Google Colab](https://colab.research.google.com/github/wandb/docs/blob/main/weave/cookbooks/source/Intro_to_Weave_Hello_Eval.ipynb)
  * [Voir la source sur GitHub](https://github.com/wandb/docs/blob/main/weave/cookbooks/source/Intro_to_Weave_Hello_Eval.ipynb)
</Note>

Ce notebook présente les évaluations W\&B Weave à l’aide d’un exemple minimal de bout en bout. Vous allez définir un `Model` Weave, l’exécuter sur un petit dataset, attribuer un score à ses sorties à l’aide d’une fonction de score personnalisée, puis examiner les résultats dans Weave. Il s’adresse aux développeurs qui découvrent Weave et recherchent un point de départ rapide et concret avant d’aborder des flux de travail d’évaluation plus avancés.

<h2 id="prerequisites">
  Prérequis
</h2>

Avant d’exécuter une évaluation Weave, remplissez les prérequis suivants.

1. Installez le SDK W\&B Weave et connectez-vous avec votre [clé API](https://forge.coreweave.com/settings#apikeys).
2. Installez le SDK d’OpenAI et connectez-vous avec votre [clé API](https://platform.openai.com/api-keys).
3. Initialisez votre projet Weights & Biases.

```python lines theme={"system"}
# Installer les dépendances et effectuer les imports
!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
# Lorsque vous exécutez cette cellule, `getpass` vous invite à saisir votre clé API sans l’afficher dans le terminal.
#####
print("---")
print(
    "Create a W&B API key at: https://forge.coreweave.com/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("---")
#####

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

<h2 id="run-your-first-evaluation">
  Exécuter votre première évaluation
</h2>

Une fois votre environnement configuré, vous pouvez 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 créant une sous-classe de `weave.Model`, en spécifiant le nom du modèle et le format du prompt, et 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 sortie structurée à l'aide d'un schéma Pydantic (`FruitExtract`). Créez ensuite un petit dataset d'évaluation composé de phrases d'entrée et des cibles attendues. Définissez ensuite une fonction de score personnalisée (dont le suivi est également assuré par `@weave.op`) qui compare la sortie du modèle à l'étiquette cible. Enfin, encapsulez le tout dans un objet `weave.Evaluation` en spécifiant votre dataset et vos évaluateurs, puis appelez `evaluate()` pour exécuter le pipeline d'évaluation de manière asynchrone.

```python lines theme={"system"}
# 1. Créer 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. Rassembler 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’une des saveurs cibles figure parmi les saveurs de la sortie
    matches = any(tf in of for tf in target_flavors for of in output_flavors)
    return {"correct": matches}

# 4. Lancer 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 dataset et les scores par exemple dans votre projet, afin que vous puissiez examiner les résultats dans l’interface de Weights & Biases.

<h2 id="looking-for-more-examples">
  Vous cherchez d’autres exemples ?
</h2>

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

* Découvrez comment [créer un pipeline d’évaluation de bout en bout](/fr/products/wandb/weave/tutorial-eval).
* Découvrez comment [évaluer une application RAG](/fr/products/wandb/weave/tutorial-rag).