Plonger plus profondément avec des résultats structurés

Vous aider à améliorer votre compréhension et votre utilisation optimale des résultats structurés et des LLM

In the previous article, we were introduced to structured outputs using OpenAI. Since the general availability release in ChatCompletions API (v1.40.0), structured outputs have been applied across dozens of use cases, and spawned numerous threads on OpenAI forums.

Dans l'article précédent, nous avons découvert les sorties structurées utilisant OpenAI. Depuis la version de disponibilité générale de l'API ChatCompletions (v1.40.0), les sorties structurées ont été appliquées à des dizaines de cas d'utilisation et ont généré de nombreux fils de discussion sur les forums OpenAI.

In this article, our aim is to provide you with an even deeper understanding, dispel some misconceptions, and give you some tips on how to apply them in the most optimal manner possible, across different scenarios.

Dans cet article, notre objectif est de vous fournir une compréhension encore plus approfondie, de dissiper certaines idées fausses et de vous donner quelques conseils sur la façon de les appliquer de la manière la plus optimale possible, dans différents scénarios.

## Structured outputs overview

## Aperçu des sorties structurées

Structured outputs are a way of enforcing the output of an LLM to follow a pre-defined schema — usually a JSON schema. This works by transforming the schema into a context free grammar (CFG), which during the token sampling step, is used together with the previously generated tokens, to inform which subsequent tokens are valid. It’s helpful to think of it as creating a regex for token generation.

Les sorties structurées sont un moyen de forcer la sortie d'un LLM à suivre un schéma prédéfini, généralement un schéma JSON. Cela fonctionne en transformant le schéma en une grammaire sans contexte (CFG), qui, lors de l'étape d'échantillonnage des jetons, est utilisée avec les jetons générés précédemment, pour indiquer quels jetons suivants sont valides. Il est utile d'y penser comme à la création d'une expression régulière pour la génération de jetons.

OpenAI API implementation actually tracks a limited subset of JSON schema features. With more general structured output solutions, such as Outlines, it is possible to use a somewhat larger subset of the JSON schema, and even define completely custom non-JSON schemas — as long as one has access to an open weight model. For the purpose of this article, we will assume the OpenAI API implementation.

La mise en œuvre de l'API OpenAI suit en fait un sous-ensemble limité de fonctionnalités du schéma JSON. Avec des solutions de sortie structurées plus générales, telles que Outlines, il est possible d'utiliser un sous-ensemble un peu plus grand du schéma JSON, et même de définir des schémas non JSON entièrement personnalisés, à condition d'avoir accès à un modèle de pondération ouvert. Pour les besoins de cet article, nous supposerons l'implémentation de l'API OpenAI.

### JSON Schema and Pydantic

### Schéma JSON et Pydantic

According to JSON Schema Core Specification, “JSON Schema asserts what a JSON document must look like, ways to extract information from it, and how to interact with it”. JSON schema defines six primitive types — null, boolean, object, array, number and string. It also defines certain keywords, annotations, and specific behaviours. For example, we can specify in our schema that we expect an array and add an annotation that minItems shall be 5 .

Selon la spécification JSON Schema Core, « JSON Schema affirme à quoi doit ressembler un document JSON, les moyens d'en extraire des informations et comment interagir avec lui ». Le schéma JSON définit six types primitifs : nul, booléen, objet, tableau, nombre et chaîne. Il définit également certains mots-clés, annotations et comportements spécifiques. Par exemple, nous pouvons spécifier dans notre schéma que nous attendons un tableau et ajouter une annotation indiquant que minItems doit être 5 .

Pydantic is a Python library that implements the JSON schema specification. We use Pydantic to build robust and maintainable software in Python. Since Python is a dynamically typed language, data scientists do not necessarily think in terms of variable types — these are often implied in their code. For example, a fruit would be specified as:

Pydantic est une bibliothèque Python qui implémente la spécification de schéma JSON. Nous utilisons Pydantic pour créer des logiciels robustes et maintenables en Python. Puisque Python est un langage typé dynamiquement, les data scientists ne pensent pas nécessairement en termes de types de variables – celles-ci sont souvent implicites dans leur code. Par exemple, un fruit serait spécifié comme :

```python

```python

fruit = "apple"

fruit = "pomme"

```

```

…while a function declaration that returns “fruit” from some piece of data would often be specified as:

… alors qu’une déclaration de fonction qui renvoie « fruit » à partir d’un élément de données serait souvent spécifiée comme suit :

```python

```python

def get_fruit(data):

def get_fruit(données):

return data

renvoyer des données

```

```

Pydantic on the other hand allows us to generate a JSON-schema compliant class, with properly annotated variables and type hints, making our code more readable/maintainable and in general more robust, i.e.

Pydantic, d'autre part, nous permet de générer une classe conforme au schéma JSON, avec des variables correctement annotées et des indices de type, rendant notre code plus lisible/maintenable et en général plus robuste, c'est-à-dire

```python

```python

class Fruit(BaseModel):

classe Fruit (BaseModel):

fruit: str

fruit : str

```

```

OpenAI actually strongly recommends the use of Pydantic for specifying schemas, as opposed to specifying the “raw” JSON schema directly. There are several reasons for this. Firstly, Pydantic is guaranteed to adhere to the JSON schema specification, so it saves you extra pre-validation steps. Secondly, for larger schemas, it is less verbose, allowing you to write cleaner code, faster. Finally, the openai Python package actually does some housekeeping, like setting additionalProperties to False for you, whereas when defining your schema “by-hand” using JSON, you would need to set these manually, for every object in your schema (failing to do so results in a rather annoying API error).

OpenAI recommande en fait fortement l'utilisation de Pydantic pour spécifier les schémas, plutôt que de spécifier directement le schéma JSON « brut ». Il y a plusieurs raisons à cela. Premièrement, Pydantic est garanti d'adhérer à la spécification du schéma JSON, ce qui vous évite des étapes de pré-validation supplémentaires. Deuxièmement, pour les schémas plus volumineux, il est moins détaillé, ce qui vous permet d'écrire du code plus propre, plus rapidement. Enfin, le package openai Python effectue en fait quelques tâches ménagères, comme définir des propriétés supplémentaires sur False pour vous, alors que lors de la définition de votre schéma « à la main » à l'aide de JSON, vous devrez les définir manuellement, pour chaque objet de votre schéma (à défaut de le faire). cela entraîne donc une erreur API plutôt ennuyeuse).

## Limitations

## Limites

As we alluded to previously, the ChatCompletions API provides a limited subset of the full JSON schema specification. There are numerous keywords that are not yet supported, such as minimum and maximum for numbers, and minItems and maxItems for arrays — annotations that would be otherwise very useful in reducing hallucinations, or constraining the output size.

Comme nous l'avons mentionné précédemment, l'API ChatCompletions fournit un sous-ensemble limité de la spécification complète du schéma JSON. Il existe de nombreux mots-clés qui ne sont pas encore pris en charge, tels que minimum et maximum pour les nombres, et minItems et maxItems pour les tableaux – des annotations qui seraient autrement très utiles pour réduire les hallucinations ou limiter la taille de sortie.

Certain formatting features are also unavailable. For example, the following Pydantic schema would result in API error when passed to response_format in ChatCompletions:

Certaines fonctionnalités de formatage sont également indisponibles. Par exemple, le schéma Pydantic suivant entraînerait une erreur d'API lorsqu'il serait transmis à réponse_format dans ChatCompletions :

```python

```python

class Post(BaseModel):

classe Post (BaseModel):

date_published: datetime

date_published : dateheure

```

```

It would fail because openai package has no format handling for datetime , so instead you would need to set date_published as a str and perform format validation (e.g. ISO 8601 compliance) post-hoc.

Cela échouerait car le package openai n'a pas de gestion de format pour datetime , vous devrez donc définir date_published comme str et effectuer une validation de format (par exemple, conformité ISO 8601) post-hoc.

Other key limitations include the following:

Les autres limitations clés sont les suivantes :

- Schemas must be able to be represented using Pydantic models.

- Les schémas doivent pouvoir être représentés à l'aide de modèles Pydantic.

- Schemas must be able to be serialized to JSON.

- Les schémas doivent pouvoir être sérialisés en JSON.

- Schemas must be able to be validated using Pydantic models.

- Les schémas doivent pouvoir être validés à l'aide de modèles Pydantic.

- Schemas must be able to be deserialized from JSON.

- Les schémas doivent pouvoir être désérialisés depuis JSON.

## Tips and tricks

## Trucs et astuces

With all this in mind, we can now go through a couple of use cases with tips and tricks on how to enhance the performance when using structured outputs.

Avec tout cela à l’esprit, nous pouvons maintenant passer en revue quelques cas d’utilisation avec des trucs et astuces sur la façon d’améliorer les performances lors de l’utilisation de sorties structurées.

### Creating flexibility using optional parameters

### Créer de la flexibilité à l'aide de paramètres facultatifs

Let’s say we are building a web scraping application where our goal is to collect specific components from the web pages. For each web page, we supply the raw HTML in the user prompt, give specific scraping instructions in the system prompt, and define the following Pydantic model:

Disons que nous construisons une application de web scraping dans laquelle notre objectif est de collecter des composants spécifiques à partir des pages Web. Pour chaque page Web, nous fournissons le code HTML brut dans l'invite utilisateur, donnons des instructions de scraping spécifiques dans l'invite système et définissons le modèle Pydantic suivant :

```python

```python