Tracez votre code - Weights & Biases Documentation

Ce guide vous montre 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 le code basé sur des LLM en capturant les entrées, les sorties et la structure de chaque opération sous forme d’Appel. Pour voir votre code en cours d’exécution sous forme de traces détaillées dans Weave, créez des Appels. Les sections suivantes décrivent les trois principales façons de procéder, de la plus automatisée à la plus manuelle :

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

Choisissez l’approche qui correspond au niveau de contrôle dont vous avez besoin sur les éléments à tracer.

Suivi automatique des Appels aux bibliothèques LLM

Weave s’intègre automatiquement à de nombreuses bibliothèques et frameworks courants, tels que openai, anthropic, cohere, mistral et LangChain. Importez la bibliothèque LLM ou le framework, puis initialisez votre projet Weave. Weave trace ensuite automatiquement tous les Appels adressés au LLM ou à la plateforme dans votre projet, sans nécessiter de modification de code supplémentaire. Pour obtenir la liste complète des intégrations de bibliothèques prises en charge, voir 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 obtenir un guide complet de configuration pour les projets JavaScript et TypeScript, voir le SDK TypeScript : guide d’intégration de bibliothèques tierces.

Si vous souhaitez mieux contrôler le comportement automatique, voir Configurer le suivi automatique des Appels LLM.

Suivi des fonctions personnalisées

Les applications LLM comportent souvent une logique supplémentaire (comme le prétraitement/post-traitement, les prompts, etc.) que vous souhaitez suivre. Utilisez cette approche lorsque vous souhaitez 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écorez votre fonction
@weave.op
def my_function(name: str):
    return f"Hello, {name}!"

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

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

Weave vous permet de suivre manuellement ces Appels en enveloppant 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 aussi le faire directement en ligne :

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

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

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

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

Suivre les méthodes de classe et d’instance

En plus des fonctions autonomes, vous pouvez également suivre les méthodes de classe et d’instance. Vous pouvez suivre n’importe quelle méthode d’une classe en la décorant 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 le Tracing.

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 des appels de fonction parallèles (multithread)

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

Python
TypeScript

L’exemple de code suivant montre comment utiliser ThreadPoolExecutor. La première fonction, func, est un op simple qui prend x et renvoie x+1. La deuxième 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) signifie que chaque appel à func conserve le même contexte de trace parent.

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

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

Dans la Weave UI, cela produit un seul appel parent avec cinq appels enfants imbriqués. Vous obtenez une trace entièrement hiérarchisée, même si les opérations d’incrémentation s’exécutent en parallèle.

La Trace UI, 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 via l’API. Cette approche vous donne un contrôle complet sur le moment où un appel commence et se termine, au prix de davantage de code standard.

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

​Suivi des fonctions personnalisées

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

​Tracer des appels de fonction parallèles (multithread)

​Suivi manuel des appels

Suivi automatique des Appels aux bibliothèques LLM

Suivi des fonctions personnalisées

Suivre les méthodes de classe et d’instance

Tracer des appels de fonction parallèles (multithread)

Suivi manuel des appels