Tracez votre code

Instrumentez votre code en cours d’exécution afin que celle-ci apparaisse sous forme de traces détaillées dans W&B Weave.

Pour afficher votre code en cours d’exécution sous forme de traces détaillées dans Weave, créez des appels. Vous pouvez procéder de trois façons principales :

​

1. Suivi automatique des appels de bibliothèques LLM

Weave s’intègre automatiquement à de nombreuses intégrations et frameworks courants, comme openai, anthropic, cohere, mistral et LangChain. Importez la bibliothèque LLM ou le framework, initialisez votre projet Weave, puis Weave trace automatiquement tous les appels effectués vers le LLM ou la plateforme dans votre projet, sans aucune 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

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

TypeScript

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 JS / TS, voir le SDK TypeScript : guide d’intégration tierce.

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

​

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

Python

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}!"

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

TypeScript

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

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

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

TypeScript

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. Pour obtenir un imbriquement correct sous le même op parent, utilisez un ThreadPoolExecutor.

Python

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

TypeScript

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, ce qui vous permet d’obtenir une trace entièrement hiérarchisée, même si les opérations d’incrémentation s’exécutent en parallèle.

​

3. Suivi manuel des appels

Vous pouvez également créer manuellement des appels directement via l’API.

Python

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

    # ... code de votre fonction ...

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

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

TypeScript

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

HTTP API

• 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"
    }
}