OpenAI

Intégrez OpenAI avec Weave pour le tracing, l’évaluation et le monitoring

Vous souhaitez tester des modèles OpenAI sur Weave sans aucune configuration préalable ? Essayez le LLM Playground.

​

Tracing

Il est important de stocker les traces des applications LLM dans une base de données centrale, aussi bien pendant le développement qu’en production. Vous utiliserez ces traces pour le débogage, ainsi que pour constituer un jeu de données d’exemples difficiles servant à l’évaluation au fur et à mesure que vous améliorez votre application.

Weave peut capturer automatiquement les traces de la bibliothèque Python OpenAI.

Commencez à capturer des traces en appelant weave.init(<project-name>) avec le nom de projet de votre choix. OpenAI sera automatiquement patché, quel que soit le moment où vous l’importez.

Si vous ne spécifiez pas d’équipe W&B lorsque vous appelez weave.init(), votre entité par défaut sera utilisée. Pour trouver ou mettre à jour votre entité par défaut, consultez Paramètres utilisateur dans la documentation W&B Models.

Patch automatique

Weave patche automatiquement OpenAI, qu’il soit importé avant ou après weave.init() :

Python

from openai import OpenAI
import weave

weave.init('emoji-bot')  # OpenAI est automatiquement patché !

client = OpenAI()
response = client.chat.completions.create(
  model="gpt-4",
  messages=[
    {
      "role": "system",
      "content": "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
    },
    {
      "role": "user",
      "content": "How are you?"
    }
  ]
)

import { OpenAI } from 'openai';
import { wrapOpenAI } from '@wandb/weave';

const openai = wrapOpenAI(new OpenAI());

// Tous les appels à OpenAI seront désormais tracés
openai.chat.completions.create(
  {
    model: "gpt-4",
    messages: [
      {
        role: "system",
        content: "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
      },
      {
        role: "user",
        content: "How are you?"
      }
    ]
  }
);

Patch explicite (facultatif)

Vous pouvez toujours appliquer explicitement un patch si vous souhaitez un contrôle plus fin :

import weave

weave.init('emoji-bot')
weave.integrations.patch_openai()  # Activer le tracing OpenAI

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
  model="gpt-4",
  messages=[
    {"role": "user", "content": "Make me a emoji"}
  ]
)

Voir une trace en temps réel

Nous capturons également les outils d’appel de fonctions pour OpenAI Functions et OpenAI Assistants.

​

Sorties structurées

Weave prend également en charge les sorties structurées avec OpenAI. C’est utile pour garantir que les réponses de votre LLM suivent un format spécifique.

Python

from openai import OpenAI
from pydantic import BaseModel
import weave

class UserDetail(BaseModel):
    name: str
    age: int

client = OpenAI()
weave.init('extract-user-details')

completion = client.beta.chat.completions.parse(
    model="gpt-4o-2024-08-06",
    messages=[
        {"role": "system", "content": "Extract the user details from the message."},
        {"role": "user", "content": "My name is David and I am 30 years old."},
    ],
    response_format=UserDetail,
)

user_detail = completion.choices[0].message.parsed
print(user_detail)

​

Prise en charge de l’asynchrone

Weave prend également en charge les fonctions asynchrones avec OpenAI.

Python

from openai import AsyncOpenAI
import weave

client = AsyncOpenAI()
weave.init('async-emoji-bot')

async def call_openai():
    response = await client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "system", 
                "content": "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
            },
            {
                "role": "user",
                "content": "How are you?"
            }
        ]
    )
    return response

# Appel de la fonction asynchrone
result = await call_openai()

​

Prise en charge du streaming

Weave prend également en charge le streaming des réponses d’OpenAI.

Python

from openai import OpenAI
import weave

client = OpenAI()
weave.init('streaming-emoji-bot')

response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {
            "role": "system", 
            "content": "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
        },
        {
            "role": "user",
            "content": "How are you?"
        }
    ],
    stream=True
)

for chunk in response:
    print(chunk.choices[0].delta.content or "", end="")

​

Tracing des appels de fonction

Weave effectue également le tracing des appels de fonction effectués par OpenAI lors de l’utilisation d’outils.

Python

from openai import OpenAI
import weave

client = OpenAI()
weave.init('function-calling-bot')

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the weather in a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The location to get the weather for"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "The unit to return the temperature in"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {
            "role": "user",
            "content": "What's the weather like in New York?"
        }
    ],
    tools=tools
)

print(response.choices[0].message.tool_calls)

​

API Batch

Weave prend également en charge l’API Batch d’OpenAI pour traiter plusieurs requêtes.

Python

from openai import OpenAI
import weave

client = OpenAI()
weave.init('batch-processing')

# Créer un fichier de lot
batch_input = [
    {
        "custom_id": "request-1",
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-4",
            "messages": [{"role": "user", "content": "Hello, how are you?"}]
        }
    },
    {
        "custom_id": "request-2", 
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-4",
            "messages": [{"role": "user", "content": "What's the weather like?"}]
        }
    }
]

# Soumettre le lot
batch = client.batches.create(
    input_file_id="your-file-id",
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

# Récupérer les résultats du lot
completed_batch = client.batches.retrieve(batch.id)

​

API Assistants

Weave prend également en charge l’API Assistants d’OpenAI pour créer des applications d’IA conversationnelle.

Python

from openai import OpenAI
import weave

client = OpenAI()
weave.init('assistant-bot')

# Créer un assistant
assistant = client.beta.assistants.create(
    name="Math Assistant",
    instructions="You are a personal math tutor. Answer questions about math.",
    model="gpt-4"
)

# Créer un thread
thread = client.beta.threads.create()

# Ajouter un message au thread
message = client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="What is 2+2?"
)

# Exécuter l’assistant
run = client.beta.threads.runs.create(
    thread_id=thread.id,
    assistant_id=assistant.id
)

# Obtenir la réponse de l’assistant
messages = client.beta.threads.messages.list(thread_id=thread.id)

​

Suivi des coûts

Weave suit automatiquement le coût de vos appels à l’API OpenAI. Vous pouvez consulter le détail des coûts dans l’interface Weave.

Le suivi des coûts est disponible pour tous les modèles OpenAI et est calculé d’après la tarification OpenAI la plus récente.

​

Tracing des fonctions personnalisées

Vous pouvez également tracer des fonctions personnalisées qui utilisent OpenAI à l’aide du décorateur @weave.op.

Python

from openai import OpenAI
import weave

client = OpenAI()
weave.init('custom-function-bot')

@weave.op
def generate_response(prompt: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ]
    )
    return response.choices[0].message.content

# Cet appel de fonction sera tracé
result = generate_response("Hello, how are you?")

​

Étapes suivantes

Maintenant que vous avez configuré le tracing pour OpenAI, vous pouvez :

1. Voir les traces dans l’interface Weave : accédez à votre projet Weave pour consulter les traces de vos appels OpenAI
2. Créer des évaluations : utilisez vos traces pour créer des jeux de données d’évaluation
3. Surveiller les performances : suivez la latence, les coûts et d’autres métriques
4. Déboguer les problèmes : utilisez les traces pour comprendre ce qui se passe dans votre application LLM

Pour en savoir plus sur ces sujets, consultez notre guide d’évaluation et notre guide de monitoring.