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

Was ist GPT-4o?

GPT-4o, kurz für "omni", ist ein bedeutender Fortschritt in der KI. Im Gegensatz zu GPT-4, das nur Text verarbeitet, ist GPT-4o ein multimodales Modell, das Text-, Audio- und visuelle Daten verarbeitet und erzeugt.

Indem GPT-4o neben dem Text auch Audio- und visuelle Daten einbezieht, befreit es sich von den Beschränkungen herkömmlicher reiner Textmodelle und schafft natürlichere und intuitivere Interaktionen.

Der GPT-4o hat eine schnellere Reaktionszeit, ist 50 % billiger als der GPT-4 Turbo und ist besser im Verstehen von Audio und Vision als die bisherigen Modelle.

GPT-4o Anwendungsfälle

Zusätzlich zur Interaktion mit GPT-4o über die ChatGPT-Schnittstelle können Entwickler/innen mit GPT-4o über die OpenAI API interagieren und so die Fähigkeiten von GPT-4o in ihre Anwendungen und Systeme integrieren.

Die GPT-4o API eröffnet durch ihre multimodalen Fähigkeiten eine große Bandbreite an potenziellen Anwendungsfällen:

GPT-4o API: Wie man sich mit der API von OpenAI verbindet

Lass uns nun herausfinden, wie du GPT-4o über die OpenAI API nutzen kannst.

Schritt 1: Einen API-Schlüssel generieren

Bevor wir die GPT-4o API nutzen können, müssen wir uns für ein OpenAI-Konto anmelden und einen API-Schlüssel erhalten. 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 navigieren:

Wir können jetzt einen API-Schlüssel generieren. Wir müssen sie sicher aufbewahren, denn wir werden sie nicht mehr sehen können. Aber wir können jederzeit eine neue erstellen, wenn wir sie verlieren oder für ein anderes Projekt benötigen.

Schritt 2: Importiere die OpenAI API in Python

Um mit der GPT-4o API programmatisch zu interagieren, müssen wir die OpenAI Python-Bibliothek installieren. Wir können dies tun, indem wir 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: Einen API-Aufruf tätigen

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

## Set the API key
client = OpenAI(api_key="your_api_key_here")

Ersetze "your_api_key_here" durch deinen tatsächlichen API-Schlüssel.

Nachdem wir die Client-Verbindung hergestellt haben, können wir mit der Texterstellung mit GPT-4o beginnen:

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)

Dieses Codeschnipsel verwendet die Chatvervollständigungs-API mit dem GPT-4o-Modell, das mathematische Fragen als Eingabe akzeptiert und eine Antwort erzeugt:

GPT-4o API: Audio Anwendungsfälle

Die Audiotranskription und -zusammenfassung sind zu unverzichtbaren Werkzeugen für verschiedene Anwendungen geworden, von der Verbesserung der Zugänglichkeit bis zur Steigerung der Produktivität. Mit der GPT-4o API können wir Aufgaben wie das Transkribieren und Zusammenfassen von Audioinhalten effizient erledigen.

Obwohl der GPT-4o das Potenzial hat, Audio direkt zu verarbeiten, ist die Funktion der direkten Audioeingabe noch nicht über die API verfügbar. Im Moment können wir einen zweistufigen Prozess mit der GPT-4o API verwenden, um Audioinhalte zu transkribieren und dann zusammenzufassen.

Schritt 1: Audio in Text umwandeln

Um eine Audiodatei mit GPT-4o zu transkribieren, müssen wir der API die Audiodaten zur Verfügung stellen. Hier ist ein Beispiel:

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

Ersetze "path/to/audio.mp3" durch den tatsächlichen Pfad zu deiner Audiodatei. Dieses Beispiel verwendet das whisper-1 Modell für die Transkription.

Schritt 2: Audiotext 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: Vision Use Cases

Die visuelle Datenanalyse ist in vielen Bereichen wichtig, vom Gesundheitswesen bis zur Sicherheit und darüber hinaus. Mit der GPT-4o API kannst du Bilder nahtlos analysieren, dich an Konversationen über visuelle Inhalte beteiligen und wertvolle Informationen aus Bildern extrahieren.

Schritt 1: Bilddaten zur API hinzufügen

Um ein Bild mit GPT-4o zu analysieren, müssen wir der API zunächst die Bilddaten zur Verfügung stellen. Wir können dies tun, indem wir entweder ein lokales Bild als base64 String kodieren oder eine URL zu einem Online-Bild angeben:

import base64

IMAGE_PATH = "image_path"

# Open the image file and encode it as a base64 string
def 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 die Bildeingabe verarbeitet haben, können wir die Bilddaten zur Analyse an die API übergeben.

Lass uns versuchen, ein Bild zu analysieren, um die Fläche einer Form zu bestimmen. Nehmen wir zunächst das Bild unten:

Wir bitten GPT-4o nun, die Fläche dieser Form abzufragen - beachte, dass wir unten ein base64-Bild eingeben:

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)

Betrachten wir nun diese Form:

Wir übergeben die Bild-URL an GPT-4o, um die Fläche der Form zu ermitteln:

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)

Beachte, dass GPT-4o die Breite des vertikalen Rechtecks falsch gemessen hat - sie sollte vier Zentimeter betragen, nicht zwei. Diese Diskrepanz ergibt sich aus der falschen Ausrichtung zwischen den Messbeschriftungen und den tatsächlichen Proportionen des Rechtecks. Dies unterstreicht einmal mehr, wie wichtig menschliche Aufsicht und Validierung sind.

GPT-4o API-Preise

OpenAI hat eine wettbewerbsfähige Preisstruktur für die GPT-4o API eingeführt, die sie zugänglicher und kostengünstiger macht als frühere Modelle.

Hier ist eine Zusammenfassung der Preise neben den Modellen Claude von Antropic und Gemini von Google (die Preise sind in amerikanischen Dollar angegeben):

Wie du siehst, ist der Preis für GPT-4o deutlich niedriger als der für GPT-4 Turbo und GPT-4. Außerdem ist er im Vergleich zu anderen hochmodernen Sprachmodellen wie Claude Opus und Gemini 1.5 Pro sehr preisgünstig.

GPT-4o API: Wichtige Überlegungen

Bei der Arbeit mit der GPT-4o API ist es wichtig, einige wichtige Punkte zu beachten, um eine optimale Leistung, Kosteneffizienz und Anpassung an den jeweiligen Anwendungsfall zu gewährleisten. Hier sind drei entscheidende Faktoren, die du beachten solltest:

Preisgestaltung und Kostenmanagement

Die OpenAI API folgt einem Pay-per-Use-Modell, bei dem die Kosten auf der Grundlage der Anzahl der verarbeiteten Token anfallen.

Obwohl GPT-4o billiger ist als GPT-4 Turbo, ist es wichtig, dass wir unseren Einsatz entsprechend planen, um die Kosten abzuschätzen und zu verwalten.

Um die Kosten zu minimieren, kannst du Techniken wie die Stapelverarbeitung und die Optimierung von Prompts in Betracht ziehen, um die Anzahl der API-Aufrufe und der verarbeiteten Token zu reduzieren.

Latenz und Leistung

Obwohl GPT-4o eine beeindruckende Leistung und niedrige Latenzzeiten bietet, ist es immer noch ein großes Sprachmodell, was bedeutet, dass die Verarbeitung von Anfragen rechenintensiv sein kann, was zu relativ hohen Latenzzeiten führt.

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

Außerdem können wir die dedizierten Instanzen von OpenAI nutzen oder das Modell an unseren speziellen Anwendungsfall anpassen, um die Leistung zu verbessern und die Latenz zu verringern.

Anpassung der Anwendungsfälle

GPT-4o ist ein leistungsfähiges allgemeines Modell mit einer breiten Palette von Möglichkeiten, aber wir müssen sicherstellen, dass unser spezieller Anwendungsfall mit den Stärken des Modells übereinstimmt.

Bevor wir uns ausschließlich auf GPT-4o verlassen, müssen wir unseren Anwendungsfall sorgfältig prüfen und überlegen, ob die Fähigkeiten des Modells unseren Bedürfnissen entsprechen.

Bei Bedarf können wir kleinere Modelle feinabstimmen oder andere Modelle untersuchen, die für unsere spezielle Aufgabe besser geeignet sind.

Fazit

Die multimodalen Fähigkeiten von GPT-4o überwinden die Grenzen früherer Modelle, die Schwierigkeiten hatten, verschiedene Arten von Daten nahtlos zu integrieren und zu verarbeiten.

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

Wenn du mehr Übung mit GPT-4o haben möchtest, empfehle ich dir diesen Code-Along zur Erstellung 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