> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Découvrez Weave avec Serverless Inference
> Découvrez les bases de Weave à l’aide de Serverless 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 [Serverless Inference](/fr/inference) pour découvrir les bases de Weave. Utilisez Serverless 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 Serverless Inference](/fr/inference/models). À la fin de ce guide, vous aurez tracé des appels LLM, comparé des modèles et exécuté une évaluation que vous pourrez consulter dans l’interface Weave.
## Ce que vous allez apprendre
Ce guide vous montre comment :
* Configurer Weave et Serverless 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 l’interface Weave.
## Prérequis
* Un [compte W\&B](https://wandb.ai/signup)
* Python 3.10+ 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 LLM
Cette section vous montre comment effectuer un seul appel LLM et laisser Weave le tracer automatiquement, afin que vous puissiez confirmer que votre configuration fonctionne avant de passer à des exemples plus complexes.
Pour commencer, faites un copier-coller de l'exemple de code suivant. Cet exemple utilise Llama 3.1-8B avec Serverless Inference.
Lorsque vous exécutez ce code, Weave :
* Trace automatiquement votre appel LLM.
* Journalise les entrées, les sorties, la latence et l'utilisation des jetons.
* Fournit un lien pour consulter votre trace dans l'interface Weave.
```python lines theme={null}
import weave
import openai
# Initialisez Weave. Remplacez [YOUR-TEAM] par le nom de votre équipe.
weave.init("[YOUR-TEAM]/inference-quickstart")
# Créez un client compatible OpenAI pointant vers Serverless 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="[YOUR-TEAM]/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 twoslash lines theme={null}
// @noErrors
import * as weave from 'weave';
import OpenAI from 'openai';
// Initialisez Weave. Remplacez les valeurs entre "[]" par les vôtres.
await weave.init("[YOUR-TEAM]/inference-quickstart")
// Créez un client compatible OpenAI pointant vers Serverless Inference
const client = new OpenAI({
baseURL: 'https://api.inference.wandb.ai/v1', // point de terminaison Serverless 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 synthèse de texte
Maintenant que vous avez tracé un seul appel LLM, cette section montre comment Weave trace des opérations imbriquées dans plusieurs fonctions, afin que vous puissiez voir comment une véritable application LLM en plusieurs étapes est capturée dans l’interface utilisateur.
Ensuite, exécutez ce code, une application simple de synthèse qui montre comment Weave effectue la trace des opérations imbriquées :
```python lines theme={null}
import weave
import openai
# Initialisez Weave. Remplacez les valeurs entre "[]" par les vôtres.
weave.init("[YOUR-TEAM]/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="[YOUR-TEAM]/my-first-weave-project", # Requis pour le suivi de l'utilisation
)
@weave.op()
def extract_key_points(text: str) -> list[str]:
"""Extract key points from a text."""
response = 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
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:
"""Create a concise summary based on key points."""
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": "Create a one-sentence summary based on these key points."},
{"role": "user", "content": f"Key points:\n{points_text}"}
],
)
return response.choices[0].message.content
@weave.op()
def summarize_text(text: str) -> dict:
"""Main summarization pipeline."""
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("Key Points:", result["key_points"])
print("\nSummary:", result["summary"])
```
```typescript twoslash lines theme={null}
// @noErrors
import * as weave from 'weave';
import OpenAI from 'openai';
// Initialiser Weave. Remplacer par your-team/your-project
await weave.init('[YOUR-TEAM]/inference-quickstart');
const client = new OpenAI({
baseURL: 'https://api.inference.wandb.ai/v1',
apiKey: process.env.WANDB_API_KEY || 'YOUR_WANDB_API_KEY', // Replace with your API key or set the WANDB_API_KEY environment variable
});
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 }
],
});
// Returns response without blank lines
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
};
});
// Try it with sample text
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
Un cas d'utilisation courant de Weave consiste à comparer la manière dont différents modèles répondent au même prompt. Serverless Inference donne accès à plusieurs modèles. Utilisez le code suivant pour comparer les performances des réponses générées respectivement par Llama et DeepSeek :
```python lines theme={null}
import weave
import openai
# Initialiser Weave. Remplacez par your-team/your-project
weave.init("[YOUR-TEAM]/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="[YOUR-TEAM]/my-first-weave-project", # Requis pour le suivi de l'utilisation
)
# Définir une classe Model 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éer 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")
# Comparer leurs réponses
test_question = "Explain quantum computing in one paragraph for a high school student."
print("Llama 3.1 8B response:")
print(llama_model.predict(test_question))
print("\n" + "="*50 + "\n")
print("DeepSeek V3 response:")
print(deepseek_model.predict(test_question))
```
```typescript twoslash lines theme={null}
// @noErrors
import * as weave from 'weave';
import OpenAI from 'openai';
// Initialiser Weave. Remplacez par your-team/your-project
await weave.init("[YOUR-TEAM]/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éer 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éer 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');
// Comparer leurs réponses
const testQuestion = 'Explain quantum computing in one paragraph for a high school student.';
console.log('Llama 3.1 8B response:');
console.log(await llamaModel(testQuestion));
console.log('\n' + '='.repeat(50) + '\n');
console.log('DeepSeek V3 response:');
console.log(await deepseekModel(testQuestion));
```
## Évaluer les performances du modèle
Au-delà des comparaisons ponctuelles, cette section vous montre comment exécuter une évaluation structurée sur un jeu de données afin de mesurer et de comparer systématiquement la qualité du modèle.
Évaluez les performances d’un modèle sur une tâche de questions-réponses à l’aide de `EvaluationLogger`, intégré à Weave. Cela permet un suivi structuré de l’évaluation, avec agrégation automatique, capture de l’utilisation des jetons et riches fonctionnalités de comparaison 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:
"""Score the accuracy of the model output."""
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]):
"""Run evaluation on a dataset using Weave's built-in evaluation framework."""
# Initialiser EvaluationLogger AVANT d'appeler le modèle pour capturer l'utilisation des jetons
# Particulièrement important pour l'inférence sans serveur 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 la journalisation pour cette prédiction
pred_logger.finish()
# Enregistrer la synthèse - Weave agrège automatiquement les scores de précision
eval_logger.log_summary()
print(f"Evaluation complete for {model.model_name} (logged as: {safe_model_name}). View results in the Weave UI.")
# Comparer plusieurs modèles - 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 twoslash lines theme={null}
// @noErrors
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 jetons
// Ceci est particulièrement important pour l'inférence serverless 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);
// Journaliser la prédiction
const predLogger = evalLogger.logPrediction(
{ question: example.question },
output
);
// Évaluer la sortie
const score = await accuracyScorer({
expected: example.expected || '',
output: output,
expected_one_of: example.expected_one_of
});
// Journaliser le score
predLogger.logScore('accuracy', score.score);
// Terminer la journalisation pour cette prédiction
predLogger.finish();
}
// Journaliser la synthèse - 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 - 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
```
Après avoir exécuté ces exemples, vous aurez tracé des appels LLM, un pipeline de synthèse imbriqué, une comparaison de modèles et une évaluation complète enregistrée dans Weave. 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 l’interface Weave.
Dans l’interface Weave, 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 jetons 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](/fr/inference/models) dans la documentation Serverless Inference.
## Étapes suivantes
Une fois les notions de base en place, les ressources suivantes vous permettent d'approfondir votre utilisation de Weave et de Serverless Inference :
* **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 `your-team/your-project`.
Erreurs liées aux limites de débit
Serverless 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 Serverless Inference](/fr/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.