Instructor

Suivez l’extraction de données structurées à partir de LLM avec l’intégration Instructor de Weave, en capturant la validation Pydantic et la logique de nouvelle tentative.

Instructor est une bibliothèque légère qui facilite l’obtention de données structurées, comme du JSON, à partir de LLM.

​

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 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 va maintenant suivre et consigner 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 pendant vos expériences afin de capturer des détails ad hoc qui n’ont pas été commités dans git.

Créez simplement une fonction décorée avec @weave.op.

Dans l’exemple ci-dessous, la fonction extract_person est la fonction de métrique encapsulée avec @weave.op. Cela nous aide à voir les étapes intermédiaires, comme un appel OpenAI Chat Completion.

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 expérimenter plus facilement

Il est difficile d’organiser une expérience lorsqu’il y a de nombreux éléments en jeu. En utilisant la classe Model, vous pouvez capturer et structurer 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/sorties, les Model capturent des paramètres structurés qui contrôlent le comportement de votre application, ce qui permet d’identifier facilement les paramètres les plus efficaces. Vous pouvez également utiliser les Weave Models avec serve (voir ci-dessous) et les Évaluation.

Dans l’exemple ci-dessous, 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éfinissez la structure de sortie souhaitée
class Person(BaseModel):
    person_name: str
    age: int


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

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

Tracing et gestion des versions de vos appels à l’aide d’un Model

​

Servir un Weave Model

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

Vous pouvez servir votre modèle avec la commande suivante dans le terminal :

weave serve weave://your_entity/project-name/YourModel:<hash>