OpenJourney auf centron A100-GPU-Servern: KI-Bilder mit Stable Diffusion erzeugen

OpenJourney ist ein Bildgenerierungsmodell auf Basis von Stable Diffusion, das unter der OpenRAIL-Lizenz veröffentlicht wurde. Es liefert Ergebnisse, die Midjourney ähneln, und ermöglicht dir, mithilfe künstlicher Intelligenz realistische und hochwertige Kunstwerke zu erzeugen. In dieser Anleitung lernst du, wie du mit OpenJourney auf einer centron Cloud-GPU-Instanz KI-Bilder generierst. Dafür richtest du Jupyter Notebook sowie die nötigen Pakete ein, um OpenJourney auf einem centron Cloud-GPU-Server auszuführen.

Voraussetzungen

Bevor du beginnst:

• Stelle bei centron einen Ubuntu 22.04 A100 oder RTX 6000 Ada Cloud GPU Server bereit, der mindestens Folgendes bietet:
  • 30 GB Arbeitsspeicher
  • 350 GB NVMe-Speicher
• Verbinde dich per SSH mit dem Server und lege einen Nicht-Root-Benutzer mit sudo-Rechten an.
• Aktualisiere den Server.

Jupyter Notebook installieren

Jupyter Notebook ist eine quelloffene, browserbasierte Entwicklungsumgebung, mit der du Dokumente mit ausführbarem Code, Visualisierungen und Formeln erstellen und teilen kannst. Damit kannst du die Rechenleistung deiner centron Cloud-GPU-Instanz direkt im Webbrowser nutzen, um besonders ressourcenintensive Modelle auszuführen. Installiere Jupyter Notebook wie folgt.

Installiere den Paketmanager python3-pip.

$ sudo apt install python3-pip

Installiere anschließend JupyterLab über pip.

$ sudo pip install -U jupyterlab

Um die JupyterLab-Oberfläche abzusichern, erzeuge mit dem folgenden Befehl einen Passwort-Hash.

$ python3 -c "from jupyter_server.auth import passwd; print(passwd('STRONG_PASSWORD'))"

Kopiere den erzeugten Passwort-Hash.

Erstelle eine neue JupyterLab-Konfigurationsdatei.

$ jupyter lab --generate-config

Bearbeite die Konfigurationsdatei.

$ nano ~/.jupyter/jupyter_lab_config.py

Suche die folgenden Einträge und setze sie wie hier gezeigt.

c.ServerApp.password = 'PASTE_PASSWORD_HASH'
c.ServerApp.allow_remote_access = True

Speichere die Datei und schließe den Editor.

Erlaube Port 8888 in der Firewall, damit die Weboberfläche erreichbar ist.

$ sudo ufw allow 8888

Lege einen Ordner an, in dem du die von OpenJourney erzeugten Bilder speicherst.

$ mkdir ~/Generated-Images

Starte den JupyterLab-Server im Hintergrund.

$ jupyter lab --ip 0.0.0.0 &

Öffne danach die Jupyter-Weboberfläche im Browser und melde dich mit dem zuvor gesetzten Passwort an.

Umgebung einrichten

Als nächsten Schritt richtest du die Umgebung für die Bildgenerierung ein. Installiere PyTorch, die erforderlichen Hugging-Face-Bibliotheken und matplotlib, um Bilder direkt im Jupyter Notebook zu erzeugen und anzuzeigen.

Rufe im Browser die Jupyter-Weboberfläche auf.

Gehe im Launcher zum Bereich Notebook und wähle Python 3 (ipykernel), um ein neues Notebook zu erstellen.

Wenn du das Notebook umbenennen möchtest, klicke mit der rechten Maustaste auf den Dateinamen und wähle Rename.

Führe in einer Code-Zelle die folgenden Befehle aus, um torch und torchvision zu installieren.

!pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118

Sobald torch installiert ist, ergänze diese Befehle, um die Hugging-Face-Pakete zu installieren.

!pip install transformers
!pip install diffusers
!pip install accelerate

Mit diesen Befehlen installierst du folgende Werkzeuge:

• Transformers: Eine Sammlung vortrainierter Modelle für Aufgaben wie NLP, NER, Übersetzung und Sentiment-Analyse.
• Diffusers: Vortrainierte Diffusions-Pipelines und Bausteine zum Erstellen und Trainieren von Diffusionsmodellen.
• Accelerate: Unterstützt PyTorch bei verteilten Setups und nutzt Beschleuniger wie GPUs und TPUs, um Effizienz und Geschwindigkeit zu erhöhen.

Installiere matplotlib.

!pip install matplotlib

Damit steht dir matplotlib zur Verfügung, um die generierten Bilder im Jupyter Notebook anzuzeigen.

Installiere ipywidgets.

!pip install ipywidgets

Bilder mit OpenJourney erzeugen

Um mit OpenJourney Bilder zu erstellen, importierst du die notwendigen Module, startest das Modell und aktivierst die GPU-Beschleunigung über CUDA.

Importiere die benötigten Module.

from diffusers import StableDiffusionPipeline
import torch
import matplotlib.pyplot as plt

Die Klasse StableDiffusionPipeline stellt die OpenJourney-Schnittstelle für Text-zu-Bild bereit. Torch liefert Tensorfunktionen samt GPU-Acceleration, und matplotlib dient dazu, die Resultate anzuzeigen.

Initialisiere das Modell.

model_id = "prompthero/openjourney"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
pipe = pipe.to("cuda")

Mit from_pretrained() wird die Pipeline geladen und automatisch so vorbereitet, dass sie Text in Bilder umwandeln kann.

Die Parameter für from_pretrained() sind:

• model_id: Gibt an, welche Pipeline geladen wird. Hier wird „prompthero/openjourney“ verwendet. Alternativ kannst du auf einen lokalen Ordner mit Gewichten oder auf eine Checkpoint-Datei verweisen.
• torch_dtype: Legt den Datentyp der Tensoren für die Berechnung fest. float16 wird genutzt, damit die Berechnungen in 16-Bit stattfinden und weniger Speicher belegen. Du kannst die automatische Wahl mit torch_dtype = "auto" zulassen. Standardmäßig ist torch_dtype = "full-precision" gesetzt.

Erzeuge nun ein Bild aus einem Text-Prompt.

prompt = "YOUR_PROMPT_HERE, mdjrny-v4 style"
images = pipe(prompt).images

Damit wird dein Prompt an die Pipeline übergeben und das Ergebnis gespeichert. Jedes Ausführen der Zelle erzeugt ein neues Bild. Das Suffix mdjrny-v4 style lenkt das Modell in eine Midjourney-ähnliche Richtung. Du kannst die Outputs verbessern, indem du deinem Prompt zusätzliche Details wie Objektive, Umgebung, Lichtstimmung und ähnliche Angaben hinzufügst.

Zeige das erzeugte Bild an.

plt.imshow(images[0])

Wird ein generiertes Bild als Not Safe For Work (NSFW) eingestuft, kann das Modell einen Fehler melden und ein leeres Bild liefern. Passe deinen Prompt an oder nutze einen anderen Seed, um bessere Ergebnisse zu erhalten.

Wenn du die Achsen im Bild ausblenden möchtest, führe Folgendes aus.

plt.imshow(images[0])
plt.axis('off')
plt.show()

Erzeugte Bilder speichern

Lege das zuvor erstellte Verzeichnis als Speicherziel für deine Bilder fest.

save_directory = "‾/Generated-Images"

Der Zielordner muss bereits vorhanden sein. Stelle sicher, dass du ihn in deinem Home-Verzeichnis angelegt hast.

Speichere die Bilder mit einer for-Schleife.

for i, image in enumerate(images):
    image.save(f"{save_directory}/image_{i}.png")

So wird jedes Bild im Pfad save_directory abgelegt, mit Dateinamen wie image_{i}.png, wobei {i} den Index im Ergebnis-Array darstellt.

Prüfe im Terminal, ob die Bilder im Ordner liegen.

$ ls ~/Generates-Images

Um die generierten Bilder auf deinen Rechner zu übertragen, nutze ein sicheres Transferverfahren wie SFTP, FTP oder RSync.

Mehrere Bilder mit OpenJourney erstellen

Standardmäßig erzeugt die Pipeline pro Prompt nur ein Bild. Wenn du mehrere unterschiedliche Bilder aus demselben Prompt möchtest, legst du die Anzahl der Ausgaben fest.

Erweitere den Prompt-Code, um die gewünschte Bildanzahl zu definieren.

num_images = 5
prompt = ["YOUR_PROMPT_HERE, mdjrny-v4 style"] * num_images

Damit wird num_images gesetzt und dein Prompt als Liste in genau dieser Länge vervielfacht.

Erzeuge mehrere Bilder.

image_list = pipe(prompt).images

Die Variable image_list enthält anschließend alle erzeugten Bilder zur weiteren Nutzung.

Gib die Bilder mit einer aktiven Schleife aus.

for image in image_list:
    plt.imshow(image)
    plt.show()

Die Schleife durchläuft image_list und zeigt jedes Bild über plt.imshow(image) an. Du kannst auch die Speicherschleife wiederverwenden, um alle Ergebnisse in dein Exportverzeichnis zu sichern.

Deterministische Ausgabe mit OpenJourney

Du kannst einen festen Zufalls-Seed setzen und ihn an den Generator der Pipeline übergeben, um reproduzierbare Ergebnisse zu erhalten. Wenn du denselben Seed wieder nutzt, erstellt das Modell jedes Mal identische Bildausgaben.

Erzeuge einen neuen Generator.

prompt = "YOUR_PROMPT_HERE, mdjrny-v4 style"
generator = torch.Generator("cuda").manual_seed(2048)
images = pipe(prompt, guidance_scale=7.5, generator=generator).images

Dieser Code erstellt einen Generator und übergibt ihn an die Pipeline. Der konstante Wert in manual_seed() fixiert die Zufälligkeit, sodass das Modell bei jeder Ausführung denselben Output liefert. Du kannst dafür jede beliebige ganze Zahl verwenden. Ohne gesetzten Seed erzeugt der Generator bei jedem Lauf einen neuen Zufallswert, wodurch unterschiedliche Bilder entstehen.

Wichtige Begriffe

Die Bildpipeline unterstützt viele Parameter, verpflichtend sind jedoch nur pipe und prompt. Im Folgenden findest du optionale Einstellungen, die du beim Generieren nutzen kannst.

• pipe: Die Text-zu-Bild-Pipelinefunktion. Sie nimmt den Prompt sowie zusätzliche Konfigurationswerte entgegen.
• prompt: Der Texteingang, der die Bildgenerierung steuert. Ersetze „YOUR_PROMPT_HERE, mdjrny-v4 style“ durch deinen eigenen Prompt. Wenn du das mdjrny-v4 style-Suffix entfernst, werden eher generische Bilder erzeugt, die weniger einem Midjourney-Look entsprechen.
• generator: Eine Instanz von torch.Generator zur Kontrolle der Zufallszahlen. Ein Seed wie 2048 sorgt für stabile und deterministische Resultate, wenn du ihn wiederverwendest.
• guidance_scale: Bestimmt, wie stark die Pipeline deinem Prompt folgt, und beeinflusst die Bildqualität. Diese classifier-free guidance priorisiert Prompt-Treue, was Qualität und Vielfalt beeinflusst. Werte zwischen etwa 7 und 8,5 funktionieren meist gut; Standard ist 7,5.
• images: Eine Liste aller erzeugten Bildobjekte.
• num_inference_steps: Die Anzahl der Inferenz-Schritte während der Generierung. Standard sind 50 und damit ein Kompromiss aus Geschwindigkeit und Qualität. Weniger Schritte liefern schneller Ergebnisse, mehr Schritte können die Qualität steigern, benötigen aber mehr Zeit.

Fazit

In diesem Artikel hast du mithilfe des OpenJourney-Modells Bilder erstellt und einen centron A100 Cloud-GPU-Server genutzt, um die Generierung zu beschleunigen und zu verbessern. Außerdem hast du eine Jupyter-Notebook-Umgebung aufgebaut und die benötigten Bibliotheken installiert, um Bilder zu erzeugen, anzuzeigen und zu speichern.