Tracer votre code - CoreWeave Docs

Ce guide explique comment instrumenter votre application afin que son exécution apparaisse sous forme de traces détaillées dans W&B Weave. Les traces vous aident à déboguer, évaluer et surveiller du code reposant sur des LLM : elles capturent les entrées, les sorties et la structure de chaque opération sous forme d’Appel. Pour visualiser l’exécution de votre code sous forme de traces détaillées dans Weave, vous devez créer des Appels. Les sections suivantes décrivent les trois principales méthodes pour y parvenir, de la plus automatique à la plus manuelle :

Suivi automatique des appels aux bibliothèques de LLM.
Suivi des fonctions personnalisées avec weave.op.
Suivi manuel des Appels directement à l’aide de l’API.

Choisissez l’approche adaptée au niveau de contrôle dont vous avez besoin sur ce qui est tracé.

Suivi automatique des appels aux bibliothèques LLM

Weave s’intègre automatiquement à de nombreux frameworks et bibliothèques courants, tels que openai, anthropic, cohere, mistral et LangChain. Importez la bibliothèque LLM ou le framework, puis initialisez votre projet Weave. Weave trace alors automatiquement dans votre projet tous les appels effectués vers le LLM ou la plateforme, sans aucune autre modification du code. Pour obtenir la liste complète des intégrations de bibliothèques prises en charge, consultez Aperçu des intégrations.

Python
TypeScript

import weave

from openai import OpenAI
client = OpenAI()

# Initialiser Weave Tracing
weave.init('intro-example')

response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {
            "role": "user",
            "content": "How are you?"
        }
    ],
    temperature=0.8,
    max_tokens=64,
    top_p=1,
)

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

const client = new OpenAI()

// Initialiser Weave Tracing
await weave.init('intro-example')

const response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [
    {
      role: 'user',
      content: 'How are you?',
    },
  ],
  temperature: 0.8,
  max_tokens: 64,
  top_p: 1,
});

Pour un guide de configuration complet des projets JavaScript et TypeScript, consultez le SDK TypeScript : guide d’intégration des outils tiers.

Pour mieux contrôler ce comportement automatique, consultez Configurer le suivi automatique des appels LLM.

Suivre des fonctions personnalisées

Les applications LLM comportent souvent une logique supplémentaire que vous souhaitez suivre : prétraitement et post-traitement, prompts, etc. Utilisez cette approche lorsque vous voulez que Weave capture vos propres fonctions en plus des appels LLM qu’il trace automatiquement.

Python
TypeScript

Weave vous permet de suivre manuellement ces appels à l’aide du décorateur @weave.op. Par exemple :

import weave

# Initialiser Weave Tracing
weave.init('intro-example')

# Décorer votre fonction
@weave.op
def my_function(name: str):
    return f"Hello, {name}!"

# Appeler votre fonction -- Weave suivra automatiquement les entrées et les sorties
print(my_function("World"))

Vous pouvez également suivre les méthodes de classes.

Weave vous permet de suivre manuellement ces appels en encapsulant votre fonction avec weave.op. Par exemple :

import * as weave from 'weave'

await weave.init('intro-example')

function myFunction(name: string) {
    return `Hello, ${name}!`
}

const myFunctionOp = weave.op(myFunction)

Vous pouvez également définir l’encapsulation en ligne :

const myFunctionOp = weave.op((name: string) => `Hello, ${name}!`)

Cela fonctionne aussi bien pour les fonctions que pour les méthodes de classes :

class MyClass {
    constructor() {
        this.myMethod = weave.op(this.myMethod)
    }

    myMethod(name: string) {
        return `Hello, ${name}!`
    }
}

Suivre les méthodes de classe et d’objet

Outre les fonctions autonomes, vous pouvez suivre les méthodes de classe et d’objet. Pour suivre n’importe quelle méthode d’une classe, décorez-la avec weave.op.

Python
TypeScript

import weave

# Initialiser Weave Tracing
weave.init("intro-example")

class MyClass:
    # Décorez votre méthode
    @weave.op
    def my_method(self, name: str):
        return f"Hello, {name}!"

instance = MyClass()

# Appelez votre méthode -- Weave suivra automatiquement les entrées et les sorties
print(instance.my_method("World"))

Vous pouvez appliquer @weave.op aux méthodes d’instance pour les tracer.

class Foo {
    @weave.op
    async predict(prompt: string) {
        return "bar"
    }
}

Vous pouvez également appliquer @weave.op aux méthodes statiques pour surveiller les fonctions utilitaires d’une classe.

class MathOps {
    @weave.op
    static square(n: number): number {
        return n * n;
    }
}

Tracer les appels de fonctions parallèles (multithread)

Par défaut, les appels parallèles apparaissent tous dans Weave comme des appels racines distincts, ce qui rend la hiérarchie de la trace difficile à suivre. Pour les imbriquer correctement sous le même op parent, utilisez un ThreadPoolExecutor.

Python
TypeScript

L’exemple de code suivant illustre l’utilisation de ThreadPoolExecutor. La première fonction, func, est un op simple qui prend x et renvoie x+1. La seconde fonction, outer, est un autre op qui accepte une liste d’entrées. Dans outer, l’utilisation de ThreadPoolExecutor et de exc.map(func, inputs) garantit que chaque appel à func conserve le même contexte de la trace parente.

import weave

@weave.op
def func(x):
    return x+1

@weave.op
def outer(inputs):
    with weave.ThreadPoolExecutor() as exc:
        exc.map(func, inputs)

# Mettez à jour le nom de votre projet Weave
client = weave.init('my-weave-project')
outer([1,2,3,4,5])

This feature is not available in the TypeScript SDK yet.

Dans l’interface de Weights & Biases, vous obtenez ainsi un seul appel parent comportant cinq appels enfants imbriqués. La trace est entièrement hiérarchique, même si les incréments s’exécutent en parallèle. L’interface Trace, montrant un seul appel parent pour outer, avec cinq appels enfants imbriqués.

L’interface Trace, montrant un seul appel parent pour outer, avec cinq appels enfants imbriqués.

Suivi manuel des appels

Si ni l’intégration automatique ni le décorateur weave.op ne conviennent à votre flux de travail, vous pouvez créer manuellement des appels directement à l’aide de l’API. Cette approche vous offre un contrôle complet sur le début et la fin d’un appel, au prix d’un code répétitif plus abondant.

Python
TypeScript
HTTP API

import weave

# Initialiser Weave Tracing
client = weave.init('intro-example')

def my_function(name: str):
    # Démarrer un appel
    call = client.create_call(op="my_function", inputs={"name": name})

    # ... le code de votre fonction ...

    # Terminer un appel
    client.finish_call(call, output="Hello, World!")

    # Appeler votre fonction
    print(my_function("World"))

Cette fonctionnalité n’est pas encore disponible dans le SDK TypeScript.

Démarrer un appel : POST /call/start.
Terminer un appel : POST /call/end.

curl -L 'https://trace.wandb.ai/call/start' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-d '{
    "start": {
        "project_id": "string",
        "id": "string",
        "op_name": "string",
        "display_name": "string",
        "trace_id": "string",
        "parent_id": "string",
        "started_at": "2024-09-08T20:07:34.849Z",
        "attributes": {},
        "inputs": {},
        "wb_run_id": "string"
    }
}

​Suivi automatique des appels aux bibliothèques LLM

​Suivre des fonctions personnalisées

​Suivre les méthodes de classe et d’objet

​Tracer les appels de fonctions parallèles (multithread)

​Suivi manuel des appels

Suivi automatique des appels aux bibliothèques LLM

Suivre des fonctions personnalisées

Suivre les méthodes de classe et d’objet

Tracer les appels de fonctions parallèles (multithread)

Suivi manuel des appels