> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# 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](https://python.useinstructor.com/) 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](https://python.useinstructor.com/). Pour commencer le suivi, appelez `weave.init(project_name="[YOUR-WANDB-PROJECT-NAME]")`, puis utilisez la bibliothèque normalement.
```python lines theme={null}
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`](/fr/weave/guides/tracking/ops).
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.
```python lines theme={null}
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`](../core-types/models), 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 [`Model`](../core-types/models)s 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`](#serve-a-weave-model) et les [`Evaluation`](../core-types/evaluations)s.
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`.
```python lines theme={null}
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`](../core-types/models) |
## 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`](https://docs.wandb.ai/weave/guides/tools/serve).
| [
](https://wandb.ai/geekyrakshit/instructor-test/weave/objects/PersonExtractor/versions/xXpMsJvaiTOjKafz1TnHC8wMgH5ZAAwYOaBMvHuLArI) |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 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 :
```bash theme={null}
weave serve weave://your_entity/project-name/YourModel:[HASH]
```