> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduction aux évaluations

> Découvrez comment utiliser cette introduction aux évaluations avec W&B Weave

<Note>
  Il s'agit d'un notebook interactif. Vous pouvez l'exécuter en local 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 à 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.

<div id="prerequisites">
  ## Prérequis
</div>

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](https://wandb.ai/settings#apikeys).
2. Installez l’OpenAI SDK et connectez-vous avec votre [clé API](https://platform.openai.com/api-keys).
3. Initialisez votre projet W\&B.

```python lines theme={null}
# 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
```

<div id="run-your-first-evaluation">
  ## Lancez votre première évaluation
</div>

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.

```python lines theme={null}
# 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.

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

Maintenant que vous avez exécuté 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/weave/tutorial-eval).
* Découvrez comment [évaluer une application RAG](/fr/weave/tutorial-rag).