So nutzt du die Stable Diffusion 3 API

Stability AI hat im Februar 2024 eine frühe Vorschau auf Stable Diffusion 3 angekündigt. Das KI-Modell ist noch in der Vorschauphase, aber im April 2024 gab das Team bekannt, dass Stable Diffusion 3 und Stable Diffusion 3 Turbo nach der Partnerschaft mit Fireworks AI, der schnellsten und zuverlässigsten API-Plattform am Markt, auf der Stability AI Developer Platform API verfügbar sein werden.

Beachte, dass Stable Diffusion 3 eine Reihe von Text-zu-Bild-Generierungsmodellen ist. Laut Stability AI ist das Modell „gleichwertig oder besser“ als andere Text-zu-Bild-Generatoren wie OpenAI’s DALL-E 3 und Midjourney v6 – insbesondere bei „Typografie und Prompt-Treue“.

In diesem Tutorial lernst du praxisnah, wie du mit der API startest, um eigene Bilder zu generieren.

Warum Stable Diffusion 3?

Stable Diffusion 3 bringt mehrere Neuerungen und Features mit, die es von seinen Vorgängern abheben und in der Text-zu-Bild-Generierung sehr wettbewerbsfähig machen – vor allem durch verbesserte Textdarstellung und genaueres Befolgen von Prompts.

Schauen wir uns die Fortschritte an:

Verbessertes Prompt-Following

• Kontextverständnis: Stable Diffusion 3 nutzt modernste Natural Language Processing (NLP), um Prompts besser zu verstehen und zu interpretieren. So entstehen passendere, kontextrelevante Ergebnisse.
• Prompt-Kohärenz: Im Vergleich zu früheren Versionen hält Stable Diffusion 3 die inhaltliche Linie deutlich besser und bleibt über den gesamten Dialog hinweg eng am Benutzerprompt.

Verbesserte Textgenerierung

• Feinabgestimmte Sprachmodelle: Stable Diffusion 3 setzt auf feinjustierte Sprachmodelle, die auf großen Datensätzen trainiert wurden. Dadurch versteht das Modell Grammatik, Syntax und Semantik besser und liefert natürlichere, stimmige Antworten.
• Weniger Streuung in den Antworten: Dank verbesserter Trainingsmethoden und Architektur erzeugt Stable Diffusion 3 konsistentere, qualitativ hochwertigere Outputs über verschiedene Prompts und Kontexte hinweg.

Fortgeschrittene Prompt-Erweiterung

• Mehrstufige Dialoge: Stable Diffusion 3 kann mehrstufige Unterhaltungen effektiver führen und behält Kontext und Kohärenz über mehrere Austauschschritte hinweg.
• Prompt-Expansion: Das Modell nutzt fortgeschrittene Techniken zur Prompterweiterung, um informativere, kontextrelevantere Antworten zu erzeugen und Dialoge mit umfassenden Antworten anzureichern.

Fein steuerbare Kontrollmechanismen

• Parametersteuerung: Stable Diffusion 3 bietet fein abgestimmte Kontrolle über Parameter wie Antwortlänge, Kreativitätsgrad und Themenrelevanz – für ein individuelles Nutzererlebnis.
• Bias-Reduktion: Das Modell enthält Mechanismen zur Minderung von Verzerrungen in der Textgenerierung und fördert so Fairness und Inklusivität.

Erste Schritte mit der Stable Diffusion 3 API

In diesem Abschnitt gehen wir Schritt für Schritt durch den Start mit der Stability API.

Schritt 1: Erstelle dein Konto. Du musst ein Konto anlegen, bevor du die API von Stability AI nutzen kannst. Du kannst dich mit Benutzername und Passwort registrieren, aber neue Nutzer erhalten 25 Gratis-Credits, wenn sie sich mit ihrem Google-Konto anmelden.

Schritt 2: Hole dir deinen API-Schlüssel. Nach der Kontoerstellung benötigst du einen API Key. Du findest ihn auf der Seite API Keys. In der Dokumentation heißt es: „Alle hier dokumentierten APIs verwenden denselben Authentifizierungsmechanismus: Die API wird über den Authorization-Header übergeben.“

Schritt 3: Credits aufladen. Du brauchst Credits, um Anfragen an die API zu stellen. Credits sind die Verbrauchseinheit pro API-Call – die Menge variiert je nach Modell und Modalität. Sind deine Credits aufgebraucht, kannst du im Billing-Dashboard neue kaufen: 1 USD pro 100 Credits.

In diesem Tutorial nutzen wir Google Colab und ComfyUI, um zu demonstrieren, wie du mit der Stable Diffusion 3 API Bilder erzeugst. Im nächsten Abschnitt zeigen wir die Schritte für beide Tools.

Stable Diffusion 3 API mit Google Colab verwenden

Um mit Google Colab zu starten, brauchst du ein Google-Konto – klicke auf den Link und folge der Anleitung.

Wenn du bereits ein Google-Konto hast, öffne ein neues Notebook und befolge die folgenden Schritte.

Hinweis: Der Code in diesem Beispiel stammt aus dem SD3_API-Tutorial von Stability AI.

Schritt 1: Anforderungen installieren.

from io import BytesIO
import IPython
import json
import os
from PIL import Image
import requests
import time
from google.colab import output

Schritt 2: Verbindung zur Stability API herstellen.

import getpass
# To get your API key, visit https://platform.stability.ai/account/keys
STABILITY_KEY = getpass.getpass('Enter your API Key')

Schritt 3. Funktionen definieren

def send_generation_request(
    host,
    params,
):
    headers = {
        "Accept": "image/*",
        "Authorization": f"Bearer {STABILITY_KEY}"
    }

    # Encode parameters
    files = {}
    image = params.pop("image", None)
    mask = params.pop("mask", None)
    if image is not None and image != '':
        files["image"] = open(image, 'rb')
    if mask is not None and mask != '':
        files["mask"] = open(mask, 'rb')
    if len(files)==0:
        files["none"] = ''

    # Send request
    print(f"Sending REST request to {host}...")
    response = requests.post(
        host,
        headers=headers,
        files=files,
        data=params
    )
    if not response.ok:
        raise Exception(f"HTTP {response.status_code}: {response.text}")

    return response

Schritt 4. Bilder generieren.

Laut Dokumentation gibt es derzeit einen Stable-Image-Dienst in Produktion:

• SD3: verbraucht 6,5 Credits
• SD3 Turbo: verbraucht 4 Credits

Lass uns beide testen.

In diesem Beispiel erstellen wir ein Bild eines Tukans in einem tropischen Tieflandgebiet.

# SD3

prompt = "This dreamlike digital art captures a vibrant, Toucan bird in a lowland tropic area" #@param {type:"string"}
negative_prompt = "" #@param {type:"string"}
aspect_ratio = "1:1" #@param ["21:9", "16:9", "3:2", "5:4", "1:1", "4:5", "2:3", "9:16", "9:21"]
seed = 0 #@param {type:"integer"}
output_format = "jpeg" #@param ["jpeg", "png"]

host = f"https://api.stability.ai/v2beta/stable-image/generate/sd3"

params = {
    "prompt" : prompt,
    "negative_prompt" : negative_prompt,
    "aspect_ratio" : aspect_ratio,
    "seed" : seed,
    "output_format" : output_format,
    "model" : "sd3",
    "mode" : "text-to-image"
}

response = send_generation_request(
    host,
    params
)

# Decode response
output_image = response.content
finish_reason = response.headers.get("finish-reason")
seed = response.headers.get("seed")

# Check for NSFW classification
if finish_reason == 'CONTENT_FILTERED':
    raise Warning("Generation failed NSFW classifier")

# Save and display result
generated = f"generated_{seed}.{output_format}"
with open(generated, "wb") as f:
    f.write(output_image)
print(f"Saved image {generated}")

output.no_vertical_scroll()
print("Result image:")
IPython.display.display(Image.open(generated))

Das hat das Modell erzeugt:

Bild vom Autor mit Stable Diffusion 3 erstellt

Jetzt erstellen wir mit SD3 Turbo ein Bild von einem Auto aus Früchten:

#SD3 Turbo

prompt = "A car made out of fruits." #@param {type:"string"}
aspect_ratio = "1:1" #@param ["21:9", "16:9", "3:2", "5:4", "1:1", "4:5", "2:3", "9:16", "9:21"]
seed = 0 #@param {type:"integer"}
output_format = "jpeg" #@param ["jpeg", "png"]

host = f"https://api.stability.ai/v2beta/stable-image/generate/sd3"

params = {
    "prompt" : prompt,
    "aspect_ratio" : aspect_ratio,
    "seed" : seed,
    "output_format" : output_format,
    "model" : "sd3-turbo"
}

response = send_generation_request(
    host,
    params
)

# Decode response
output_image = response.content
finish_reason = response.headers.get("finish-reason")
seed = response.headers.get("seed")

# Check for NSFW classification
if finish_reason == 'CONTENT_FILTERED':
    raise Warning("Generation failed NSFW classifier")

# Save and display result
generated = f"generated_{seed}.{output_format}"
with open(generated, "wb") as f:
    f.write(output_image)
print(f"Saved image {generated}")

output.no_vertical_scroll()
print("Result image:")
IPython.display.display(Image.open(generated))

Die Ausführung des Codes ergab folgendes Bild:

Bild vom Autor mit Stable Diffusion 3 Turbo erstellt

Die API mit ComfyUI nutzen

ComfyUI ist eine robuste und flexible grafische Benutzeroberfläche (GUI) für Stable Diffusion. Die graphbasierte Oberfläche im Flowchart-Stil ermöglicht es, anspruchsvolle Stable-Diffusion-Workflows zu erstellen und auszuführen.

Systemanforderungen:

• Graphics Processing Unit (GPU): Eine geeignete NVIDIA-GPU mit mindestens 8 GB VRAM, z. B. RTX 3060 Ti oder besser.
• Central Processing Unit (CPU): Ein aktueller Prozessor, z. B. Intel Xeon E5, i5, Ryzen 5 oder höher.
• Random Access Memory (RAM): 16 GB oder mehr.
• Betriebssystem: Windows 10/11 oder Linux.
• Ausreichend Speicherplatz für Modelle und generierte Bilder.

Schritt 1: ComfyUI installieren

Am einfachsten installierst du ComfyUI unter Windows mit dem Standalone-Installer von der Releases-Seite. Dieser bringt wichtige Abhängigkeiten wie PyTorch und Hugging Face Transformers bereits mit – du musst sie nicht separat installieren.

So erhältst du ein Komplettpaket und kannst ComfyUI unter Windows schnell und ohne aufwendige Einrichtung starten.

Einfach herunterladen, entpacken, Modelle hinzufügen und loslegen!

Schritt 1.1: Lade die Standalone-Version von ComfyUI aus diesem GitHub-Repository herunter – der Download startet beim Klicken automatisch.

Schritt 1.2: Nachdem du die aktuelle comfyui-windows.zip-Datei geladen hast, entpacke sie mit einem Tool wie 7-Zip oder WinRAR.

Schritt 1.3: Für die Nutzung von ComfyUI brauchst du ein Checkpoint-Modell. Du kannst ein Checkpoint-Modell von Stable Diffusion oder Hugging Face herunterladen. Lege das Modell in folgenden Ordner:

ComfyUI_windows_portable\ComfyUI\models\checkpoints

Schritt 1.4: Starte nun einfach run_nvidia_gpu.bat (empfohlen) oder run_cpu.bat. Dadurch sollte ComfyUI automatisch im Browser starten.

In der Konsole erscheint eine URL http://127.0.0.1:8188/, die du im Browser öffnen kannst.

Schritt 2: ComfyUI Manager installieren

Öffne im Datei-Explorer das gerade installierte Verzeichnis. Unter Windows heißt es meist „ComfyUI_windows_portable“. Navigiere dann zu ComfyUI und weiter zu custom_nodes. Gib an dieser Stelle cmd in die Adresszeile ein und drücke Enter.

Es öffnet sich ein Eingabeaufforderungsfenster. Führe dort folgenden Befehl aus:

git clone https://github.com/ltdrdata/ComfyUI-Manager

Nach Abschluss startest du ComfyUI neu. Im schwebenden Panel sollte nun der neue Button „Manager“ erscheinen.

Schritt 3: Stability AI API Node installieren

Klicke auf „Manage“ und wechsle zu „Install Custom Nodes“. Suche dort nach „stability API“.

Finde den Eintrag "Stability API nodes for ComfyUI" und klicke rechts auf Install, um die Installation zu starten. Danach erscheint ein „Restart“-Button. Klicke auf „Restart“, um ComfyUI neu zu starten.

Schritt 4: Systemweiten API-Key festlegen

Dieser Schritt ist optional, aber empfehlenswert. Du kannst für jeden Node innerhalb des Stability-AI-Custom-Nodes einen Stability-AI-API-Key setzen. So musst du den Key nicht in jedem Workflow erneut eintragen und minimierst das Risiko, ihn versehentlich zu teilen, wenn du dein Workflow-JSON weitergibst.

Gehe dazu in das Custom-Node-Verzeichnis:

ComfyUI_windows_portable > ComfyUI > custom_nodes > ComfyUI-SAI_API. 

Erstelle eine neue Datei namens sai_platform_key.txt. Füge deinen API Key ein, speichere die Datei und starte ComfyUI neu.

Schritt 5: Workflow laden und ausführen

Installiere den Stable Diffusion 3 Text-zu-Bild-Workflow und ziehe ihn in ComfyUI.

Jetzt kannst du loslegen!

Troubleshooting und Tipps

Wie bei jedem Tool kann es unterwegs zu Problemen kommen. Hier sind die häufigsten Herausforderungen und passende Schritte zur Fehlerbehebung – sowohl für API-Themen als auch für die Einrichtung.

API-Key und Authentifizierung

Herausforderung: Beim Zugriff auf die API können Authentifizierungsfehler durch einen falschen API-Key oder fehlerhafte Zugangsdaten auftreten.

Fehlerbehebung: Prüfe den API-Key und kopiere ihn exakt. Achte darauf, dass keine Leerzeichen oder Sonderzeichen eingefügt wurden. Verifiziere, dass der API-Key vom Stable-Diffusion-3-Server korrekt akzeptiert wird.

Credit-Management

Herausforderung: Probleme mit Credits, etwa unzureichendes Guthaben oder Abrechnungsfehler.

Fehlerbehebung: Prüfe dein Credit-Guthaben im Stable-Diffusion-3-Dashboard. Verifiziere deine Rechnungsdaten und kläre Abweichungen oder Fehler mit dem Support.

Konnektivität und Netzwerk

Herausforderung: Netzwerkprobleme oder Unterbrechungen verhindern den API-Zugriff.

Fehlerbehebung: Stelle eine stabile Internetverbindung sicher. Teste die API von einem anderen Netzwerk oder Gerät, um das Problem einzugrenzen. Kontaktiere deinen Internetanbieter, falls die Störungen anhalten.

Kompatibilität und Abhängigkeiten

Herausforderung: Inkompatible Versionen oder Abhängigkeitsfehler bei Installation oder Nutzung von Tools und Bibliotheken.

Fehlerbehebung: Prüfe die Kompatibilitätsanforderungen der Stable Diffusion 3 API und nutze kompatible Versionen der Tools und Libraries. Aktualisiere oder installiere problematische Abhängigkeiten neu. Sieh für Hinweise in die Dokumentation und Community-Foren.

Performance und Antwortzeiten

Herausforderung: Langsame Antworten oder Performance-Probleme, besonders zu Stoßzeiten.

Fehlerbehebung: Überwache die API-Performance und Antwortzeiten, um Muster zu erkennen. Erwäge ein Upgrade auf einen höherwertigen Tarif für bessere Performance und Priorisierung. Kontaktiere den Support, wenn die Latenzen dauerhaft hoch sind.

Dokumentation und Support

Herausforderung: Unklarheiten in der API-Dokumentation oder Bedarf an Unterstützung bei spezifischen Problemen.

Fehlerbehebung: Nutze die Stable Diffusion 3 Dokumentation für Nutzung, Troubleshooting und Best Practices. Bei offenen Fragen oder Problemen wende dich an den Support oder die Community-Foren.

Fazit

Stable Diffusion 3 ist eine Reihe von Text-zu-Bild-Generierungsmodellen. Dieser Artikel hat dir gezeigt, wie du die API mit Google Colab und ComfyUI praktisch einsetzt. Jetzt kannst du eigene Bilder erstellen – setze das Gelernte am besten gleich um, damit es sitzt.

Danke fürs Lesen!

Weiterlernen

• Stable Diffusion Web UI: Der umfassende Einsteiger-Guide
• Fine-Tuning von Stable Diffusion XL mit DreamBooth und LoRA
• So führst du Stable Diffusion aus
• Fotorealistische Bilder mit KI und Diffusers in Python erzeugen