GPT-4o-2024-08-06: Was ist neu und wie verwendet man strukturierte Daten?

Here is the translated HTML code in German: ```html

OpenAI hat mit der Veröffentlichung von GPT-4o-2024-08-06 erneut die Grenzen der künstlichen Intelligenz erweitert und strukturierten Output in die API eingeführt. Dieses bahnbrechende Feature stellt einen wesentlichen Fortschritt in der Zuverlässigkeit und Benutzerfreundlichkeit von KI-generierten Inhalten dar, insbesondere für Entwickler und Unternehmen, die auf die Erzeugung strukturierten Daten angewiesen sind.

GPT-4o-2024-08-06: Was ist neu?

Historisch gesehen haben große Sprachmodelle (LLMs) hervorragende menschliche Texte generiert, aber Schwierigkeiten, konsistent strukturierte Daten gemäß spezifischer Formate zu produzieren. GPT-4o-2024-08-06 geht dieses Problem mit der Einführung von strukturierten Ausgaben direkt an und stellt sicher, dass die vom Modell generierten Ausgaben genau den von den Entwicklern bereitgestellten JSON-Schemas entsprechen.

GPT-4o-2024-08-06 ist wirklich gut bei JSON-Schema

Zuerst die Grundlagen:

• Die Leistungsverbesserung von GPT-4o-2024-08-06 mit strukturierten Ausgaben ist bemerkenswert.
• In den Bewertungen von OpenAI zu komplexen JSON-Schemas erreicht dieses neue Modell eine perfekte Punktzahl von 100%, im Vergleich zu seinem Vorgänger, GPT-4-0613, das weniger als 40% in denselben Tests erzielte.

GPT-4o-2024-08-06 ist besser und günstiger als GPT-4O

Vergleichen wir GPT-4o-2024-08-06 mit seinen Vorgängermodellen und dem kompakteren GPT-4o-mini:

MMLU (Massive Multitask Language Understanding)

• GPT-4o-2024-08-06: 88.7% (5-shot)
• GPT-4o: 88.7% (5-shot)
• GPT-4o-mini: 82.0% (5-shot)
• GPT-4 (Juni 2023 Version): 86.4% (5-shot)

MMMU (Massive Multitask Multimodal Understanding)

• GPT-4o-2024-08-06: 69.1%
• GPT-4o: 69.1%
• GPT-4o-mini: 59.4%
• GPT-4 (Juni 2023 Version): 34.9%

Preise (pro Million Tokens)

• GPT-4o-2024-08-06: 5,00 $ Eingabe, 15,00 $ Ausgabe
• GPT-4o: 5,00 $ Eingabe, 15,00 $ Ausgabe
• GPT-4o-mini: 0,15 $ Eingabe, 0,60 $ Ausgabe
• GPT-4 (Juni 2023 Version): 30,00 $ Eingabe, 60,00 $ Ausgabe

Kontextfenster

• GPT-4o-2024-08-06: 128K Tokens
• GPT-4o: 128K Tokens
• GPT-4o-mini: 128K Tokens
• GPT-4 (Juni 2023 Version): 8.192 Tokens

Diese Benchmarks zeigen, dass GPT-4o-2024-08-06 die hohe Leistung von GPT-4o beibehält und gleichzeitig das neue Feature der strukturierten Ausgaben einführt. GPT-4o-mini bietet, obwohl es nicht so leistungsstark ist, eine kostengünstigere Lösung für viele Anwendungen.

Strukturierte Ausgaben: Der neue Trick von OpenAI

OpenAI hat strukturierte Ausgaben in zwei Hauptformen innerhalb der API eingeführt:

1. Funktionsaufruf
2. Antwortformat-Parameter

Lass uns erkunden, wie man diese Funktionen mit Schritt-für-Schritt-Anleitungen und Beispielcodes verwendet.

Schritt-für-Schritt-Anleitung: Verwendung strukturierten Ausgaben

1. Funktionsaufruf mit strukturierten Ausgaben

Schritt 1: Definiere deine Funktion mit einem strengen Schema

import openai

function_schema = {
    "name": "get_current_weather",
    "description": "Holen Sie sich das aktuelle Wetter an einem bestimmten Ort",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "Die Stadt und der Staat, z.B. San Francisco, CA"
            },
            "temperature_unit": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"]
            }
        },
        "required": ["location", "temperature_unit"]
    },
    "strict": True  # Dies aktiviert strukturierte Ausgaben
}

client = openai.OpenAI()
response = client.chat.completions.create(
    model="gpt-4o-2024-08-06",
    messages=[
        {"role": "user", "content": "Wie ist das Wetter in Boston?"}
    ],
    functions=[function_schema],
    function_call={"name": "get_current_weather"}
)

print(response.choices[0].message.function_call)

2. Antwortformat-Parameter mit strukturierten Ausgaben

Schritt 1: Definiere dein JSON-Schema

json_schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"},
        "cities_visited": {
            "type": "array",
            "items": {"type": "string"}
        }
    },
    "required": ["name", "age", "cities_visited"]
}

response = client.chat.completions.create(
    model="gpt-4o-2024-08-06",
    messages=[
        {"role": "user", "content": "Generiere ein Profil für einen Weltreisenden namens John, der 30 Jahre alt ist."}
    ],
    response_format={"type": "json_object", "json_schema": json_schema}
)

print(response.choices[0].message.content)

3. Verwendung strukturierter Ausgaben mit SDKs

OpenAI hat seine Python- und Node-SDKs mit nativer Unterstützung für strukturierte Ausgaben aktualisiert. Hier ist ein Beispiel mit dem Python SDK und Pydantic:

from pydantic import BaseModel, Field
from typing import List
from openai import OpenAI

class Traveler(BaseModel):
    name: str
    age: int
    cities_visited: List[str] = Field(min_items=1)

client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4o-2024-08-06",
    messages=[
        {"role": "user", "content": "Generiere ein Profil für eine Weltreisende namens Sarah, die 28 Jahre alt ist."}
    ],
    response_format={"type": "json_object", "schema": Traveler.model_json_schema()}
)

traveler = Traveler.model_validate_json(response.choices[0].message.content)
print(f"Name: {traveler.name}, Alter: {traveler.age}, Besuchte Städte: {', '.join(traveler.cities_visited)}")

Best Practices für die Verwendung strukturierter Ausgaben

1. Definiere klare Schemas: Stelle sicher, dass deine JSON-Schemas gut definiert sind und alle möglichen Ausgaben abdecken.
2. Umgang mit Ablehnungen: Implementiere Logik, um mit Fällen umzugehen, in denen das Modell die Ausgabe aufgrund von Sicherheitsbedenken verweigert.
3. Validiere Ausgaben: Obwohl strukturierte Ausgaben die Einhaltung des Schemas garantieren, validiere immer den Inhalt auf Genauigkeit.
4. Optimiere für Leistung: Cache vorverarbeitete Schemata, um die Latenz bei nachfolgenden Anfragen zu reduzieren.
5. Kombiniere mit Funktionsaufrufen: Verwende strukturierte Ausgaben zusammen mit Funktionsaufrufen für komplexere Anwendungen.

Einschränkungen und Überlegungen

Trotz ihrer Fortschritte haben GPT-4o-2024-08-06 und strukturierte Ausgaben einige Einschränkungen:

• Nur ein Teilmenge von JSON-Schema wird unterstützt.
• Die erste API-Antwort mit einem neuen Schema verursacht zusätzliche Latenz.
• Obwohl Struktur garantiert ist, ist die Inhaltsgenauigkeit nicht.
• Strukturierte Ausgaben sind nicht kompatibel mit parallelen Funktionsaufrufen.
• Verwendete JSON-Schemas sind nicht für Zero Data Retention (ZDR) berechtigt.

Fazit

GPT-4o-2024-08-06 und sein Feature der strukturierten Ausgaben stellen einen bedeutenden Fortschritt in der Zuverlässigkeit von KI-generierten Inhalten dar. Durch die Lösung des Problems, konsistent strukturierte Daten zu erzeugen, hat OpenAI neue Möglichkeiten für Entwickler und Unternehmen erschlossen. Da sich die KI-Landschaft weiterhin entwickelt, setzt GPT-4o-2024-08-06 einen neuen Standard für Präzision und Struktur in KI-gestützten Anwendungen und ebnet den Weg für anspruchsvollere und zuverlässigere KI-Systeme in verschiedenen Branchen.

``` This translated HTML code maintains the original structure while converting the text content to German.