Instructor - Weights & Biases Documentation

Instructor est une bibliothèque légère qui facilite l’obtention de données structurées, comme du JSON, à partir de LLM. Ce guide vous montre comment suivre les appels Instructor avec Weave afin de déboguer l’extraction structurée, de capturer la validation Pydantic et d’inspecter le mécanisme de nouvelle tentative.

Tracing

Il est important de stocker les traces des applications de modèles de langage dans un emplacement centralisé, aussi bien pendant le développement qu’en production. Ces traces peuvent être utiles pour le débogage, ainsi que servir de jeu de données pour vous aider à améliorer votre application. Weave capture automatiquement les traces pour Instructor. Pour commencer le suivi, appelez weave.init(project_name="[YOUR-WANDB-PROJECT-NAME]"), puis utilisez la bibliothèque normalement.

import instructor
import weave
from pydantic import BaseModel
from openai import OpenAI


# Définir la structure de sortie souhaitée
class UserInfo(BaseModel):
    user_name: str
    age: int

# Initialiser Weave
weave.init(project_name="instructor-test")

# patcher le client OpenAI
client = instructor.from_openai(OpenAI())

# Extraire des données structurées à partir du langage naturel
user_info = client.chat.completions.create(
    model="gpt-3.5-turbo",
    response_model=UserInfo,
    messages=[{"role": "user", "content": "John Doe is 30 years old."}],
)


Weave suit et consigne tous les appels LLM effectués avec Instructor. Vous pouvez consulter les traces dans l’interface web de Weave.

Suivez vos propres ops

En décorant une fonction avec @weave.op, vous commencez à capturer les entrées, les sorties et la logique de l’application afin de pouvoir déboguer la façon dont les données circulent dans votre application. Vous pouvez imbriquer des ops en profondeur et construire un arbre de fonctions que vous souhaitez suivre. Cela lance également automatiquement la gestion des versions du code à mesure que vous expérimentez, en capturant des détails ad hoc qui n’ont pas été commités dans git. Créez une fonction décorée avec @weave.op. Dans l’exemple suivant, la fonction extract_person est la fonction de métrique encapsulée avec @weave.op. Cela vous permet de voir les étapes intermédiaires, comme l’appel de complétion de chat d’OpenAI.

import instructor
import weave
from openai import OpenAI
from pydantic import BaseModel


# Définir la structure de sortie souhaitée
class Person(BaseModel):
    person_name: str
    age: int


# Initialiser Weave
weave.init(project_name="instructor-test")

# Patcher le client OpenAI
lm_client = instructor.from_openai(OpenAI())


# Extraire des données structurées à partir du langage naturel
@weave.op()
def extract_person(text: str) -> Person:
    return lm_client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "user", "content": text},
        ],
        response_model=Person,
    )


person = extract_person("My name is John and I am 20 years old")


Décorer la fonction `extract_person` avec `@weave.op` permet de tracer ses entrées, ses sorties et tous les appels LM internes effectués dans la fonction. Weave suit également automatiquement les objets structurés générés par Instructor et en gère les versions.

Créer un `Model` pour faciliter l’expérimentation

Il est difficile d’organiser l’expérimentation lorsqu’il y a de nombreux éléments à prendre en compte. En utilisant la classe Model, vous pouvez capturer et organiser les détails expérimentaux de votre application, comme le prompt système ou le modèle que vous utilisez. Cela facilite l’organisation et la comparaison des différentes itérations de votre application. En plus de la gestion des versions du code et de la capture des entrées et des sorties, les Models capturent des paramètres structurés qui contrôlent le comportement de votre application, afin de vous permettre de trouver les paramètres les plus efficaces. Vous pouvez également utiliser les modèles Weave avec serve et les Evaluations. Dans l’exemple suivant, vous pouvez expérimenter avec PersonExtractor. Chaque fois que vous modifiez l’un de ces éléments, vous obtenez une nouvelle version de PersonExtractor.

import asyncio
from typing import List, Iterable

import instructor
import weave
from openai import AsyncOpenAI
from pydantic import BaseModel


# Définir la structure de sortie souhaitée
class Person(BaseModel):
    person_name: str
    age: int


# Initialiser Weave
weave.init(project_name="instructor-test")

# patcher le client OpenAI
lm_client = instructor.from_openai(AsyncOpenAI())


class PersonExtractor(weave.Model):
    openai_model: str
    max_retries: int

    @weave.op()
    async def predict(self, text: str) -> List[Person]:
        model = await lm_client.chat.completions.create(
            model=self.openai_model,
            response_model=Iterable[Person],
            max_retries=self.max_retries,
            stream=True,
            messages=[
                {
                    "role": "system",
                    "content": "You are a perfect entity extraction system",
                },
                {
                    "role": "user",
                    "content": f"Extract `{text}`",
                },
            ],
        )
        return [m async for m in model]


model = PersonExtractor(openai_model="gpt-4", max_retries=2)
asyncio.run(model.predict("John is 30 years old"))


Traçage et gestion des versions de vos appels à l’aide d’un `Model`

Servir un Weave Model

Après avoir enregistré un weave.Model, vous pouvez le servir comme point de terminaison FastAPI pour le tester en dehors du notebook ou l’intégrer à d’autres applications. À partir d’une référence Weave vers un objet weave.Model, vous pouvez lancer un serveur FastAPI et le serve.


Vous pouvez obtenir la référence Weave de n’importe quel `weave.Model` en accédant au modèle et en la copiant depuis l’UI.

Pour servir votre modèle, exécutez la commande suivante dans votre terminal :

weave serve weave://your_entity/project-name/YourModel:[HASH]

​Tracing

​Suivez vos propres ops

​Créer un Model pour faciliter l’expérimentation

​Servir un Weave Model

Tracing

Suivez vos propres ops

Créer un `Model` pour faciliter l’expérimentation

Servir un Weave Model