Évaluations avec des datasets HuggingFace

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

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.

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.

Configuration et importations

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.

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

Charger et préparer le dataset HuggingFace

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.

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.

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

Définir les fonctions de traitement et d’évaluation

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.

@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 "}

Créer et exécuter l’évaluation

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 :

preprocess_example récupère les données correspondantes dans le dataset HuggingFace.
Weave transmet les données prétraitées à function_to_evaluate.
hf_eval attribue un score à la sortie.
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.

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

​Configuration et importations

​Charger et préparer le dataset HuggingFace

​Définir les fonctions de traitement et d’évaluation

​Créer et exécuter l’évaluation

Configuration et importations

Charger et préparer le dataset HuggingFace

Définir les fonctions de traitement et d’évaluation

Créer et exécuter l’évaluation