Mit strukturierten Ergebnissen tiefer eintauchen

Wir helfen Ihnen dabei, Ihr Verständnis und die optimale Nutzung strukturierter Ausgaben und LLMs zu verbessern

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.

Im vorherigen Artikel wurden wir mit strukturierten Ausgaben mithilfe von OpenAI vertraut gemacht. Seit der Veröffentlichung der allgemeinen Verfügbarkeit in der ChatCompletions-API (v1.40.0) wurden strukturierte Ausgaben auf Dutzende von Anwendungsfällen angewendet und zahlreiche Threads in OpenAI-Foren hervorgebracht.

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.

Unser Ziel ist es, Ihnen mit diesem Artikel ein noch tieferes Verständnis zu vermitteln, einige Missverständnisse auszuräumen und Ihnen einige Tipps zu geben, wie Sie diese in verschiedenen Szenarien optimal anwenden können.

## Structured outputs overview

## Übersicht über strukturierte Ausgaben

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.

Strukturierte Ausgaben sind eine Möglichkeit, die Ausgabe eines LLM so zu erzwingen, dass sie einem vordefinierten Schema folgt – normalerweise einem JSON-Schema. Dies funktioniert durch die Umwandlung des Schemas in eine kontextfreie Grammatik (CFG), die während des Token-Sampling-Schritts zusammen mit den zuvor generierten Token verwendet wird, um zu informieren, welche nachfolgenden Token gültig sind. Es ist hilfreich, sich das so vorzustellen, als würde man einen regulären Ausdruck für die Token-Generierung erstellen.

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.

Die OpenAI-API-Implementierung verfolgt tatsächlich eine begrenzte Teilmenge der JSON-Schemafunktionen. Mit allgemeineren strukturierten Ausgabelösungen wie Outlines ist es möglich, eine etwas größere Teilmenge des JSON-Schemas zu verwenden und sogar vollständig benutzerdefinierte Nicht-JSON-Schemas zu definieren – solange man Zugriff auf ein offenes Gewichtungsmodell hat. Für den Zweck dieses Artikels gehen wir von der OpenAI-API-Implementierung aus.

### JSON Schema and Pydantic

### JSON-Schema und 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 .

Gemäß der JSON-Schema-Kernspezifikation „legt das JSON-Schema fest, wie ein JSON-Dokument aussehen muss, wie Informationen daraus extrahiert werden können und wie mit ihm interagiert wird“. Das JSON-Schema definiert sechs primitive Typen: Null, Boolescher Wert, Objekt, Array, Zahl und Zeichenfolge. Außerdem werden bestimmte Schlüsselwörter, Anmerkungen und spezifische Verhaltensweisen definiert. Beispielsweise können wir in unserem Schema angeben, dass wir ein Array erwarten, und eine Anmerkung hinzufügen, dass minItems 5 sein soll.

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 ist eine Python-Bibliothek, die die JSON-Schemaspezifikation implementiert. Wir verwenden Pydantic, um robuste und wartbare Software in Python zu erstellen. Da Python eine dynamisch typisierte Sprache ist, denken Datenwissenschaftler nicht unbedingt in Variablentypen – diese sind oft in ihrem Code impliziert. Eine Frucht würde beispielsweise wie folgt spezifiziert:

```python

„Python

fruit = "apple"

Frucht = „Apfel“

```

„

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

…während eine Funktionsdeklaration, die „Frucht“ aus einem Datenelement zurückgibt, oft wie folgt angegeben wird:

```python

„Python

def get_fruit(data):

def get_fruit(data):

return data

Daten zurückgeben

```

„

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 hingegen ermöglicht es uns, eine JSON-Schema-kompatible Klasse mit ordnungsgemäß annotierten Variablen und Typhinweisen zu generieren, wodurch unser Code lesbarer/wartbarer und im Allgemeinen robuster wird, d. h

```python

„Python

class Fruit(BaseModel):

Klasse Fruit(BaseModel):

fruit: str

Frucht: 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 empfiehlt tatsächlich dringend die Verwendung von Pydantic zur Angabe von Schemata, anstatt das „rohe“ JSON-Schema direkt anzugeben. Dafür gibt es mehrere Gründe. Erstens hält sich Pydantic garantiert an die JSON-Schemaspezifikation, sodass Sie zusätzliche Schritte vor der Validierung einsparen. Zweitens ist es bei größeren Schemata weniger ausführlich, sodass Sie saubereren Code schneller schreiben können. Schließlich übernimmt das openai-Python-Paket tatsächlich einige Verwaltungsaufgaben, wie z. B. das Festlegen von „additionalProperties“ auf „False“ für Sie, wohingegen Sie diese manuell für jedes Objekt in Ihrem Schema festlegen müssten, wenn Sie Ihr Schema „von Hand“ mit JSON definieren (was nicht möglich ist). was zu einem ziemlich ärgerlichen API-Fehler führt).

## Limitations

## Einschränkungen

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.

Wie bereits erwähnt, stellt die ChatCompletions-API eine begrenzte Teilmenge der vollständigen JSON-Schemaspezifikation bereit. Es gibt zahlreiche Schlüsselwörter, die noch nicht unterstützt werden, wie zum Beispiel „Minimum“ und „Maximum“ für Zahlen sowie „minItems“ und „maxItems“ für Arrays – Anmerkungen, die andernfalls sehr nützlich wären, um Halluzinationen zu reduzieren oder die Ausgabegröße einzuschränken.

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

Bestimmte Formatierungsfunktionen sind ebenfalls nicht verfügbar. Das folgende Pydantic-Schema würde beispielsweise zu einem API-Fehler führen, wenn es in ChatCompletions an „response_format“ übergeben wird:

```python

„Python

class Post(BaseModel):

Klasse Post(BaseModel):

date_published: datetime

date_published: datetime

```

„

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.

Dies würde fehlschlagen, da das OpenAI-Paket keine Formatverarbeitung für datetime hat. Stattdessen müssten Sie date_published als str festlegen und im Nachhinein eine Formatvalidierung (z. B. ISO 8601-Konformität) durchführen.

Other key limitations include the following:

Weitere wichtige Einschränkungen sind die folgenden:

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

- Schemata müssen mit Pydantic-Modellen darstellbar sein.

- Schemas must be able to be serialized to JSON.

- Schemata müssen in JSON serialisiert werden können.

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

- Schemata müssen mit Pydantic-Modellen validierbar sein.

- Schemas must be able to be deserialized from JSON.

– Schemata müssen von JSON deserialisiert werden können.

## Tips and tricks

## Tipps und Tricks

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.

Vor diesem Hintergrund können wir nun einige Anwendungsfälle mit Tipps und Tricks zur Leistungssteigerung bei der Verwendung strukturierter Ausgaben durchgehen.

### Creating flexibility using optional parameters

### Flexibilität schaffen durch optionale Parameter

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:

Nehmen wir an, wir erstellen eine Web-Scraping-Anwendung, deren Ziel es ist, bestimmte Komponenten von den Webseiten zu sammeln. Für jede Webseite stellen wir den Roh-HTML-Code in der Benutzereingabeaufforderung bereit, geben in der Systemeingabeaufforderung spezifische Scraping-Anweisungen und definieren das folgende Pydantic-Modell:

```python

„Python