Découvrez Weave avec Serverless Inference

Ce guide vous montre comment utiliser W&B Weave avec Serverless Inference. 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.

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.8+ 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

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 par your-team/your-project
weave.init("<team-name>/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="<team-name>/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("<team-name>/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 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
TypeScript

import weave
import openai

# Initialisez Weave - Remplacez les valeurs entre "<>" par les vôtres.
weave.init("<team-name>/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="<team-name>/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('<team-name>/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<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 }
    ],
});
// 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<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
};
});

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

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("<team-name>/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="<team-name>/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("<team-name>/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

É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 tokens 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

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 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 dans la documentation Serverless Inference.

Étapes suivantes

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 résumé de texte

Comparer plusieurs modèles

Évaluer les performances du modèle

Modèles disponibles

Étapes suivantes

Dépannage

Premiers pas

Guides

Guides pratiques

Référence

Détails et assistance

Documentation Index

​Ce que vous allez apprendre

​Prérequis

​Tracez votre premier appel LLM

​Créer une application de résumé 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 résumé de texte

Comparer plusieurs modèles

Évaluer les performances du modèle

Modèles disponibles

Étapes suivantes

Dépannage