Exemples d'utilisation - CoreWeave Docs

Ces exemples montrent comment utiliser Serverless Inference avec Weave pour le traçage, l’évaluation et la comparaison. Suivez-les pour apprendre à instrumenter les appels de modèle afin d’observer leur comportement, de mesurer leurs performances sur un jeu de données et de comparer des modèles côte à côte. Les sections suivantes présentent un exemple de traçage de base, puis un flux de travail d’évaluation plus avancé. Avant d’exécuter l’un ou l’autre de ces exemples, assurez-vous de remplir les prérequis.

Exemple de base : tracer Llama 3.1 8B avec Weave

Cet exemple montre comment envoyer un prompt au modèle Llama 3.1 8B et tracer l’appel avec Weave. Le traçage capture l’intégralité de l’entrée et de la sortie de l’appel LLM, surveille les performances et vous permet d’analyser les résultats dans l’interface Weave.

En savoir plus sur le traçage dans Weave.

Dans cet exemple :

Vous définissez une fonction décorée avec @weave.op() qui envoie une requête de complétion de chat.
Weave enregistre vos traces et les associe à votre entity et à votre projet W&B.
Weave trace automatiquement la fonction et journalise les entrées, les sorties, la latence et les métadonnées.
Le résultat s’affiche dans le terminal et la trace apparaît dans l’onglet Traces sur Forge.

import weave
import openai

# Définir l’équipe et le projet Weave pour le traçage
weave.init("[YOUR-TEAM]/[YOUR-PROJECT]")

client = openai.OpenAI(
    base_url='https://api.inference.wandb.ai/v1',

    # Créer une clé API sur https://forge.coreweave.com/settings
    api_key="[YOUR-API-KEY]",

    # Facultatif : équipe et projet pour le suivi de l’utilisation
    project="wandb/inference-demo",
)

# Tracer l’appel de modèle dans Weave
@weave.op()
def run_chat():
    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": "Tell me a joke."}
        ],
    )
    return response.choices[0].message.content

# Exécuter et journaliser l’appel tracé
output = run_chat()
print(output)

Après avoir exécuté le code, affichez la trace dans Weave de l’une des manières suivantes :

Cliquez sur le lien affiché dans le terminal. Par exemple, https://wandb.ai/[YOUR-TEAM]/[YOUR-PROJECT]/r/call/01977f8f-839d-7dda-b0c2-27292ef0e04g.
Accédez à Forge et sélectionnez l’onglet Traces.

Une fois la trace de base opérationnelle, vous pouvez passer à un flux de travail plus complet, qui ne se limite pas à l’inspection d’appels individuels.

Exemple avancé : utiliser les évaluations et les leaderboards Weave

Outre le traçage des appels de modèle, vous pouvez évaluer les performances et publier des leaderboards. Cet exemple compare deux modèles sur un jeu de données de questions-réponses afin de montrer comment Llama 3.1 8B et DeepSeek V3.1 se comportent face aux mêmes prompts.

import os
import asyncio
import openai
import weave
from weave.flow import leaderboard
from weave.trace.ref_util import get_ref

# Définissez l’équipe et le projet Weave pour le traçage
weave.init("[YOUR-TEAM]/[YOUR-PROJECT]")

dataset = [
    {"input": "What is 2 + 2?", "target": "4"},
    {"input": "Name a primary color.", "target": "red"},
]

@weave.op
def exact_match(target: str, output: str) -> float:
    return float(target.strip().lower() == output.strip().lower())

class WBInferenceModel(weave.Model):
    model: str

    @weave.op
    def predict(self, prompt: str) -> str:
        client = openai.OpenAI(
            base_url="https://api.inference.wandb.ai/v1",
            # Créez une clé API sur https://forge.coreweave.com/settings
            api_key="[YOUR-API-KEY]",
            # Facultatif : équipe et projet pour le suivi de l’utilisation
            project="[YOUR-TEAM]/[YOUR-PROJECT]",
        )
        resp = client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
        )
        return resp.choices[0].message.content

llama = WBInferenceModel(model="meta-llama/Llama-3.1-8B-Instruct")
deepseek = WBInferenceModel(model="deepseek-ai/DeepSeek-V3.1")

def preprocess_model_input(example):
    return {"prompt": example["input"]}

evaluation = weave.Evaluation(
    name="QA",
    dataset=dataset,
    scorers=[exact_match],
    preprocess_model_input=preprocess_model_input,
)

async def run_eval():
    await evaluation.evaluate(llama)
    await evaluation.evaluate(deepseek)

asyncio.run(run_eval())

spec = leaderboard.Leaderboard(
    name="Inference Leaderboard",
    description="Compare models on a QA dataset",
    columns=[
        leaderboard.LeaderboardColumn(
            evaluation_object_ref=get_ref(evaluation).uri(),
            scorer_name="exact_match",
            summary_metric_path="mean",
        )
    ],
)

weave.publish(spec)

Après avoir exécuté ce code, accédez à votre compte W&B sur Forge et procédez comme suit :

Sélectionnez l’onglet Traces pour afficher vos traces.
Sélectionnez l’onglet Evals pour afficher vos évaluations de modèles.
Sélectionnez l’onglet Leaders pour afficher le leaderboard généré.

Une fois les deux exemples terminés, vous disposez d’un ensemble d’appels de modèle tracés, d’une évaluation publiée et d’un leaderboard qui compare les modèles sur votre jeu de données.

Étapes suivantes

Pour continuer à explorer Serverless Inference, voici quelques pistes :

Consultez la référence de l’API pour découvrir toutes les méthodes disponibles.
Essayez des modèles dans l’interface utilisateur.

​Exemple de base : tracer Llama 3.1 8B avec Weave

​Exemple avancé : utiliser les évaluations et les leaderboards Weave

​Étapes suivantes

Exemple de base : tracer Llama 3.1 8B avec Weave

Exemple avancé : utiliser les évaluations et les leaderboards Weave

Étapes suivantes