Maximale Performance bei minimalen Kosten. Jetzt Server in Sekunden starten!
    Vijona

    KI-Bilder mit OpenJourney auf einem centron Cloud-GPU-Server erstellen

    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.

    Copy Code 
    

    $ sudo apt install python3-pip

    Installiere anschließend JupyterLab über pip.

    Copy Code 
    

    $ sudo pip install -U jupyterlab

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

    Copy Code 
    

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

    Kopiere den erzeugten Passwort-Hash.

    Erstelle eine neue JupyterLab-Konfigurationsdatei.

    Copy Code 
    

    $ jupyter lab --generate-config

    Bearbeite die Konfigurationsdatei.

    Copy Code 
    

    $ nano ~/.jupyter/jupyter_lab_config.py

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

    Copy Code 
    

    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.

    Copy Code 
    

    $ sudo ufw allow 8888

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

    Copy Code 
    

    $ mkdir ~/Generated-Images

    Starte den JupyterLab-Server im Hintergrund.

    Copy Code 
    

    $ 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.

    Copy Code 
    

    !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.

    Copy Code 
    

    !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.

    Copy Code 
    

    !pip install matplotlib

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

    Installiere ipywidgets.

    Copy Code 
    

    !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.

    Copy Code 
    

    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.

    Copy Code 
    

    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.

    Copy Code 
    

    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.

    Copy Code 
    

    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.

    Copy Code 
    

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

    Erzeugte Bilder speichern

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

    Copy Code 
    

    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.

    Copy Code 
    

    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.

    Copy Code 
    

    $ 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.

    Copy Code 
    

    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.

    Copy Code 
    

    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.

    Copy Code 
    

    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.

    Copy Code 
    

    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.

    Quelle: vultr.com

    Jetzt 200€ Guthaben sichern

    Registrieren Sie sich jetzt in unserer ccloud³ und erhalten Sie 200€ Startguthaben für Ihr Projekt.

    Jetzt loslegen

    Das könnte Sie auch interessieren: