GPT-4o API-Tutorial: Erste Schritte mit der API von OpenAI

OpenAI's GPT-4o bringt Audio, Bildverarbeitung und Text in ein einziges, starkes Sprachmodell zusammen.

Diese Entwicklung ist ein wichtiger Schritt in Richtung einer natürlicheren und intuitiveren Interaktion zwischen Mensch und Computer.

In diesem Tutorial zeige ich dir Schritt für Schritt, wie du GPT-4o über die OpenAI-API nutzen kannst.

Auch wenn OpenAI kürzlich das o3-Modellrausgebracht hat – seinleistungsfähigstes Modell für logisches Denken –, sind GPT-4o und GPT-4o mini immer noch die besten Optionen für Anwendungen, die schnelle Antworten, Bildverarbeitung oder Funktionsaufrufe brauchen. Wenn dein Projekt fortgeschrittenes Schlussfolgern erfordert, solltest du dir dieses OpenAI O1 API-Tutorial ansehen, das dich durch den Prozess der Verwendung eines Schlussfolgerungsmodells über die API führt.

Was ist GPT-4o?

GPT-4o, kurz für „omni“, ist ein großer Schritt vorwärts in der KI. Anders als GPT-4, das nur mit Text klarkommt, ist GPT-4o ein multimodales Modell, das Text, Audio und visuelle Daten verarbeitet und generiert.

Durch die Einbindung von Audio- und Videodaten neben Text bricht GPT-4o aus den Grenzen traditioneller, rein textbasierter Modelle aus und ermöglicht so natürlichere und intuitivere Interaktionen.

GPT-4o hat eine schnellere Reaktionszeit, ist 50 % günstiger als GPT-4 Turbo und kann Audio- und Bilddaten besser verstehen als andere Modelle.

Wenn du einen genaueren Überblick über GPT-4o haben willst, schau dir diesen Artikel über „Was ist OpenAI’s GPT-4o?“ an.

Anwendungsfälle für GPT-4o

Neben der Interaktion mit GPT-4o über die ChatGPT-Schnittstelle können Entwickler auch über die OpenAI-API mit GPT-4o interagieren und so die Funktionen von GPT-4o in ihre Anwendungen und Systeme integrieren.

Die GPT-4o-API macht mit ihren multimodalen Funktionen jede Menge Anwendungsmöglichkeiten möglich:

GPT-4o API: So verbindest du dich mit der API von OpenAI

Schauen wir uns jetzt mal an, wie man GPT-4o über die OpenAI-API nutzen kann.

Schritt 1: API-Schlüssel erstellen

Bevor wir die GPT-4o-API nutzen können, müssen wir uns für ein OpenAI-Konto anmelden und einen API-Schlüssel holen. Wir können ein Konto auf der OpenAI API-Website erstellen.

Sobald wir ein Konto haben, können wir zur Seite mit den API-Schlüsseln gehen:

Jetzt können wir einen API-Schlüssel erstellen. Wir müssen es sicher aufbewahren, da wir es sonst nicht mehr sehen können. Aber wir können jederzeit einen neuen erstellen, wenn wir ihn verlieren oder für ein anderes Projekt brauchen.

Schritt 2: Importiere die OpenAI-API in Python

Um mit der GPT-4o-API zu programmieren, müssen wir die OpenAI Python-Bibliothek installieren. Dazu kannst du den folgenden Befehl ausführen:

Nach der Installation können wir die benötigten Module in unser Python-Skript importieren:

from openai import OpenAI

Schritt 3: Mach einen API-Aufruf

Bevor wir API-Anfragen stellen können, müssen wir uns mit unserem API-Schlüssel authentifizieren:

# Set the API keyclient = OpenAI(api_key="your_api_key_here")

Ersetz einfach „ "your_api_key_here" “ durch deinen echten API-Schlüssel.

Nachdem die Verbindung zum Client hergestellt ist, können wir mit der Textgenerierung mit GPT-4o loslegen:

MODEL = "gpt-4o"completion = client.chat.completions.create(    model=MODEL,    messages=[        {"role": "system", "content": "You are a helpful assistant that helps me with my math homework!"},        {"role": "user", "content": "Hello! Could you solve 20 x 5?"}    ])print("Assistant: " + completion.choices[0].message.content)

Dieser Codeausschnitt nutzt die Chat-Vervollständigungs-API mit dem GPT-4o-Modell, das mathematische Fragen als Eingabe nimmt und eine Antwort gibt:

GPT-4o API: Anwendungsfälle für Audio

Die Transkription und Zusammenfassung von Audioaufnahmen sind mittlerweile echt wichtige Tools in vielen Bereichen, von der Verbesserung der Barrierefreiheit bis hin zur Steigerung der Produktivität. Mit der GPT-4o-API können wir Aufgaben wie das Transkribieren und Zusammenfassen von Audioinhalten ganz einfach erledigen.

GPT-4o kann zwar Audio direkt verarbeiten, aber die direkte Audioeingabe ist über die API noch nicht verfügbar. Im Moment können wir mit der GPT-4o-API in zwei Schritten Audioinhalte transkribieren und dann zusammenfassen.

Schritt 1: Audio in Text umwandeln

Um eine Audiodatei mit GPT-4o zu transkribieren, musst du die Audiodaten an die API senden. Hier ein Beispiel:

# Transcribe the audioaudio_path = "path/to/audio.mp3"transcription = client.audio.transcriptions.create(    model="whisper-1",    file=open(audio_path, "rb"),)

Ersetz „ "path/to/audio.mp3" “ durch den tatsächlichen Pfad zu deiner Audiodatei. In diesem Beispiel wird das Modell „ whisper-1 “ für die Transkription verwendet.

Schritt 2: Audio-Text zusammenfassen

response = client.chat.completions.create(    model=MODEL,    messages=[        {            "role": "system",            "content": """You are generating a transcript summary. Create a summary of the provided transcription. Respond in Markdown."""        },        {            "role": "user",            "content": [                {"type": "text", "text": f"The audio transcription is: {transcription.text}"}            ],        }    ],    temperature=0,)print(response.choices[0].message.content)

GPT-4o API: Anwendungsfälle für Vision

Die visuelle Datenanalyse ist in vielen Bereichen super wichtig, von der Gesundheitsversorgung bis zur Sicherheit und darüber hinaus. Mit der GPT-4o-API kannst du Bilder ganz einfach analysieren, über visuelle Inhalte quatschen und wichtige Infos aus Bildern rausholen.

Schritt 1: Füge Bilddaten zur API hinzu

Um ein Bild mit GPT-4o zu analysieren, musst du erst die Bilddaten an die API schicken. Dazu können wir entweder ein lokales Bild als „ base64 “-Zeichenkette kodieren oder eine URL zu einem Online-Bild angeben:

import base64IMAGE_PATH = "image_path"# Open the image file and encode it as a base64 stringdef encode_image(image_path):    with open(image_path, "rb") as image_file:        return base64.b64encode(image_file.read()).decode("utf-8")base64_image = encode_image(IMAGE_PATH)

 "url": "<https://images.saymedia-content.com/.image/c_limit%2Ccs_srgb%2Cq_auto:eco%2Cw_538/MTczOTQ5NDQyMzQ3NTc0NTc5/compound-shapes-how-to-find-the-area-of-a-l-shape.webp>"

Schritt 2: Analysiere die Bilddaten

Sobald wir das Bild verarbeitet haben, können wir die Bilddaten zur Analyse an die API weiterleiten.

Versuchen wir mal, ein Bild zu analysieren, um die Fläche einer Form zu bestimmen. Schauen wir uns erst mal das Bild unten an:

Jetzt bitten wir GPT-4o, die Fläche dieser Form zu ermitteln – beachte, dass wir unten eine Base64-Bildeingabe verwenden:

response = client.chat.completions.create(    model=MODEL,    messages=[        {            "role": "system",            "content": "You are a helpful assistant that responds in Markdown. Help me with my math homework!"        },        {            "role": "user",            "content": [                {"type": "text", "text": "What's the area of the shape in this image?"},                {                    "type": "image_url",                    "image_url": {                        "url": f"data:image/png;base64,{base64_image}"                    }                }            ]        }    ],    temperature=0.0,)print(response.choices[0].message.content)

Schauen wir uns jetzt mal diese Form an:

Wir schicken die Bild-URL an GPT-4o, um den Bereich der Form zu finden:

response = client.chat.completions.create(    model=MODEL,    messages=[        {            "role": "system",            "content": "You are a helpful assistant that responds in Markdown. Help me with my math homework!"        },        {            "role": "user",            "content": [                {"type": "text", "text": "What's the area of the shape in the image?"},                {                    "type": "image_url",                    "image_url": {                        "url": "https://images.saymedia-content.com/.image/c_limit%2Ccs_srgb%2Cq_auto:eco%2Cw_538/MTczOTQ5NDQyMzQ3NTc0NTc5/compound-shapes-how-to-find-the-area-of-a-l-shape.webp"                    }                }            ]        }    ],    temperature=0.0,)print(response.choices[0].message.content)

Schau mal, GPT-4o hat die Breite des vertikalen Rechtecks falsch gemessen – sie sollte vier Zentimeter betragen, nicht zwei. Diese Abweichung kommt daher, dass die Messangaben und die echten Proportionen des Rechtecks nicht ganz passen. Das zeigt mal wieder, wie wichtig es ist, dass Menschen alles checken und bestätigen.

Preise für die GPT-4o-API

Ab Juli 2025 gilt für GPT-4o die folgende Pay-as-you-go-Preisgestaltung:

• Eingabetoken: 5,00 $ pro Million Tokens

• Zwischengespeicherte Eingabetoken: 2,50 $ pro Million Tokens

• Ausgabe-Token: 20,00 $ pro Million Tokens

GPT-4o Mini: Eine kostengünstige Alternative

Für Anwendungen, die viele API-Aufrufe brauchen, hat OpenAI GPT-4o Mini, eine vereinfachte Version von GPT-4o:

• Eingabetoken: 0,60 $ pro Million Tokens

• Zwischengespeicherte Eingabetoken: 0,30 $ pro Million Tokens

• Ausgegebene Token: 2,40 $ pro Million Tokens

Rabatte für die Batch-API

Die Batch-API von OpenAI bietet einen Rabatt von 50 % auf die Kosten für Eingabe- und Ausgabetoken für GPT-4o:

• Eingabetoken: 2,50 $ pro Million Tokens

• Ausgabe-Token: 10,00 $ pro Million Tokens

Das ist super, um viele Daten gleichzeitig zu verarbeiten.

GPT-4o API: Wichtige Überlegungen

Bei der Arbeit mit der GPT-4o-API solltest du ein paar wichtige Punkte beachten, um optimale Leistung, Kosteneffizienz und die richtige Anpassung an den jeweiligen Anwendungsfall sicherzustellen. Hier sind drei wichtige Punkte, die du beachten solltest:

Preise und Kostenmanagement

Die OpenAI-API funktioniert nach einem Pay-per-Use-Modell, bei dem die Kosten von der Anzahl der verarbeiteten Tokens abhängen.

Obwohl GPT-4o günstiger ist als GPT-4 Turbo, ist es wichtig, die Nutzung gut zu planen, um die Kosten richtig einzuschätzen und im Griff zu behalten.

Um die Kosten niedrig zu halten, kannst du Techniken wie Batching und die Optimierung von Eingabeaufforderungen nutzen, um die Anzahl der API-Aufrufe und verarbeiteten Tokens zu reduzieren.

Latenz und Leistung

Auch wenn GPT-4o echt beeindruckend schnell ist und wenig Zeit braucht, ist es trotzdem ein großes Sprachmodell. Das heißt, dass die Verarbeitung von Anfragen ziemlich viel Rechenleistung braucht, was zu einer etwas längeren Wartezeit führen kann.

Wir müssen unseren Code optimieren und Techniken wie Caching und asynchrone Verarbeitung einsetzen, um Latenzprobleme zu verringern.

Außerdem können wir die speziellen Instanzen von OpenAI ausprobieren oder das Modell für unseren speziellen Anwendungsfall optimieren, um die Leistung zu verbessern und die Latenz zu verringern.

Anpassung der Anwendungsfälle

GPT-4o ist ein starkes allgemeines Modell mit vielen Möglichkeiten, aber wir müssen sichergehen, dass unser spezieller Anwendungsfall zu den Stärken des Modells passt.

Bevor wir uns nur auf GPT-4o verlassen, sollten wir unseren Anwendungsfall genau anschauen und überlegen, ob das Modell das kann, was wir brauchen.

Wenn nötig, können wir kleinere Modelle optimieren oder andere Modelle ausprobieren, die für unsere spezielle Aufgabe besser passen.

Fazit

Die multimodalen Fähigkeiten von GPT-4o's lösen die Probleme früherer Modelle, die Schwierigkeiten hatten, verschiedene Datentypen nahtlos zu integrieren und zu verarbeiten.

Mit der GPT-4o-API können Entwickler innovative Lösungen entwickeln, die Text, Audio und visuelle Daten nahtlos zusammenbringen.

Wenn du mehr mit GPT-4o üben willst, empfehle ich dir diesen Code-Along zum Erstellen von KI-Assistenten mit GPT-4o. Wenn du mehr über die Arbeit mit APIs erfahren möchtest, empfehle ich dir diese Ressourcen:

• Arbeiten mit der OpenAI-API
• OpenAI-Kochbuch
• OpenAI API-Spickzettel