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.

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

​

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
• 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 à 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

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

TypeScript

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

import weave
import openai

# Initialiser 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 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

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

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

import weave
import openai

# Initialisez 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é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

import * as weave from 'weave';
import OpenAI from 'openai';

// Initialisez 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é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<string> {
    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

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

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 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 dans la documentation W&B 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

​

Dépannage