> ## 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.
# Découvrir Weave avec Serverless Inference
> Découvrez les bases de Weave avec Serverless Inference pour tracer les appels de modèle, comparer les sorties et exécuter des évaluations.
export const GitHubLink = ({url, compact = false}) =>
{compact ? "View source" : <>
GitHub source
}
;
export const ColabLink = ({url}) =>
Try in Colab
;
Ce guide vous montre comment utiliser Weave avec [Serverless Inference](/fr/products/inference/serverless) pour découvrir les principes fondamentaux de Weave. Utilisez Serverless Inference pour créer et tracer des applications LLM à l'aide de modèles open source disponibles en temps réel, sans avoir à configurer votre propre infrastructure ni à gérer les clés API de plusieurs fournisseurs. Avec votre clé API CoreWeave Forge, vous pouvez interagir avec [tous les modèles hébergés par Serverless Inference](/fr/products/inference/serverless/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 de Weights & Biases.
Ce que vous allez apprendre
Ce guide vous montre comment :
* Configurer Weave et Serverless Inference.
* Créer une application LLM de base avec traçage automatique.
* Comparer plusieurs modèles.
* Évaluer les performances d’un modèle sur un jeu de données.
* Consulter vos résultats dans l’interface utilisateur de Weights & Biases.
Prérequis
* Un [compte CoreWeave Forge](https://id.coreweave.com/signup)
* Python 3.10+ ou Node.js 18+
* Les paquets requis installés :
* **Python** : `pip install weave openai`
* **TypeScript** : `npm install weave openai`
* Une [clé API OpenAI](https://platform.openai.com/api-keys) définie dans une variable d’environnement.
Tracer votre premier appel LLM
Cette section vous montre comment effectuer un appel LLM unique et le faire tracer automatiquement par Weave, afin de vérifier que votre configuration fonctionne avant de passer à des exemples plus complexes.
Pour commencer, copiez-collez l’exemple de code suivant. Il utilise le modèle Llama 3.1-8B de 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 afficher votre trace dans l’interface de Weights & Biases.
```python lines theme={"system"}
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 avec OpenAI qui pointe 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
project="[YOUR-TEAM]/my-first-weave-project", # Requis pour le suivi de l’utilisation
)
# Décorez votre fonction pour activer le traçage. 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 l’ensemble
result = ask_llama("What are the benefits of using W&B Weave for LLM development?")
print(result)
```
```typescript lines theme={"system"}
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 avec OpenAI qui pointe 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 traçage
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 l’ensemble
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 réparties sur plusieurs fonctions. Vous verrez ainsi comment une véritable application LLM en plusieurs étapes est capturée dans l’interface utilisateur.
Exécutez ensuite le code suivant, une application de synthèse de base qui illustre la façon dont Weave trace les opérations imbriquées :
```python lines theme={"system"}
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 propre clé API
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 les 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 lines theme={"system"}
import * as weave from 'weave';
import OpenAI from 'openai';
// Initialiser Weave. Remplacez par votre-équipe/votre-projet
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
});
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 les 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 texte d’exemple
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 à un même prompt. Serverless Inference donne accès à plusieurs modèles. Utilisez le code suivant pour comparer les performances de Llama et de DeepSeek à partir de leurs réponses respectives :
```python lines theme={"system"}
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
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 lines theme={"system"}
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 avec 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 méthodiquement la qualité des modèles.
Évaluez les performances d’un modèle sur une tâche de questions-réponses à l’aide de l’`EvaluationLogger` intégré à Weave. Il fournit un suivi structuré des évaluations, avec agrégation automatique, capture de l’utilisation des jetons et des fonctionnalités de comparaison avancées dans l’interface utilisateur.
Ajoutez le code suivant à la fin du script utilisé dans la section précédente :
```python lines theme={"system"}
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 avec 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
# C’est particulièrement important avec Serverless Inference pour suivre les coûts
# Convertir le nom du modèle dans un format valide (remplacer les caractères non alphanumériques par des caractères de soulignement)
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"])
# Journaliser la prédiction
pred_logger = eval_logger.log_prediction(
inputs={"question": example["question"]},
output=output
)
# Noter la sortie
score = accuracy_scorer(
expected=example.get("expected", ""),
output=output,
expected_one_of=example.get("expected_one_of")
)
# Journaliser le score
pred_logger.log_score(
scorer="accuracy",
score=score["score"]
)
# Terminer la journalisation de cette prédiction
pred_logger.finish()
# Journaliser 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 Weights & Biases UI.")
# 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 de Weights & Biases, accédez à l’onglet Evals pour comparer les résultats des différents modèles
```
```typescript twoslash lines theme={"system"}
// @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 avec l’EvaluationLogger de Weave
async function evaluateModel(
model: (question: string) => Promise,
modelName: string,
dataset: DatasetExample[]
): Promise {
// Initialiser EvaluationLogger AVANT d’appeler le modèle afin de capturer l’utilisation des jetons
// C’est particulièrement important avec Serverless Inference pour suivre les coûts
// Convertir le nom du modèle dans un format valide (remplacer les caractères non alphanumériques par des caractères de soulignement)
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 de 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 weights and Biases 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 de Weights & Biases, accédez à l’onglet Evals pour comparer les résultats des différents modèles
```
Après avoir exécuté ces exemples, vous disposez d’appels LLM tracés, d’un pipeline de synthèse imbriqué, d’une comparaison de modèles et d’une évaluation complète, tous journalisés dans Weave. L’exécution de ces exemples affiche dans le terminal des liens vers les traces. Cliquez sur l’un de ces liens pour afficher les traces dans l’interface de Weights & Biases.
Dans l’interface de Weights & Biases, vous pouvez :
* Consulter la chronologie de tous vos appels LLM.
* Inspecter les entrées et les sorties de chaque opération.
* Afficher l’utilisation des jetons et les coûts estimés (capturés automatiquement par EvaluationLogger).
* Analyser la latence et les métriques de performances.
* Accéder à l’onglet **Evals** pour consulter les résultats d’évaluation agrégés.
* Utiliser la fonctionnalité **Compare** pour analyser les performances de différents modèles.
* Parcourir des exemples précis pour voir comment différents modèles se comportent sur les mêmes entrées.
Modèles disponibles
Pour obtenir la liste complète des modèles disponibles, consultez la [section Modèles disponibles](/fr/products/inference/serverless/models) de la documentation Serverless Inference.
Étapes suivantes
Une fois les notions de base acquises, les ressources suivantes vous aideront à approfondir votre utilisation de Weave et de Serverless Inference :
* **Utiliser le Playground** : [essayez des modèles de manière interactive](/fr/products/wandb/weave/guides/tools/playground#access-the-playground) dans le Weave Playground
* **Créer des évaluations** : découvrez comment mener une [évaluation systématique](/fr/products/wandb/weave/guides/core-types/evaluations) de vos applications LLM
* **Essayer d’autres intégrations** : Weave s’intègre à [OpenAI, Anthropic et bien d’autres](/fr/products/wandb/weave/guides/integrations)
Dépannage
Erreurs d’authentification
Si vous rencontrez des erreurs d’authentification :
1. Vérifiez que vous disposez d’un compte CoreWeave Forge valide.
2. Assurez-vous d’utiliser la bonne clé API, disponible sur [forge.coreweave.com/settings](https://forge.coreweave.com/settings).
3. Vérifiez que le nom de votre projet respecte le format `your-team/your-project`.
Erreurs de limite 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 un délai entre les appels.
* Envisagez une mise à niveau de votre forfait pour bénéficier de limites plus élevées.
Pour plus de détails, consultez la [documentation sur les limites de Serverless Inference](/fr/products/inference/serverless/usage-limits).
Crédits épuisés
L’offre gratuite inclut un nombre limité de crédits. Pour plus de détails, consultez la [documentation sur l’utilisation et les limites](/fr/products/inference/serverless/usage-limits).
## Related topics
- [Premiers pas avec Weights & Biases](/fr/products/wandb/get-started.md)