Découvrir Weave avec Serverless Inference

Ce guide vous montre comment utiliser Weave avec Serverless Inference 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. À 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
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 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
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 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)

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

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

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<string>,
  modelName: string,
  dataset: DatasetExample[]
): Promise<void> {
  // 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 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 dans le Weave Playground
Créer des évaluations : découvrez comment mener une évaluation systématique de vos applications LLM
Essayer d’autres intégrations : Weave s’intègre à OpenAI, Anthropic et bien d’autres

​Ce que vous allez apprendre

​Prérequis

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