Vous souhaitez tester des modèles OpenAI sur Weave sans aucune configuration préalable ? Essayez le LLM Playground. 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() :
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 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"}
]
)
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
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
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
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)
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)
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)
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
@weave.op.
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?")
- Voir les traces dans l’interface Weave : accédez à votre projet Weave pour consulter les traces de vos appels OpenAI
- Créer des évaluations : utilisez vos traces pour créer des jeux de données d’évaluation
- Surveiller les performances : suivez la latence, les coûts et d’autres métriques
- 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.
