Passer au contenu principal
Il s’agit d’un notebook interactif. Vous pouvez l’exécuter localement ou utiliser les liens suivants :
Ce notebook montre comment utiliser Weave avec le routage personnalisé de Not Diamond pour acheminer des prompts de LLM vers le modèle le plus adapté, en fonction des résultats d’évaluation. À la fin, vous aurez entraîné un routeur personnalisé pour des prompts de code, l’aurez utilisé pour sélectionner un modèle cible pour un nouveau prompt et aurez évalué ses performances par rapport au meilleur modèle pris individuellement.

​
Routage des prompts

Cette section explique pourquoi le routage personnalisé est utile lorsque vous travaillez avec plusieurs LLM. Lors de la création de flux de travail LLM complexes, vous pouvez avoir besoin de router les prompts vers différents modèles en fonction de la précision, du coût ou de la latence d’appel. Vous pouvez utiliser Not Diamond pour router les prompts dans ces flux de travail vers le modèle le plus adapté à vos besoins, afin de maximiser la précision tout en réduisant les coûts des modèles. Pour une distribution de données donnée, il est rare qu’un seul modèle surpasse tous les autres sur chaque requête. En combinant plusieurs modèles au sein d’un « méta-modèle » qui apprend quand faire appel à chaque LLM, vous pouvez surpasser les performances de chaque modèle pris individuellement, tout en réduisant au passage les coûts et la latence.

​
Routage personnalisé

Les entrées suivantes sont requises pour entraîner un routeur personnalisé pour vos prompts :
  1. Un ensemble de prompts LLM : Les prompts doivent être des chaînes de caractères et doivent être représentatifs des prompts utilisés dans votre application.
  2. Réponses LLM : Les réponses des LLM candidats pour chaque entrée. Les LLM candidats peuvent inclure à la fois des LLM pris en charge et vos propres modèles personnalisés.
  3. Scores d’évaluation des réponses aux entrées des LLM candidats : Les scores sont des valeurs numériques et peuvent correspondre à n’importe quelle métrique adaptée à vos besoins.
En soumettant ces éléments à l’API Not Diamond, vous pouvez ensuite entraîner un routeur personnalisé adapté à chacun de vos flux de travail.

​
Configurer les données d’entraînement

Dans cette section, vous préparez les données d’entraînement et de test sur lesquelles le routeur personnalisé apprend. En pratique, vous utilisez vos propres évaluations pour entraîner un routeur personnalisé. Pour ce notebook d’exemple, toutefois, vous utilisez des réponses de LLM pour le jeu de données HumanEval afin d’entraîner un routeur personnalisé pour des tâches de programmation. Commencez par télécharger le jeu de données préparé pour cet exemple, puis convertissez les réponses de LLM en EvaluationResults pour chaque modèle. Cette répartition entre données d’entraînement et de test est utilisée dans les sections suivantes pour entraîner le routeur et évaluer ses performances hors échantillon. 
!curl -L "https://drive.google.com/uc?export=download&id=1q1zNZHioy9B7M-WRjsJPkfvFosfaHX38" -o humaneval.csv
python
import random

import weave
from weave.flow.dataset import Dataset
from weave.flow.eval import EvaluationResults
from weave.integrations.notdiamond.util import get_model_evals

pct_train = 0.8
pct_test = 1 - pct_train

# En pratique, vous créerez une Évaluation sur votre jeu de données et appellerez
# `evaluation.get_eval_results(model)`
model_evals = get_model_evals("./humaneval.csv")
model_train = {}
model_test = {}
for model, evaluation_results in model_evals.items():
    n_results = len(evaluation_results.rows)
    all_idxs = list(range(n_results))
    train_idxs = random.sample(all_idxs, k=int(n_results * pct_train))
    test_idxs = [idx for idx in all_idxs if idx not in train_idxs]

    model_train[model] = EvaluationResults(
        rows=weave.Table([evaluation_results.rows[idx] for idx in train_idxs])
    )
    model_test[model] = Dataset(
        rows=weave.Table([evaluation_results.rows[idx] for idx in test_idxs])
    )
    print(
        f"Found {len(train_idxs)} train rows and {len(test_idxs)} test rows for {model}."
    )

​
Entraîner un routeur personnalisé

Une fois EvaluationResults préparés, vous pouvez maintenant les soumettre à Not Diamond pour entraîner un routeur personnalisé. Assurez-vous d’avoir créé un compte et généré une clé API, puis renseignez votre clé API dans le code suivant. La clé API sert à authentifier la requête d’entraînement.
Créer une clé API
import os

from weave.integrations.notdiamond.custom_router import train_router

api_key = os.getenv("NOTDIAMOND_API_KEY", "<YOUR_API_KEY>")

preference_id = train_router(
    model_evals=model_train,
    prompt_column="prompt",
    response_column="actual",
    language="en",
    maximize=True,
    api_key=api_key,
    # Laissez cette ligne commentée pour entraîner votre premier routeur personnalisé
    # Décommentez-la pour réentraîner votre routeur personnalisé en place
    # preference_id=preference_id,
)
Vous pouvez ensuite suivre le processus d’entraînement de votre routeur personnalisé dans l’application Not Diamond.
Suivre la progression de l'entraînement du routeur
Une fois l’entraînement de votre routeur personnalisé terminé, vous pouvez l’utiliser pour router vos prompts. 
from notdiamond import NotDiamond

import weave

weave.init("notdiamond-quickstart")

llm_configs = [
    "anthropic/claude-3-5-sonnet-20240620",
    "openai/gpt-4o-2024-05-13",
    "google/gemini-1.5-pro-latest",
    "openai/gpt-4-turbo-2024-04-09",
    "anthropic/claude-3-opus-20240229",
]
client = NotDiamond(api_key=api_key, llm_configs=llm_configs)

new_prompt = (
    """
You are a helpful coding assistant. Using the provided function signature, write the implementation for the function
in Python. Write only the function. Do not include any other text.

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """
    """ Check if in given list of numbers, are any two numbers closer to each other than
    given threshold.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """
    """
"""
)
session_id, routing_target_model = client.model_select(
    messages=[{"role": "user", "content": new_prompt}],
    preference_id=preference_id,
)

print(f"Session ID: {session_id}")
print(f"Target Model: {routing_target_model}")
Cet exemple utilisait aussi la compatibilité de Not Diamond avec le Tracing automatique de Weave. Vous pouvez voir les résultats dans l’interface Weave. interface Weave pour le routage personnalisé

​
Évaluez votre routeur personnalisé

Cette section montre comment déterminer si le routeur personnalisé fait mieux que le meilleur modèle pris individuellement. Une fois que vous avez entraîné votre routeur personnalisé, vous pouvez évaluer ses performances de l’une des manières suivantes :
  • Performances sur l’échantillon en soumettant les prompts d’entraînement.
  • Performances hors échantillon en soumettant de nouveaux prompts ou des prompts de validation.
Dans l’exemple suivant, vous soumettez l’ensemble de test au routeur personnalisé pour évaluer ses performances. 
from weave.integrations.notdiamond.custom_router import evaluate_router

eval_prompt_column = "prompt"
eval_response_column = "actual"

best_provider_model, nd_model = evaluate_router(
    model_datasets=model_test,
    prompt_column=eval_prompt_column,
    response_column=eval_response_column,
    api_key=api_key,
    preference_id=preference_id,
)
python
@weave.op()
def is_correct(score: int, output: dict) -> dict:
    # Nous détournons le score, car nous avons déjà les réponses du modèle
    return {"correct": score}

best_provider_eval = weave.Evaluation(
    dataset=best_provider_model.model_results.to_dict(orient="records"),
    scorers=[is_correct],
)
await best_provider_eval.evaluate(best_provider_model)

nd_eval = weave.Evaluation(
    dataset=nd_model.model_results.to_dict(orient="records"), scorers=[is_correct]
)
await nd_eval.evaluate(nd_model)
Dans cet exemple, le « méta-modèle » Not Diamond achemine les prompts vers plusieurs modèles différents. L’entraînement du routeur personnalisé via Weave exécute également des évaluations et téléverse les résultats dans l’interface Weave. Une fois l’exécution du routeur personnalisé terminée, vous pouvez consulter les résultats dans l’interface Weave. Dans l’interface utilisateur, vous pouvez voir que le « méta-modèle » Not Diamond surpasse le modèle le plus performant en acheminant les prompts vers d’autres modèles plus susceptibles de répondre correctement au prompt.
Évaluation de Not Diamond