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

# Évaluations avec des datasets HuggingFace

> Découvrez comment utiliser des évaluations basées sur des datasets HuggingFace avec W&B Weave

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

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

Ce notebook vous montre comment utiliser un dataset HuggingFace comme source d’entrée pour une `Evaluation` Weave. À la fin, vous disposerez d’un pipeline d’évaluation fonctionnel qui fait référence aux lignes d’un dataset HuggingFace par leur index, prétraite chaque ligne pour la convertir au format attendu par votre modèle et suit les résultats évalués dans Weave. Cette approche est utile lorsque vous souhaitez évaluer des modèles sur des datasets HuggingFace existants sans avoir à les convertir au préalable en dataset natif Weave.

<Note>
  Ce guide présente une solution de contournement pour utiliser des datasets HuggingFace avec les évaluations Weave. Cette approche fonctionne dès aujourd’hui, et des intégrations plus transparentes pour les datasets externes sont en cours de développement.
</Note>

<h2 id="setup-and-imports">
  Configuration et importations
</h2>

Commencez par initialiser Weave et par vous connecter à W\&B afin que Weave suive les runs d’évaluation et leurs résultats dans votre projet Weave.

```python lines theme={"system"}
!pip install datasets wandb weave

# Initialiser les variables
HUGGINGFACE_DATASET = "wandb/ragbench-test-sample"
WANDB_KEY = ""
WEAVE_TEAM = ""
WEAVE_PROJECT = ""

# Initialiser Weave et importer les bibliothèques requises
import asyncio

import nest_asyncio
import wandb
from datasets import load_dataset

import weave
from weave import Evaluation

# Se connecter à wandb et initialiser Weave
wandb.login(key=WANDB_KEY)
client = weave.init(f"{WEAVE_TEAM}/{WEAVE_PROJECT}")

# Appliquer nest_asyncio pour autoriser les boucles d’événements imbriquées (nécessaire dans certains environnements de notebooks)
nest_asyncio.apply()
```

<h2 id="load-and-prepare-huggingface-dataset">
  Charger et préparer le dataset HuggingFace
</h2>

Chargez ensuite le dataset HuggingFace et créez un index léger que l’évaluation parcourra. Au lieu de transmettre directement les lignes du dataset à Weave, transmettez une liste de références d’index, puis résolvez-les en lignes complètes lors du prétraitement. Cette approche permet de garder l’évaluation liée au dataset HuggingFace d’origine et d’en conserver les références.

<Note>
  Dans l’index, encodez le `hf_hub_name` avec le `hf_id` afin que chaque ligne dispose d’un identifiant unique. Weave utilise cette valeur de digest unique pour suivre et référencer des entrées précises du dataset lors des évaluations.
</Note>

```python lines theme={"system"}
# Charger le jeu de données HuggingFace
ds = load_dataset(HUGGINGFACE_DATASET)
row_count = ds["train"].num_rows

# Créer un mappage d’index pour le jeu de données
# Génère une liste de dictionnaires contenant les index du jeu de données HF
# Exemple : [{"hf_id": 0}, {"hf_id": 1}, {"hf_id": 2}, ...]
hf_index = [{"hf_id": i, "hf_hub_name": HUGGINGFACE_DATASET} for i in range(row_count)]
```

<h2 id="define-processing-and-evaluation-functions">
  Définir les fonctions de traitement et d’évaluation
</h2>

Une fois l’index en place, définissez les trois fonctions qui composent le pipeline d’évaluation : l’une pour transformer chaque référence de l’index en exemple exploitable, une autre pour attribuer un score à la sortie du modèle, et une dernière qui représente le modèle évalué.

Le pipeline de traitement utilise les fonctions suivantes :

* `preprocess_example` : transforme la référence de l’index en données effectivement nécessaires à l’évaluation.
* `hf_eval` : définit la façon d’attribuer un score aux sorties du modèle.
* `function_to_evaluate` : la fonction ou le modèle évalué proprement dit.

```python lines theme={"system"}
@weave.op()
def preprocess_example(example):
    """
    Preprocesses each example before evaluation.
    Args:
        example: Dict containing hf_id
    Returns:
        Dict containing the prompt from the HF dataset
    """
    hf_row = ds["train"][example["hf_id"]]
    return {"prompt": hf_row["question"], "answer": hf_row["response"]}

@weave.op()
def hf_eval(hf_id: int, output: dict) -> dict:
    """
    Scoring function for evaluating model outputs.
    Args:
        hf_id: Index in the HF dataset
        output: The output from the model to evaluate
    Returns:
        Dict containing evaluation scores
    """
    hf_row = ds["train"][hf_id]
    return {"scorer_value": True}

@weave.op()
def function_to_evaluate(prompt: str):
    """
    The function that will be evaluated (e.g., your model or pipeline).
    Args:
        prompt: Input prompt from the dataset
    Returns:
        Dict containing model output
    """
    return {"generated_text": "testing "}
```

<h2 id="create-and-run-the-evaluation">
  Créer et exécuter l’évaluation
</h2>

Enfin, reliez l’index, le scorer et la fonction de prétraitement au sein d’un objet `Evaluation` Weave, puis exécutez-le sur le modèle. Pour chaque entrée de `hf_index`, Weave effectue les étapes suivantes :

1. `preprocess_example` récupère les données correspondantes dans le dataset HuggingFace.
2. Weave transmet les données prétraitées à `function_to_evaluate`.
3. `hf_eval` attribue un score à la sortie.
4. Weave assure le suivi des résultats.

Une fois l’évaluation terminée, vous pouvez examiner le run et ses scores ligne par ligne dans votre projet Weave.

```python lines theme={"system"}
# Créer l’objet d’évaluation
evaluation = Evaluation(
    dataset=hf_index,  # Utiliser notre mappage d’index
    scorers=[hf_eval],  # Liste des fonctions de score
    preprocess_model_input=preprocess_example,  # Fonction de préparation des entrées
)

# Exécuter l’évaluation en mode asynchrone
async def main():
    await evaluation.evaluate(function_to_evaluate)

asyncio.run(main())
```