> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-wbdocs-1882.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Découvrez Weave avec W&B Inference
> Découvrez les bases de Weave à l’aide de W&B Inference pour tracer les appels au modèle, comparer les sorties et effectuer des évaluations.
export const GitHubLink = ({url}) =>
Source GitHub
;
export const ColabLink = ({url}) =>
Essayer sur Colab
;
Ce guide vous montre comment utiliser W\&B Weave avec [W\&B Inference](https://docs.wandb.ai/inference/). Utilisez W\&B Inference pour créer et tracer des applications LLM à l’aide de modèles open source accessibles en direct, sans avoir à mettre en place votre propre infrastructure ni à gérer des clés API provenant de plusieurs fournisseurs. Avec votre clé API W\&B, vous pouvez interagir avec [tous les modèles hébergés par W\&B Inference](https://docs.wandb.ai/inference/models/).
## Ce que vous allez apprendre
Ce guide vous montre comment :
* Configurer Weave et W\&B Inference
* Créer une application LLM simple avec un tracing automatique
* Comparer plusieurs modèles
* Évaluer les performances du modèle sur un jeu de données
* Consulter vos résultats dans la Weave UI
## Prérequis
* Un [compte W\&B](https://wandb.ai/signup)
* Python 3.8+ ou Node.js 18+
* Packages requis :
* **Python**: `pip install weave openai`
* **TypeScript**: `npm install weave openai`
* Une [clé API OpenAI](https://platform.openai.com/api-keys) configurée comme variable d'environnement
## Tracez votre premier appel à un LLM
Pour commencer, faites un copier-coller de l’exemple de code suivant. Cet exemple utilise Llama 3.1-8B avec W\&B Inference.
Lorsque vous exécutez ce code, Weave :
* Trace automatiquement votre appel à un LLM
* Enregistre les entrées, les sorties, la latence et l’utilisation des tokens
* Fournit un lien pour consulter votre trace dans Weave UI
```python lines theme={null}
import weave
import openai
# Initialisez Weave - remplacez par your-team/your-project
weave.init("/inference-quickstart")
# Créez un client compatible OpenAI pointant vers W&B Inference
client = openai.OpenAI(
base_url='https://api.inference.wandb.ai/v1',
api_key="YOUR_WANDB_API_KEY", # Remplacez par votre clé API réelle
project="/my-first-weave-project", # Requis pour le suivi de l'utilisation
)
# Décorez votre fonction pour activer le tracing ; utilisez le client OpenAI standard
@weave.op()
def ask_llama(question: str) -> str:
response = client.chat.completions.create(
model="meta-llama/Llama-3.1-8B-Instruct",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": question}
],
)
return response.choices[0].message.content
# Appelez votre fonction - Weave trace automatiquement tout
result = ask_llama("What are the benefits of using W&B Weave for LLM development?")
print(result)
```
```typescript lines theme={null}
import * as weave from 'weave';
import OpenAI from 'openai';
// Initialisez Weave - remplacez les valeurs entre "<>" par les vôtres.
await weave.init("/inference-quickstart")
// Créez un client compatible OpenAI pointant vers W&B Inference
const client = new OpenAI({
baseURL: 'https://api.inference.wandb.ai/v1', // Endpoint W&B Inference
apiKey: process.env.WANDB_API_KEY || 'YOUR_WANDB_API_KEY', // Remplacez par votre clé API ou définissez la variable d'environnement WANDB_API_KEY
});
// Encapsulez votre fonction avec weave.op pour activer le tracing
const askLlama = weave.op(async function askLlama(question: string): Promise {
const response = await client.chat.completions.create({
model: 'meta-llama/Llama-3.1-70B-Instruct',
messages: [
{ role: 'system', content: 'You are a helpful assistant.' },
{ role: 'user', content: question }
],
});
return response.choices[0].message.content || '';
});
// Appelez votre fonction - Weave trace automatiquement tout
const result = await askLlama('What are the benefits of using W&B Weave for LLM development?');
console.log(result);
```
## Créer une application de résumé de texte
Ensuite, essayez d’exécuter ce code, une application simple de résumé qui montre comment Weave effectue la trace des opérations imbriquées :
```python lines theme={null}
import weave
import openai
# Initialiser Weave - Remplacez les valeurs entre "<>" par les vôtres.
weave.init("/inference-quickstart")
client = openai.OpenAI(
base_url='https://api.inference.wandb.ai/v1',
api_key="YOUR_WANDB_API_KEY", # Remplacez par votre clé API réelle
project="/my-first-weave-project", # Requis pour le suivi d'utilisation
)
@weave.op()
def extract_key_points(text: str) -> list[str]:
"""Extraire les points clés d'un texte."""
response = client.chat.completions.create(
model="meta-llama/Llama-3.1-8B-Instruct",
messages=[
{"role": "system", "content": "Extrayez 3 à 5 points clés du texte. Retournez chaque point sur une nouvelle ligne."},
{"role": "user", "content": text}
],
)
# Renvoie la réponse sans lignes vides
return [line for line in response.choices[0].message.content.strip().splitlines() if line.strip()]
@weave.op()
def create_summary(key_points: list[str]) -> str:
"""Créer un résumé concis à partir des points clés."""
points_text = "\n".join(f"- {point}" for point in key_points)
response = client.chat.completions.create(
model="meta-llama/Llama-3.1-8B-Instruct",
messages=[
{"role": "system", "content": "Créez un résumé en une phrase à partir de ces points clés."},
{"role": "user", "content": f"Points clés :\n{points_text}"}
],
)
return response.choices[0].message.content
@weave.op()
def summarize_text(text: str) -> dict:
"""Pipeline principal de résumé."""
key_points = extract_key_points(text)
summary = create_summary(key_points)
return {
"key_points": key_points,
"summary": summary
}
# Essayez avec un exemple de texte
sample_text = """
The Apollo 11 mission was a historic spaceflight that landed the first humans on the Moon
on July 20, 1969. Commander Neil Armstrong and lunar module pilot Buzz Aldrin descended
to the lunar surface while Michael Collins remained in orbit. Armstrong became the first
person to step onto the Moon, followed by Aldrin 19 minutes later. They spent about
two and a quarter hours together outside the spacecraft, collecting samples and taking photographs.
"""
result = summarize_text(sample_text)
print("Points clés :", result["key_points"])
print("\nRésumé :", result["summary"])
```
```typescript lines theme={null}
import * as weave from 'weave';
import OpenAI from 'openai';
// Initialiser Weave - remplacer par your-team/your-project
await weave.init('/inference-quickstart');
const client = new OpenAI({
baseURL: 'https://api.inference.wandb.ai/v1',
apiKey: process.env.WANDB_API_KEY || 'YOUR_WANDB_API_KEY', // Remplacer par votre clé API ou définir la variable d'environnement WANDB_API_KEY
});
const extractKeyPoints = weave.op(async function extractKeyPoints(text: string): Promise {
const response = await client.chat.completions.create({
model: 'meta-llama/Llama-3.1-8B-Instruct',
messages: [
{ role: 'system', content: 'Extract 3-5 key points from the text. Return each point on a new line.' },
{ role: 'user', content: text }
],
});
// Renvoie la réponse sans lignes vides
const content = response.choices[0].message.content || '';
return content.split('\n').map(line => line.trim()).filter(line => line.length > 0);
});
const createSummary = weave.op(async function createSummary(keyPoints: string[]): Promise {
const pointsText = keyPoints.map(point => `- ${point}`).join('\n');
const response = await client.chat.completions.create({
model: 'meta-llama/Llama-3.1-8B-Instruct',
messages: [
{ role: 'system', content: 'Create a one-sentence summary based on these key points.' },
{ role: 'user', content: `Key points:\n${pointsText}` }
],
});
return response.choices[0].message.content || '';
});
const summarizeText = weave.op(async function summarizeText(text: string): Promise<{key_points: string[], summary: string}> {
const keyPoints = await extractKeyPoints(text);
const summary = await createSummary(keyPoints);
return {
key_points: keyPoints,
summary: summary
};
});
// Essayer avec un exemple de texte
const sampleText = `
The Apollo 11 mission was a historic spaceflight that landed the first humans on the Moon
on July 20, 1969. Commander Neil Armstrong and lunar module pilot Buzz Aldrin descended
to the lunar surface while Michael Collins remained in orbit. Armstrong became the first
person to step onto the Moon, followed by Aldrin 19 minutes later. They spent about
two and a quarter hours together outside the spacecraft, collecting samples and taking photographs.
`;
const result = await summarizeText(sampleText);
console.log('Key Points:', result.key_points);
console.log('\nSummary:', result.summary);
```
## Comparer plusieurs modèles
W\&B Inference permet d’accéder à plusieurs modèles. Utilisez le code suivant pour comparer les performances des réponses de Llama et de DeepSeek :
```python lines theme={null}
import weave
import openai
# Initialisez Weave - remplacez par your-team/your-project
weave.init("/inference-quickstart")
client = openai.OpenAI(
base_url='https://api.inference.wandb.ai/v1',
api_key="YOUR_WANDB_API_KEY", # Remplacez par votre clé API réelle
project="/my-first-weave-project", # Requis pour le suivi de l’utilisation
)
# Définissez une classe de modèle pour comparer différents LLM
class InferenceModel(weave.Model):
model_name: str
@weave.op()
def predict(self, question: str) -> str:
response = client.chat.completions.create(
model=self.model_name,
messages=[
{"role": "user", "content": question}
],
)
return response.choices[0].message.content
# Créez des instances pour différents modèles
llama_model = InferenceModel(model_name="meta-llama/Llama-3.1-8B-Instruct")
deepseek_model = InferenceModel(model_name="deepseek-ai/DeepSeek-V3.1")
# Comparez leurs réponses
test_question = "Explique l’informatique quantique en un paragraphe pour un lycéen."
print("Réponse de Llama 3.1 8B :")
print(llama_model.predict(test_question))
print("\n" + "="*50 + "\n")
print("Réponse de DeepSeek V3 :")
print(deepseek_model.predict(test_question))
```
```typescript lines theme={null}
import * as weave from 'weave';
import OpenAI from 'openai';
// Initialisez Weave - remplacez par your-team/your-project
await weave.init("/inference-quickstart")
const client = new OpenAI({
baseURL: 'https://api.inference.wandb.ai/v1',
apiKey: process.env.WANDB_API_KEY || 'YOUR_WANDB_API_KEY', // Remplacez par votre clé API ou définissez la variable d'environnement WANDB_API_KEY
});
// Créez des fonctions de modèle à l'aide de weave.op (weave.Model n'est pas pris en charge en TypeScript)
function createModel(modelName: string) {
return weave.op(async function predict(question: string): Promise {
const response = await client.chat.completions.create({
model: modelName,
messages: [
{ role: 'user', content: question }
],
});
return response.choices[0].message.content || '';
});
}
// Créez des instances pour différents modèles
const llamaModel = createModel('meta-llama/Llama-3.1-8B-Instruct');
const deepseekModel = createModel('deepseek-ai/DeepSeek-V3.1');
// Comparez leurs réponses
const testQuestion = 'Explique l’informatique quantique en un paragraphe pour un lycéen.';
console.log('Réponse de Llama 3.1 8B :');
console.log(await llamaModel(testQuestion));
console.log('\n' + '='.repeat(50) + '\n');
console.log('Réponse de DeepSeek V3 :');
console.log(await deepseekModel(testQuestion));
```
## Évaluer la performance du modèle
Évaluez la performance d'un modèle sur une tâche de questions-réponses à l'aide de l'`EvaluationLogger` intégré de Weave. Cela permet un suivi structuré des évaluations, avec agrégation automatique, suivi de l'utilisation des tokens et fonctionnalités de comparaison avancées dans l'interface utilisateur.
Ajoutez le code suivant au script que vous avez utilisé dans la section précédente :
```python lines theme={null}
from typing import Optional
from weave import EvaluationLogger
# Créer un jeu de données simple
dataset = [
{"question": "What is 2 + 2?", "expected": "4"},
{"question": "What is the capital of France?", "expected": "Paris"},
{"question": "Name a primary color", "expected_one_of": ["red", "blue", "yellow"]},
]
# Définir un scorer
@weave.op()
def accuracy_scorer(expected: str, output: str, expected_one_of: Optional[list[str]] = None) -> dict:
"""Évalue la précision de la sortie du modèle."""
output_clean = output.strip().lower()
if expected_one_of:
is_correct = any(option.lower() in output_clean for option in expected_one_of)
else:
is_correct = expected.lower() in output_clean
return {"correct": is_correct, "score": 1.0 if is_correct else 0.0}
# Évaluer un modèle à l'aide de l'EvaluationLogger de Weave
def evaluate_model(model: InferenceModel, dataset: list[dict]):
"""Exécute une évaluation sur un jeu de données à l'aide du framework d'évaluation intégré de Weave."""
# Initialiser EvaluationLogger AVANT d'appeler le modèle pour capturer l'utilisation des tokens
# Ceci est particulièrement important pour W&B Inference afin de suivre les coûts
# Convertir le nom du modèle en un format valide (remplacer les caractères non alphanumériques par des underscores)
safe_model_name = model.model_name.replace("/", "_").replace("-", "_").replace(".", "_")
eval_logger = EvaluationLogger(
model=safe_model_name,
dataset="qa_dataset"
)
for example in dataset:
# Obtenir la prédiction du modèle
output = model.predict(example["question"])
# Enregistrer la prédiction
pred_logger = eval_logger.log_prediction(
inputs={"question": example["question"]},
output=output
)
# Évaluer la sortie
score = accuracy_scorer(
expected=example.get("expected", ""),
output=output,
expected_one_of=example.get("expected_one_of")
)
# Enregistrer le score
pred_logger.log_score(
scorer="accuracy",
score=score["score"]
)
# Terminer l'enregistrement pour cette prédiction
pred_logger.finish()
# Enregistrer le résumé - Weave agrège automatiquement les scores de précision
eval_logger.log_summary()
print(f"Évaluation terminée pour {model.model_name} (enregistré sous : {safe_model_name}). Consultez les résultats dans l'interface Weave.")
# Comparer plusieurs modèles - une fonctionnalité clé du framework d'évaluation de Weave
models_to_compare = [
llama_model,
deepseek_model,
]
for model in models_to_compare:
evaluate_model(model, dataset)
# Dans l'interface Weave, accédez à l'onglet Evals pour comparer les résultats entre les modèles
```
```typescript lines theme={null}
import { EvaluationLogger } from 'weave';
// Créer un jeu de données simple
interface DatasetExample {
question: string;
expected?: string;
expected_one_of?: string[];
}
const dataset: DatasetExample[] = [
{ question: 'What is 2 + 2?', expected: '4' },
{ question: 'What is the capital of France?', expected: 'Paris' },
{ question: 'Name a primary color', expected_one_of: ['red', 'blue', 'yellow'] },
];
// Définir un scorer
const accuracyScorer = weave.op(function accuracyScorer(args: {
expected: string;
output: string;
expected_one_of?: string[];
}): { correct: boolean; score: number } {
const outputClean = args.output.trim().toLowerCase();
let isCorrect: boolean;
if (args.expected_one_of) {
isCorrect = args.expected_one_of.some(option =>
outputClean.includes(option.toLowerCase())
);
} else {
isCorrect = outputClean.includes(args.expected.toLowerCase());
}
return { correct: isCorrect, score: isCorrect ? 1.0 : 0.0 };
});
// Évaluer un modèle à l'aide de l'EvaluationLogger de Weave
async function evaluateModel(
model: (question: string) => Promise,
modelName: string,
dataset: DatasetExample[]
): Promise {
// Initialiser EvaluationLogger AVANT d'appeler le modèle pour capturer l'utilisation des tokens
// Ceci est particulièrement important pour W&B Inference afin de suivre les coûts
// Convertir le nom du modèle en un format valide (remplacer les caractères non alphanumériques par des underscores)
const safeModelName = modelName.replace(/\//g, '_').replace(/-/g, '_').replace(/\./g, '_');
const evalLogger = new EvaluationLogger({
name: 'inference_evaluation',
model: { name: safeModelName },
dataset: 'qa_dataset'
});
for (const example of dataset) {
// Obtenir la prédiction du modèle
const output = await model(example.question);
// Enregistrer la prédiction
const predLogger = evalLogger.logPrediction(
{ question: example.question },
output
);
// Scorer la sortie
const score = await accuracyScorer({
expected: example.expected || '',
output: output,
expected_one_of: example.expected_one_of
});
// Enregistrer le score
predLogger.logScore('accuracy', score.score);
// Terminer l'enregistrement pour cette prédiction
predLogger.finish();
}
// Enregistrer le résumé - Weave agrège automatiquement les scores de précision
await evalLogger.logSummary();
console.log(`Evaluation complete for ${modelName} (logged as: ${safeModelName}). View results in the Weave UI.`);
}
// Comparer plusieurs modèles - une fonctionnalité clé du framework d'évaluation de Weave
const modelsToCompare = [
{ model: llamaModel, name: 'meta-llama/Llama-3.1-8B-Instruct' },
{ model: deepseekModel, name: 'deepseek-ai/DeepSeek-V3.1' },
];
for (const { model, name } of modelsToCompare) {
await evaluateModel(model, name, dataset);
}
// Dans l'interface Weave, accédez à l'onglet Evals pour comparer les résultats entre les modèles
```
L’exécution de ces exemples renvoie des liens vers les traces dans le terminal. Cliquez sur n’importe lequel pour afficher les traces dans le Weave UI.
Dans le Weave UI, vous pouvez :
* Consulter la chronologie de tous vos appels LLM
* Inspecter les entrées et les sorties de chaque opération
* Voir l’utilisation des tokens et les coûts estimés (capturés automatiquement par EvaluationLogger)
* Analyser la latence et les métriques de performance
* Accéder à l’onglet **Evals** pour voir les résultats d’évaluation agrégés
* Utiliser la fonctionnalité **Compare** pour analyser les performances de différents modèles
* Parcourir des exemples spécifiques pour voir comment différents modèles se sont comportés avec les mêmes entrées
## Modèles disponibles
Pour une liste complète des modèles disponibles, voir la [section Modèles disponibles](https://docs.wandb.ai/inference/models/) dans la documentation W\&B Inference.
## Étapes suivantes
* **Utilisez le Playground** : [Essayez des modèles de manière interactive](/fr/weave/guides/tools/playground#access-the-playground) dans le Playground de Weave
* **Créez des évaluations** : découvrez [comment évaluer systématiquement vos applications LLM](/fr/weave/guides/core-types/evaluations)
* **Essayez d’autres intégrations** : Weave fonctionne avec [OpenAI, Anthropic et bien d’autres](/fr/weave/guides/integrations)
## Dépannage
Erreurs d'authentification
Si vous obtenez des erreurs d'authentification :
1. Vérifiez que vous disposez d'un compte W\&B valide
2. Vérifiez que vous utilisez la bonne clé API sur [wandb.ai/settings](https://wandb.ai/settings)
3. Assurez-vous que le nom de votre projet respecte le format `team-name/project-name`
Erreurs liées aux limites de débit
W\&B Inference applique des limites de concurrence par projet. Si vous atteignez les limites de débit :
* Réduisez le nombre de requêtes simultanées
* Ajoutez des délais entre les appels
* Envisagez de passer à un plan supérieur pour bénéficier de limites plus élevées
Pour plus de détails, voir la [documentation sur les limites de W\&B Inference](https://docs.wandb.ai/inference/usage-limits/).
Crédits bientôt épuisés
L'offre gratuite inclut un nombre limité de crédits. Voir la [documentation sur l'utilisation et les limites](https://docs.wandb.ai/inference/usage-limits/) pour plus de détails.