Découvrez Weave avec Serverless Inference

Ce guide vous montre comment utiliser W&B Weave avec Serverless 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. À 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
Python 3.10+ ou Node.js 18+
Packages requis :
- Python: pip install weave openai
- TypeScript: npm install weave openai
Une clé API OpenAI 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
TypeScript

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)

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<string> {
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
TypeScript

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"])

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<string[]> {
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<string> {
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
TypeScript

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))

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<string> {
    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
TypeScript

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

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<string>,
  modelName: string,
  dataset: DatasetExample[]
): Promise<void> {
  // 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 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 dans le Playground de Weave
Créez des évaluations : découvrez comment évaluer systématiquement vos applications LLM
Essayez d’autres intégrations : Weave fonctionne avec OpenAI, Anthropic et bien d’autres

Premiers pas

Guides

Guides pratiques

Référence

Détails et assistance

Ce que vous allez apprendre

Prérequis

Tracez votre premier appel LLM

Créer une application de synthèse de texte

Comparer plusieurs modèles

Évaluer les performances du modèle

Modèles disponibles

Étapes suivantes

Dépannage

​Ce que vous allez apprendre

​Prérequis

​Tracez votre premier appel LLM

​Créer une application de synthèse de texte

​Comparer plusieurs modèles

​Évaluer les performances du modèle

​Modèles disponibles

​Étapes suivantes

​Dépannage

Ce que vous allez apprendre

Prérequis

Tracez votre premier appel LLM

Créer une application de synthèse de texte

Comparer plusieurs modèles

Évaluer les performances du modèle

Modèles disponibles

Étapes suivantes

Dépannage