> ## 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.
# Acheminement personnalisé avec Not Diamond
> Découvrez comment utiliser l’acheminement personnalisé de Not Diamond avec W&B Weave
Ceci est un notebook interactif. Vous pouvez l’exécuter localement ou utiliser les liens suivants :
* [Ouvrir dans Google Colab](https://colab.research.google.com/github/wandb/docs/blob/main/weave/cookbooks/source/notdiamond_custom_routing.ipynb)
* [Voir la source sur GitHub](https://github.com/wandb/docs/blob/main/weave/cookbooks/source/notdiamond_custom_routing.ipynb)
Ce notebook montre comment utiliser Weave avec [l’acheminement personnalisé de Not Diamond](https://docs.notdiamond.ai/docs/router-training-quickstart) 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](https://www.notdiamond.ai/) 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 :
1. **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.
2. **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.
3. **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](https://github.com/openai/human-eval) 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.
```python lines theme={"system"}
!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](https://app.notdiamond.ai/keys) et
[généré une clé API](https://app.notdiamond.ai/keys), puis insérez votre clé API dans le code ci-dessous. Cette clé API sert à authentifier la requête d’entraînement.
```python lines theme={"system"}
import os
from weave.integrations.notdiamond.custom_router import train_router
api_key = os.getenv("NOTDIAMOND_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.
Une fois l’entraînement de votre routeur personnalisé terminé, vous pouvez l’utiliser pour acheminer vos prompts.
```python lines theme={"system"}
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.
É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.
```python lines theme={"system"}
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.
