> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Instructor
> Tracez l’extraction de données structurées à partir de LLM grâce à l’intégration Instructor de Weave, qui capture la validation Pydantic et la logique de nouvelles tentatives.
[Instructor](https://python.useinstructor.com/) est une bibliothèque légère qui permet d’obtenir des données structurées, comme du JSON, à partir de LLM. Ce guide vous explique comment tracer les appels Instructor avec Weave afin de déboguer l’extraction structurée, de capturer la validation Pydantic et d’inspecter la logique de nouvelles tentatives.
Traçage
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 sont utiles pour le débogage et peuvent servir de jeu de données pour améliorer votre application.
Weave capture automatiquement les traces d'[Instructor](https://python.useinstructor.com/). Pour commencer à suivre vos appels, appelez `weave.init(project_name="[YOUR-WANDB-PROJECT-NAME]")`, puis utilisez la bibliothèque comme d'habitude.
```python lines theme={"system"}
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 d’un texte en 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 journalise tous les appels LLM effectués avec Instructor. Vous pouvez consulter les traces dans l’interface web de Weave. |
Suivre vos propres ops
Encapsuler une fonction avec `@weave.op` permet de capturer les entrées, les sorties et la logique de votre application afin de déboguer la circulation des données dans celle-ci. Vous pouvez imbriquer les ops sur plusieurs niveaux et construire une arborescence des fonctions que vous souhaitez suivre. Le code est également versionné automatiquement au fil de vos expériences, ce qui permet de capturer les modifications ponctuelles qui n'ont pas encore été validées dans Git.
Créez une fonction décorée avec [`@weave.op`](/fr/products/wandb/weave/guides/tracking/ops).
Dans l'exemple suivant, la fonction `extract_person` est la fonction de métrique encapsulée avec `@weave.op`. Vous pouvez ainsi voir les étapes intermédiaires, comme l'appel de complétion de chat OpenAI.
```python lines theme={"system"}
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 d’un texte en 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")
```
| 
|
| - |
| En décorant la fonction `extract_person` avec `@weave.op`, vous tracez ses entrées, ses sorties et tous les appels au LM effectués à l’intérieur de la fonction. Weave suit et versionne également automatiquement les objets structurés générés par Instructor. |
Créer un `Model` pour faciliter l’expérimentation
Il est difficile d’organiser ses expériences lorsque de nombreux éléments évoluent en même temps. La classe [`Model`](/fr/products/wandb/weave/guides/core-types/models) vous permet de capturer et d’organiser les détails expérimentaux de votre application, comme votre prompt système ou le modèle que vous utilisez. Vous pouvez ainsi organiser et comparer plus facilement les différentes itérations de votre application.
En plus de gérer les versions du code et de capturer les entrées et les sorties, les [`Model`](/fr/products/wandb/weave/guides/core-types/models)s capturent des paramètres structurés qui contrôlent le comportement de votre application, ce qui vous permet d’identifier les paramètres les plus efficaces. Vous pouvez également utiliser les Weave Models avec [`serve`](#serve-a-weave-model) et les [`Evaluation`](/fr/products/wandb/weave/guides/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={"system"}
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`](/fr/products/wandb/weave/guides/core-types/models) |
Servir un Weave Model
Après avoir enregistré un `weave.Model`, vous pouvez le servir en tant que point de terminaison FastAPI afin de le tester en dehors du notebook ou de l'intégrer à d'autres applications. À partir d'une référence Weave vers un objet `weave.Model`, vous pouvez démarrer un serveur FastAPI et le servir avec [`serve`](/fr/products/wandb/weave/guides/tools/serve).
| [
](https://forge.coreweave.com/wandb/geekyrakshit/instructor-test/weave/objects/PersonExtractor/versions/xXpMsJvaiTOjKafz1TnHC8wMgH5ZAAwYOaBMvHuLArI) |
| - |
| Pour trouver la référence Weave d'un `weave.Model`, accédez au modèle et copiez-la depuis l'interface utilisateur. |
Pour servir votre modèle, exécutez la commande suivante dans votre terminal :
```bash theme={"system"}
weave serve weave://your_entity/project-name/YourModel:[HASH]
```
## Related topics
- [Exemples de code et notebooks](/fr/products/wandb/examples.md)