Passer au contenu principal
Il s’agit d’un notebook interactif. Vous pouvez l’exécuter en local ou utiliser les liens ci-dessous :

​
Utiliser HuggingFace jeux de données pour les évaluations avec preprocess_model_input

​
Remarque : il s’agit d’une solution de contournement temporaire

Ce guide présente une solution de contournement pour utiliser HuggingFace jeux de données dans les évaluations Weave.

Nous travaillons activement à des intégrations plus fluides qui simplifieront ce processus. Bien que cette approche fonctionne, attendez-vous à des améliorations et à des mises à jour prochainement, qui rendront l’utilisation de jeux de données externes plus simple.

​
Configuration et importations

Tout d’abord, nous initialisons Weave et nous nous connectons à Weights & Biases afin de suivre les expériences. 
!pip install datasets wandb weave
python
# Initialiser les variables
HUGGINGFACE_DATASET = "wandb/ragbench-test-sample"
WANDB_KEY = ""
WEAVE_TEAM = ""
WEAVE_PROJECT = ""

# Initialiser weave et 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 notebook)
nest_asyncio.apply()

​
Charger et préparer le jeu de données HuggingFace

  • Nous chargeons un jeu de données HuggingFace.
  • Nous créons un mappage d’index pour référencer les lignes du jeu de dataset.
  • Cette approche par index nous permet de conserver des références au jeu de données original.
Remarque :
Dans l’index, nous encodons hf_hub_name ainsi que hf_id afin de garantir que chaque ligne dispose d’un identifiant unique. Cette valeur de condensé unique est utilisée pour assurer le suivi et référencer des entrées spécifiques du jeu de données 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
# Ceci crée une liste de dicts avec les indices 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

​
Pipeline de traitement

  • preprocess_example : transforme la référence de l’index en données effectives nécessaires à l’évaluation
  • hf_eval : définit comment calculer le score des sorties du modèle
  • function_to_evaluate : la fonction/le modèle effectivement évalué
@weave.op()
def preprocess_example(example):
    """
    Prétraite chaque exemple avant l'évaluation.
    Args:
        example: Dict contenant hf_id
    Returns:
        Dict contenant le prompt du jeu de données HF
    """
    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:
    """
    Fonction de scoring pour évaluer les sorties du modèle.
    Args:
        hf_id: Index dans le jeu de données HF
        output: La sortie du modèle à évaluer
    Returns:
        Dict contenant les scores d'évaluation
    """
    hf_row = ds["train"][hf_id]
    return {"scorer_value": True}

@weave.op()
def function_to_evaluate(prompt: str):
    """
    La fonction qui sera évaluée (par exemple, votre modèle ou pipeline).
    Args:
        prompt: Prompt d'entrée issu du jeu de données
    Returns:
        Dict contenant la sortie du modèle
    """
    return {"generated_text": "testing "}

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

  • Pour chaque index de hf_index :
    1. preprocess_example récupère les données correspondantes du jeu de données HF.
    2. Les données prétraitées sont transmises à function_to_evaluate.
    3. La sortie est évaluée à l’aide de hf_eval.
    4. Les résultats sont suivis dans Weave.
# Créer l'objet d'évaluation
evaluation = Evaluation(
    dataset=hf_index,  # Utiliser notre mappage d'index
    scorers=[hf_eval],  # Liste des fonctions de scoring
    preprocess_model_input=preprocess_example,  # Fonction pour préparer les entrées
)

# Exécuter l'évaluation de façon asynchrone
async def main():
    await evaluation.evaluate(function_to_evaluate)

asyncio.run(main())