Künstliche Intelligenz verändert rasant, wie wir visuelle Inhalte erstellen und mit ihnen interagieren. OpenAI steht an der Spitze dieser Revolution und bietet leistungsstarke Modelle, die in der Lage sind, Bilder mit erstaunlichem Realismus und Kreativität zu generieren und zu manipulieren. Während Modelle wie DALL·E 3 und GPT-4o diese Fähigkeiten in benutzerorientierten Tools demonstrieren, bietet OpenAI Entwicklern auch direkten Zugriff auf diese Technologie über seine Image Generation API, wobei häufig die Modellkennung gpt-image-1 verwendet wird.
Dieser Leitfaden bietet einen tiefen Einblick in die Verwendung von gpt-image-1 (der offizielle Name der erwarteten GPT-4o Image Generation API). Wir werden das zugrunde liegende Modell, seine leistungsstarken Funktionen und Preisüberlegungen untersuchen und eine umfassende Schritt-für-Schritt-Anleitung mit Python bereitstellen. Entscheidend ist, dass wir auch besprechen, wie Tools wie Apidog den Entwicklungs- und Testprozess rationalisieren und die Integration reibungsloser und effizienter gestalten können.
Benötigen Sie eine integrierte All-in-One-Plattform für Ihr Entwicklerteam, um mit maximaler Produktivität zusammenzuarbeiten?
Apidog liefert alle Ihre Anforderungen und ersetzt Postman zu einem viel günstigeren Preis!
Was ist die GPT-4o Image Generation API (gpt-image-1)?
Im Wesentlichen ist gpt-image-1 (GPT-4o Image Generation API) ein Dienst, der es Entwicklern ermöglicht, Bilder programmgesteuert mit den fortschrittlichen KI-Modellen von OpenAI zu erstellen und zu ändern. Wenn Sie mit dieser API interagieren und gpt-image-1 angeben (oder die API auf das neueste empfohlene Modell standardmäßig einstellen, das häufig mit den Fähigkeiten von GPT-4o/DALL·E 3 übereinstimmt), nutzen Sie ein ausgeklügeltes System, das auf riesigen Mengen an Text- und Bilddaten trainiert wurde.
Warum die GPT-4o Image Generation API (gpt-image-1) verwenden?
- High-Fidelity Image Generation: Erstellen Sie detaillierte, kohärente und visuell ansprechende Bilder aus Textbeschreibungen (Prompts). Das Modell zeichnet sich dadurch aus, dass es Nuancen in Prompts versteht, um genaue Ergebnisse zu liefern.
- Diverse Stylistic Range: Gehen Sie über den Fotorealismus hinaus. Generieren Sie Bilder in verschiedenen Stilen wie Ölgemälde, Aquarell, Pixelkunst, 3D-Rendering, minimalistische Linienkunst und viele mehr, indem Sie einfach die gewünschte Ästhetik in Ihrem Prompt beschreiben.
- Advanced Image Editing (Inpainting & Outpainting): Ändern Sie vorhandene Bilder. Sie können ein Bild und eine Maske (ein transparenter Bereich, der angibt, wo Änderungen erfolgen sollen) zusammen mit einem Prompt bereitstellen, um bestimmte Teile nahtlos zu bearbeiten (Inpainting) oder das Bild über seine ursprünglichen Grenzen hinaus zu erweitern (Outpainting, obwohl dies typischerweise über Prompt-Iteration erfolgt).
- Image Variations: Generieren Sie verschiedene Versionen eines Eingabebildes, wobei das Kernmotiv und der Stil beibehalten werden, aber kreative Variationen eingeführt werden.
- Sophisticated Prompt Understanding: Das Modell versteht komplexe Sätze, räumliche Beziehungen, mehrere Objekte und abstrakte Konzepte, die im Prompt beschrieben werden.
- Improved Text Rendering: Einer der wesentlichen Fortschritte ist die Fähigkeit, lesbaren und kontextuell passenden Text innerhalb generierter Bilder zu rendern, wodurch eine große Hürde für frühere Generationen von Bildmodellen überwunden wird.
- Safety by Design: Integrierte Sicherheitssysteme verhindern die Generierung von schädlichen, unangemessenen oder gegen die Richtlinien verstoßenden Inhalten basierend auf Prompts und Bildanalysen.
API-Kosten, Latenz und Inhaltsmoderation
Das Verständnis der Faktoren, die sich auf die Kosten und die Reaktionszeit auswirken, ist entscheidend, wenn Sie die gpt-image-1 API integrieren.
Kosten und Latenz:
Im Gegensatz zu einer einfachen Preisgestaltung pro Bild sind die Kosten und die Latenz für gpt-image-1 direkt proportional zum Rechenaufwand, der in Bild-Tokens gemessen wird. Das Modell generiert zuerst spezielle Bild-Tokens, die den visuellen Inhalt darstellen, bevor das endgültige Bild gerendert wird.
Die Anzahl der generierten Bild-Tokens hängt von den angeforderten Bildabmessungen (size) und der Qualitätseinstellung (quality) ab:
| Qualität | Quadratisch (1024×1024) | Hochformat (1024×1536) | Querformat (1536×1024) |
|---|---|---|---|
| Niedrig | 272 Tokens | 408 Tokens | 400 Tokens |
| Mittel | 1056 Tokens | 1584 Tokens | 1568 Tokens |
| Hoch | 4160 Tokens | 6240 Tokens | 6208 Tokens |
Höhere Qualitätseinstellungen und größere Abmessungen erfordern deutlich mehr Bild-Tokens, was zu höheren Kosten und potenziell höherer Latenz (längere Reaktionszeiten) führt.
Wichtig: Sie müssen auch die Eingabetext-Tokens berücksichtigen, die von Ihrem Prompt verbraucht werden. Die Gesamtkosten pro Anfrage basieren sowohl auf den Eingabe-Prompt-Tokens als auch auf den generierten Bild-Tokens.
Für eine präzise, aktuelle Preisgestaltung pro Text- und Bild-Token konsultieren Sie immer die offizielle OpenAI-Preisseite: https://openai.com/pricing.
Inhaltsmoderation:
OpenAI filtert alle Eingabe-Prompts und generierten Bilder anhand seiner Inhaltsrichtlinie, um Sicherheit und verantwortungsvolle Nutzung zu gewährleisten. Bei der Verwendung von gpt-image-1 haben Sie über den optionalen Parameter moderation eine gewisse Kontrolle über die Strenge der Moderation:
auto(Standard): Wendet Standardfilterung an, um die Erstellung bestimmter potenziell altersunangemessener Inhaltskategorien zu begrenzen.low: Wendet weniger restriktive Filterung an.
Wählen Sie die für den Kontext und die Benutzerbasis Ihrer Anwendung geeignete Einstellung, während Sie gleichzeitig die Nutzungsrichtlinien von OpenAI einhalten.
So verwenden Sie die OpenAI Image Generation API (gpt-image-1)
Dieser Abschnitt enthält umfassende Code-Snippets, die zeigen, wie Sie die OpenAI Image Generation API mit dem Modell gpt-image-1 über die offizielle openai Python-Bibliothek verwenden.
Voraussetzungen & Einrichtung
Stellen Sie sicher, dass Sie ein OpenAI-Konto und einen API-Schlüssel haben. Installieren Sie die erforderlichen Bibliotheken:
pip install --upgrade openai pillow
Importieren Sie die erforderlichen Module und initialisieren Sie den Client (er verwendet automatisch die Umgebungsvariable OPENAI_API_KEY):
import os
import base64
from io import BytesIO
from openai import OpenAI
from PIL import Image # Für Bildmanipulation, wenn b64_json verarbeitet wird
# Initialisieren Sie den Client
client = OpenAI()
# Stellen Sie sicher, dass der API-Schlüssel als Umgebungsvariable festgelegt ist, oder initialisieren Sie mit:
# client = OpenAI(api_key="YOUR_API_KEY")
# Empfohlen: Verwenden Sie response_format='b64_json' für die direkte Verarbeitung
# Hilfsfunktion (optional) zur Verarbeitung von b64_json-Daten:
def process_b64_json(b64_json_data, output_path):
try:
image_bytes = base64.b64decode(b64_json_data)
image = Image.open(BytesIO(image_bytes))
# Optional: Größe ändern oder andere Verarbeitung
# image = image.resize((512, 512), Image.LANCZOS)
image.save(output_path) # Speichert im Format, das aus der Erweiterung abgeleitet wird
print(f"Bild gespeichert unter {output_path}")
except Exception as e:
print(f"Fehler bei der Bildverarbeitung: {e}")
# Ausgabeverzeichnis erstellen
os.makedirs("generated_images", exist_ok=True)
output_dir = "generated_images"
Bilder generieren (client.images.generate)
Erstellen Sie neue Bilder aus Text-Prompts. gpt-image-1 zeichnet sich dadurch aus, dass es detaillierten Anweisungen folgt.
Grundlegende Generierung:
prompt_text = """
Rendere ein realistisches Bild dieses Charakters:
Blobby Alien Character Spec Name: Glorptak... [Rest des detaillierten Prompts aus dem Kochbuch]
"""
try:
response = client.images.generate(
model="gpt-image-1",
prompt=prompt_text,
size="1024x1024", # Optionen: "1024x1024", "1024x1792", "1792x1024", "auto" (Kochbuch erwähnt auch "1536x1024", "1024x1536")
quality="high", # Optionen: "standard", "hd" (API-Dokumente) oder "low", "medium", "high", "auto" (Kochbuch) - Verwenden Sie 'hd' für die beste Qualität über die API-Dokumente.
style="vivid", # Optionen: "vivid", "natural" (Optional, beeinflusst Realismus/Drama)
n=1, # Anzahl der zu generierenden Bilder
response_format="b64_json" # Oder "url"
)
# Verarbeiten Sie die Antwort (mit der Hilfsfunktion)
image_b64 = response.data[0].b64_json
output_path = os.path.join(output_dir, "glorptak.png") # Speichern als PNG
process_b64_json(image_b64, output_path)
except Exception as e:
print(f"Fehler während der Generierung: {e}")
Ausgabe anpassen:
Das Kochbuch hebt zusätzliche Parameter hervor, um die Ausgabe beim Generieren fein abzustimmen.
prompt_pixel_cat = "Generieren Sie ein Porträt im Pixel-Art-Stil einer grauen Tabby-Katze, die als blonde Frau auf dunklem Hintergrund gekleidet ist."
try:
response = client.images.generate(
model="gpt-image-1",
prompt=prompt_pixel_cat,
size="1024x1536", # Hochformatausrichtung
quality="low", # Niedrigere Qualitätseinstellung (aus dem Kochbuch)
output_format="jpeg", # JPEG-Ausgabe anfordern
output_compression=50, # JPEG-Komprimierungsgrad (0-100)
response_format="b64_json",
n=1
)
# Verarbeiten Sie die Antwort
image_b64 = response.data[0].b64_json
output_path = os.path.join(output_dir, "pixel_cat.jpeg")
process_b64_json(image_b64, output_path)
except Exception as e:
print(f"Fehler während der benutzerdefinierten Generierung: {e}")
Transparenter Hintergrund:
Verwenden Sie output_format="png" oder "webp" und setzen Sie background="transparent". Die Aufnahme von "transparenter Hintergrund" in den Prompt könnte dies auch automatisch auslösen (gemäß Kochbuch).
prompt_transparent_hat = "Generieren Sie ein Bild im Pixel-Art-Stil eines grünen Eimerhuts mit einer rosa Feder auf transparentem Hintergrund."
try:
response = client.images.generate(
model="gpt-image-1",
prompt=prompt_transparent_hat,
size="1024x1024",
quality="low",
output_format="png", # Erforderlich für Transparenz
# background="transparent", # Kann explizit festgelegt werden
response_format="b64_json",
n=1
)
# Verarbeiten Sie die Antwort
image_b64 = response.data[0].b64_json
output_path = os.path.join(output_dir, "hat_transparent.png")
process_b64_json(image_b64, output_path)
except Exception as e:
print(f"Fehler beim Generieren des transparenten Bildes: {e}")
Bilder bearbeiten (client.images.edit)
Ändern Sie vorhandene Bilder basierend auf einem Prompt. Kann mehrere Bilder kombinieren oder Masken verwenden. Erfordert, dass Bilddateien im binären Lesemodus ('rb') geöffnet werden.
Kombinieren/Bearbeiten mehrerer Bilder (Kochbuchbeispiel):
Geben Sie eine Liste geöffneter Datei-Objekte an den Parameter image an.
prompt_combine = "Kombinieren Sie die Bilder, um die Katze zu zeigen, die den Hut trägt, während sie in einem Baum sitzt, immer noch im Pixel-Art-Stil."
cat_image_path = os.path.join(output_dir, "pixel_cat.jpeg") # Gehen Sie davon aus, dass sie existiert
hat_image_path = os.path.join(output_dir, "hat_transparent.png") # Gehen Sie davon aus, dass sie existiert
img1_file = None
img2_file = None
try:
img1_file = open(cat_image_path, "rb")
img2_file = open(hat_image_path, "rb")
response = client.images.edit(
model="gpt-image-1",
image=[img1_file, img2_file], # Übergeben Sie eine Liste von Datei-Objekten
prompt=prompt_combine, # Beschreiben Sie das gewünschte kombinierte Ergebnis
size="1024x1536", # Passen Sie die gewünschte Ausgabegröße an
response_format="b64_json",
n=1
)
# Verarbeiten Sie die Antwort
image_b64 = response.data[0].b64_json
output_path = os.path.join(output_dir, "cat_with_hat.jpeg")
process_b64_json(image_b64, output_path)
except FileNotFoundError:
print("Fehler: Eingabebilddatei(en) nicht gefunden.")
except Exception as e:
print(f"Fehler während der Bildkombination/Bearbeitung: {e}")
finally:
# WICHTIG: Dateien schließen
if img1_file: img1_file.close()
if img2_file: img2_file.close()
Bearbeiten mit einer Maske:
Geben Sie ein einzelnes Basis-image und eine mask-Datei (PNG mit Alphakanal) an. Der Prompt beschreibt das gewünschte endgültige Bild unter Berücksichtigung des maskierten Bereichs.
Schritt 1: Maske erhalten/generieren: Sie können eine manuell erstellen oder die API selbst verwenden.
# --- Snippet: Generieren einer S/W-Maske über die API (aus dem Kochbuch) ---
base_image_path = os.path.join(output_dir, "glorptak.png") # Gehen Sie davon aus, dass sie existiert
mask_prompt = "Generieren Sie eine Maske, die den gesamten Charakter im Bild abgrenzt, wobei Weiß für den Charakter und Schwarz für den Hintergrund verwendet wird. Geben Sie ein Bild in der gleichen Größe wie das Eingabebild zurück."
bw_mask_output_path = os.path.join(output_dir, "glorptak_mask_bw.png")
img_input_file = None
try:
img_input_file = open(base_image_path, "rb")
mask_gen_response = client.images.edit( # Ja, der Bearbeitungsendpunkt kann Masken generieren
model="gpt-image-1",
image=img_input_file,
prompt=mask_prompt,
size="1024x1024", # Passen Sie die Eingabegröße an
response_format="b64_json"
)
# Speichern Sie die generierte S/W-Maske
mask_b64 = mask_gen_response.data[0].b64_json
process_b64_json(mask_b64, bw_mask_output_path)
except Exception as e:
print(f"Fehler beim Generieren der Maske: {e}")
finally:
if img_input_file: img_input_file.close()
Schritt 2: S/W-Maske in Alpha-Maske konvertieren (aus dem Kochbuch): Die API erfordert, dass die Maske einen Alphakanal hat.
# --- Snippet: Erstellen eines Alphakanals für die Maske ---
bw_mask_path = os.path.join(output_dir, "glorptak_mask_bw.png") # Gehen Sie davon aus, dass sie existiert
alpha_mask_path = os.path.join(output_dir, "glorptak_mask_alpha.png")
try:
mask = Image.open(bw_mask_path).convert("L") # Laden als Graustufen
mask_rgba = mask.convert("RGBA") # Konvertieren in RGBA
mask_rgba.putalpha(mask) # Verwenden Sie die Graustufenintensität für Alpha
mask_rgba.save(alpha_mask_path, format="PNG") # Speichern als PNG
print(f"Alpha-Maske gespeichert unter {alpha_mask_path}")
except FileNotFoundError:
print(f"Fehler: S/W-Maske nicht gefunden unter {bw_mask_path}")
except Exception as e:
print(f"Fehler beim Erstellen der Alpha-Maske: {e}")
Schritt 3: Maskierte Bearbeitung durchführen: Verwenden Sie das Basisbild und die Alpha-Maske.
# --- Snippet: Bearbeiten mit Alpha-Maske ---
base_image_path = os.path.join(output_dir, "glorptak.png") # Gehen Sie davon aus, dass sie existiert
alpha_mask_path = os.path.join(output_dir, "glorptak_mask_alpha.png") # Gehen Sie davon aus, dass sie existiert
edit_prompt_masked = "Ein seltsamer Charakter auf einem farbenfrohen Galaxiehintergrund mit vielen Sternen und Planeten."
masked_edit_output_path = os.path.join(output_dir, "glorptak_masked_edit.jpeg")
img_input_file = None
mask_alpha_file = None
try:
img_input_file = open(base_image_path, "rb")
mask_alpha_file = open(alpha_mask_path, "rb") # Verwenden Sie die Maske mit Alpha
response = client.images.edit(
model="gpt-image-1",
image=img_input_file,
mask=mask_alpha_file, # Geben Sie die Alpha-Maskendatei an
prompt=edit_prompt_masked,
size="1024x1024",
response_format="b64_json",
n=1
)
# Verarbeiten Sie die Antwort
image_b64 = response.data[0].b64_json
process_b64_json(image_b64, masked_edit_output_path)
except FileNotFoundError:
print("Fehler: Basisbild- oder Alpha-Maskendatei nicht gefunden.")
except Exception as e:
print(f"Fehler während der maskierten Bearbeitung: {e}")
finally:
if img_input_file: img_input_file.close()
if mask_alpha_file: mask_alpha_file.close()
Erstellen von Bildvariationen (client.images.create_variation)
Generieren Sie Variationen eines vorhandenen Bildes. Im Kochbuchbeispiel nicht behandelt, aber über die API verfügbar.
base_image_for_variation_path = os.path.join(output_dir, "glorptak.png") # Gehen Sie davon aus, dass sie existiert
variation_output_path_template = os.path.join(output_dir, "glorptak_variation_{i}.png")
img_input_file = None
try:
img_input_file = open(base_image_for_variation_path, "rb")
response = client.images.create_variation(
model="gpt-image-1", # Geben Sie das Modell an, wenn es sich vom Standard (DALL-E 2) unterscheidet
image=img_input_file, # Basisbild-Datei-Objekt
n=2, # Anzahl der zu erstellenden Variationen
size="1024x1024", # Gewünschte Größe für Variationen
response_format="b64_json"
)
# Verarbeiten Sie mehrere Ergebnisse, wenn n > 1
for i, data_item in enumerate(response.data):
image_b64 = data_item.b64_json
output_path = variation_output_path_template.format(i=i+1)
process_b64_json(image_b64, output_path)
print(f"Generierte {len(response.data)} Variationen.")
except FileNotFoundError:
print(f"Fehler: Basisbild nicht gefunden unter {base_image_for_variation_path}")
except Exception as e:
print(f"Fehler beim Erstellen von Variationen: {e}")
finally:
if img_input_file: img_input_file.close()
Diese Snippets decken die Kernfunktionalitäten ab, die im Kochbuch und in der API-Dokumentation für gpt-image-1 demonstriert werden, wobei die offizielle openai-Bibliothek verwendet wird. Denken Sie daran, Fehler angemessen zu behandeln und Dateiresourcen (Schließen von Dateien) in Ihrer vollständigen Anwendung zu verwalten.
Passen Sie die gpt-image-1 API-Ausgabegröße, -Qualität und -Format an
Die gpt-image-1 API bietet mehrere Parameter, um die generierte Bildausgabe an Ihre spezifischen Bedürfnisse anzupassen, einschließlich Format, Qualität, Abmessungen und Hintergrundtransparenz.
Optimieren Sie generierte Bilder mit diesen gpt-image-1 API-Parametern:
size: Bildabmessungen. Beeinflusst Token-Kosten & Latenz.
- Optionen:
"1024x1024"(Quadratisch, Standard),"1024x1536"(Querformat),"1536x1024"(Hochformat),"auto".
quality: Rendering-Detail & Token-Kosten.
- Optionen:
"low","medium","high","auto"(Standard). ("hd"in den API-Dokumenten wird wahrscheinlich auf"high"abgebildet). Höhere Qualität verwendet deutlich mehr Tokens.
output_format: Dateityp für zurückgegebene b64_json-Daten.
- Optionen:
"png"(Standard, unterstützt Transparenz, verlustfrei),"jpeg"(verlustbehaftet, keine Transparenz),"webp"(modern, unterstützt Transparenz, gute Komprimierung).
output_compression (nur für jpeg/webp): Kompromiss zwischen Qualität und Größe (0=maximale Komprimierung, 100=minimale Komprimierung). Beispiel: output_compression=75.
Erstellen Sie ein Bild mit transparentem Hintergrund mit gpt-image-1
background: Setzen Sie auf "transparent" für Transparenz.
- Erfordert
output_format="png"oder"webp". - Funktioniert am besten mit
quality="medium"oder"high". - Die Erwähnung von "transparenter Hintergrund" im Prompt könnte dies ebenfalls aktivieren.
Beispiel: Generieren eines hochwertigen transparenten WebP-Bildes:
from openai import OpenAI
import base64, os
client = OpenAI()
output_dir = "generated_images"; os.makedirs(output_dir, exist_ok=True)
try:
result = client.images.generate(
model="gpt-image-1",
prompt="Vektor-Art-Symbol eines stilisierten Raketenschiffs, transparenter Hintergrund",
size="1024x1024",
quality="high", # Höhere Qualität für bessere Transparenz
output_format="webp", # WebP unterstützt Transparenz und gute Komprimierung
background="transparent", # Explizit Transparenz anfordern
response_format="b64_json",
n=1
)
# Decodieren und speichern
img_b64 = result.data[0].b64_json
img_bytes = base64.b64decode(img_b64)
output_path = os.path.join(output_dir, "rocket_icon.webp")
with open(output_path, "wb") as f: f.write(img_bytes)
print(f"Transparentes WebP-Bild gespeichert unter {output_path}")
except Exception as e: print(f"Fehler: {e}")
