Acheminement personnalisé avec Not Diamond

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

Ce notebook montre comment utiliser Weave avec l’acheminement 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 de ce notebook, vous aurez entraîné un routeur personnalisé pour des prompts de programmation, vous l’aurez utilisé pour choisir un modèle cible pour un nouveau prompt, puis vous aurez comparé ses performances à celles du meilleur modèle pris individuellement.

Acheminement des prompts

Cette section explique l’intérêt d’un acheminement personnalisé lorsque vous travaillez avec plusieurs LLM. Lorsque vous créez des flux de travail LLM complexes, vous pouvez avoir besoin d’envoyer des prompts à différents modèles en fonction de la précision, du coût ou de la latence des appels. Vous pouvez utiliser Not Diamond pour acheminer les prompts de ces flux de travail vers le modèle le mieux adapté à vos besoins, afin de maximiser la précision tout en réduisant les coûts liés aux modèles. Quelle que soit la distribution des données, 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 appeler chaque LLM, vous pouvez dépasser les performances de chaque modèle pris individuellement, et même réduire les coûts et la latence.

Acheminement personnalisé

Pour entraîner un routeur personnalisé pour vos prompts, vous devez fournir les entrées suivantes :

Un ensemble de prompts de LLM : les prompts doivent être des chaînes de caractères représentatives des prompts utilisés dans votre application.
Réponses des LLM : les réponses des LLM candidats pour chaque entrée. Les LLM candidats peuvent inclure aussi bien des LLM pris en charge que vos propres modèles personnalisés.
Scores d’évaluation des réponses des LLM candidats aux entrées : les scores sont des nombres et peuvent correspondre à n’importe quelle métrique adaptée à vos besoins.

Une fois ces éléments soumis à l’API Not Diamond, vous pouvez 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é s’appuie pour apprendre. En pratique, vous utilisez vos propres évaluations pour entraîner un routeur personnalisé. Dans ce notebook d’exemple, en revanche, vous utilisez des réponses de LLM sur le dataset HumanEval afin d’entraîner un routeur personnalisé pour des tâches de programmation. Commencez par télécharger le dataset préparé pour cet exemple, puis analysez les réponses des LLM pour les convertir en EvaluationResults pour chaque modèle. Cette répartition entre données d’entraînement et de test sert dans les sections suivantes à 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 à partir de votre dataset, puis 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 les EvaluationResults préparés, vous pouvez 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 insérez votre clé API dans le code ci-dessous. Cette clé API sert à authentifier la requête d’entraînement.

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 cette ligne pour réentraîner votre routeur personnalisé existant
    # preference_id=preference_id,
)

Vous pouvez ensuite suivre l’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 acheminer 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 a également tiré parti de la compatibilité de Not Diamond avec le traçage automatique de Weave. Vous pouvez consulter les résultats dans l’interface utilisateur de Weights & Biases.

Interface utilisateur de Weights & Biases pour l’acheminement personnalisé

Évaluez votre routeur personnalisé

Cette section explique comment déterminer si le routeur personnalisé fait mieux que le meilleur modèle pris individuellement. Une fois votre routeur personnalisé entraîné, vous pouvez évaluer ses performances de l’une des manières suivantes :

Performances sur l’échantillon d’entraînement, en soumettant les prompts d’entraînement.
Performances hors échantillon, en soumettant de nouveaux prompts ou des prompts réservés à la validation.

Dans l’exemple suivant, vous soumettez le jeu 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:
    # On détourne score, car nous disposons déjà des réponses des modèles
    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 ce cas, le « méta-modèle » de 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 utilisateur de Weights & Biases. Une fois l’entraînement du routeur personnalisé terminé, vous pouvez examiner les résultats dans l’interface utilisateur de Weights & Biases. Dans l’interface utilisateur, vous pouvez constater que le « méta-modèle » de Not Diamond surpasse le modèle le plus performant en acheminant les prompts vers d’autres modèles plus susceptibles d’y répondre correctement.

​Acheminement des prompts

​Acheminement personnalisé

​Configurer les données d’entraînement

​Entraîner un routeur personnalisé

​Évaluez votre routeur personnalisé

Acheminement des prompts

Acheminement personnalisé

Configurer les données d’entraînement

Entraîner un routeur personnalisé

Évaluez votre routeur personnalisé