NVIDIA PiD: Bild-Decoder zeichnet KI-Bilder direkt in vierfacher Auflösung

NVIDIAs PiD ersetzt bei Bildgeneratoren wie FLUX oder SDXL den VAE-Decoder und zeichnet das fertige Bild in nur vier Schritten direkt mit vierfacher Breite und Höhe. Ein Community-Trick macht daraus einen Hochskalierer für beliebige Bilder. Die Gewichte liegen frei auf Hugging Face.

Tools Selbst ausprobieren 6. Nov. 2026 6 Min. Lesezeit Quelle: Reddit r/StableDiffusion
Symbolbild, KI-generiert

Worum es geht

NVIDIA hat mit PiD (Pixel Diffusion Decoder) ein neues Bauteil für KI-Bildgeneratoren veröffentlicht. Die Gewichte liegen frei herunterladbar auf Hugging Face unter nvidia/PiD. Das zugehörige Forschungspapier „PiD: Fast and High-Resolution Latent Decoding with Pixel Diffusion“ wurde am 22. Mai 2026 eingereicht (arXiv 2605.23902). Anfang November rückte ein Beitrag im Reddit-Forum r/StableDiffusion PiD in den Fokus. Der Autor zeigt dort einen Trick, mit dem sich PiD nicht nur für bestimmte Bildmodelle, sondern als Hochskalierer für jedes beliebige Bild nutzen lässt.

Die Grundidee: Statt das von einem Bildmodell erzeugte Zwischenergebnis nur zurück in ein Bild gleicher Größe zu übersetzen, zeichnet PiD das Bild direkt mit vierfacher Breite und Höhe, in wenigen Schritten und mit feinen Details.

Das Problem mit dem klassischen Decoder

Moderne Bildgeneratoren wie FLUX, Stable Diffusion oder Qwen-Image arbeiten nicht direkt mit Pixeln. Sie rechnen in einem Latent-Raum, einer stark komprimierten internen Darstellung des Bildes, ähnlich einer sehr kompakten Skizze. Am Ende muss diese Skizze wieder in echte Pixel übersetzt werden. Das übernimmt meist der VAE-Decoder (VAE steht für Variational Autoencoder, ein Encoder-Decoder-Paar, das Bilder komprimiert und wiederherstellt).

Dieser Decoder ist laut Paper auf Rekonstruktion getrimmt. Er soll möglichst genau umkehren, was der Encoder komprimiert hat, und keine zusätzlichen Details erfinden. Außerdem wird er bei Megapixel-Auflösungen teuer. Wer große Bilder will, hängt deshalb bisher meist einen zweiten Schritt an: Das Bild wird in niedriger Auflösung decodiert und dann von einem separaten Super-Resolution-Modell (einem KI-Hochskalierer) vergrößert. Das kostet Zeit, und Fehler oder fehlende Details aus dem ersten Schritt erbt der zweite.

Wie PiD funktioniert

PiD fasst beide Schritte zu einem zusammen. Das Decodieren wird als bedingte Pixel-Diffusion behandelt: Ein Diffusionsmodell, das direkt im hochaufgelösten Pixelraum arbeitet, erzeugt das Zielbild aus Rauschen und nutzt dabei das Latent als Vorlage. Das Latent liefert den groben Aufbau und den Inhalt des Bildes. Ein vortrainiertes Pixel-Modell, laut dem Überblick von alphaXiv ein Text-zu-Bild-Prior im Stil von PixelDiT, steuert das feine Aussehen bei, also Haut, Haare, Blätter und Texturen.

Zwei technische Kniffe machen das schnell und robust:

  • Sigma-bewusster Adapter: Ein kleines Zusatzmodul speist das Latent ins Pixelmodell ein. Im Training sieht PiD Latents mit unterschiedlich viel Rauschen und lernt, wie sehr es ihnen trauen kann. Ein „Gate“ (eine Art Regler) senkt den Einfluss des Latents, je verrauschter es ist. Dadurch kann der eigentliche Bildgenerator früher aufhören: Er übergibt ein noch nicht ganz fertiges Latent, und PiD macht daraus das Endbild.
  • DMD2-Destillation: Mit dieser Technik wird ein großes, langsames Modell in eine schnellere „Schüler“-Version übertragen. So braucht der Decoder nur noch vier Schritte, und die sonst übliche Classifier-free Guidance (eine Methode, die das Bild stärker an die Vorgabe bindet und normalerweise doppelte Rechenarbeit kostet) ist gleich eingebaut.

Für das frühe Aufhören gibt es laut Paper einen optimalen Zeitpunkt. Bei FLUX.1 [dev] mit 28 Entrauschungsschritten lieferte ein Stopp drei bis fünf Schritte vor dem Ende die beste Bildqualität. Wer zu früh stoppt, bekommt einen noch unklaren Bildinhalt. Wer alle Schritte durchläuft, verliert Zeit und lässt PiD weniger Spielraum für Details.

Zahlen aus dem Paper

NVIDIA gibt folgende Messwerte an:

Messung Wert
512×512-Latent → 2048×2048 Pixel auf RTX 5090 unter 1 Sekunde, 13 GB Speicherspitze
Dasselbe auf einer GB200-GPU ca. 210 ms
PiD (FLUX.1-Stopp bei Schritt 24/28), 2048×2048, GB200 211,2 ms
VAE-Decoder + SeedVR2-3B-Hochskalierer, gleiche Aufgabe 1237,5 ms
NIQE-Qualitätswert auf FLUX.1 (niedriger = besser) PiD 3,50 vs. 4,04 bester Vergleich

Das entspricht etwa einer 5,9-fach geringeren Decoder-Latenz. Der alphaXiv-Überblick weist darauf hin, dass dies nur die Decodierzeit ist und nicht die gesamte Bildgenerierung. Bei der Qualität liegt PiD in mehreren, aber nicht in allen Messgrößen vorn. Die Tests wurden mit generierten Latents gemacht, nicht mit der Rekonstruktion beliebiger echter Fotos.

In einer Ablationsstudie (Teile des Systems werden testweise entfernt) zeigte sich: Ohne den vortrainierten Pixel-Prior bricht die Qualität stark ein, der NIQE steigt von 5,43 auf 7,79. Ohne das Gate fällt der Effekt kleiner aus (NIQE 5,84), bei einzelnen Messgrößen ist die Variante ohne Gate sogar minimal besser. Das Gate hilft also, erklärt aber laut alphaXiv nicht allein den Gesamtgewinn.

Der Community-Trick: PiD für jedes Bild

Offiziell gibt es PiD-Decoder nur für bestimmte Latent-Räume: FLUX.1, FLUX.2, Qwen-Image (erste Version), SD3 und SDXL sowie für die Bild-Encoder DINOv2 und SigLIP. Diese werden in neueren sogenannten RAE-Modellen als semantische Latents verwendet. Ein Modell mit einem anderen VAE hat also keinen passenden PiD-Decoder.

Der Reddit-Autor umgeht das so: Ein beliebiges Bild, egal ob Render aus einem anderen Modell, Foto oder Videoframe, wird zuerst mit dem FLUX.2-VAE codiert. Das so entstandene Latent geht an PiDs FLUX.2-Decoder, der in vier Schritten ein Bild mit vierfacher Kantenlänge zeichnet, optional gelenkt durch eine Bildbeschreibung. Damit wird PiD zum universellen Hochskalierer. Der Autor stellt fertige Workflows für ComfyUI (eine verbreitete knotenbasierte Oberfläche für Bild-KI) lokal und in der ComfyUI-Cloud bereit.

Wichtig dabei: PiD ist kein klassischer Schärfer. Es poliert nicht die vorhandenen Pixel, sondern zeichnet ein neues, größeres Bild, das zum Original passt. Das sieht deutlich detailreicher aus als eine einfache bikubische Vergrößerung, bedeutet aber auch, dass Details hinzuerfunden werden.

Was du zum Ausprobieren brauchst

Die Gewichte gibt es auf Hugging Face (nvidia/PiD). Am einfachsten ist der Einstieg über ComfyUI mit dem Community-Workflow. Als Richtwert nennt das Paper 13 GB Grafikspeicher in der Spitze für eine 2048×2048-Ausgabe auf einer RTX 5090. Eine NVIDIA-Karte mit 16 GB VRAM sollte daher für diese Größe reichen. Mit 12 GB oder weniger wird es eng, belastbare Angaben dafür gibt es aber nicht. Für den Hochskalier-Trick brauchst du zusätzlich den FLUX.2-VAE. Plane genug Festplattenplatz für die Decoder-Dateien und den VAE ein, die genauen Größen nennen die Quellen nicht. Ob PiD auf Macs mit Apple Silicon oder nur auf der CPU brauchbar läuft, ist nicht dokumentiert. Wer keine passende Grafikkarte hat, kann den Workflow in der ComfyUI-Cloud nutzen.

Einordnung

PiD greift ein echtes Nadelöhr heutiger Bildgeneratoren an: den letzten Schritt vom Latent zum Pixelbild. Dass NVIDIA Decodieren und Hochskalieren in einem einzigen, schnellen Modell vereint und die Gewichte freigibt, ist für alle interessant, die lokal mit FLUX, SDXL oder Qwen-Image arbeiten. Große Bilder werden so schneller und ohne einen zweiten Hochskalierer möglich. Der Community-Trick über den FLUX.2-VAE erweitert den Nutzen auf beliebige Bilder.

Die Grenzen sollte man kennen. PiD erzeugt Details generativ. Die Ergebnisse wirken schärfer, sind aber keine echte Wiederherstellung verlorener Informationen, und Schrift im Bild wird ausdrücklich nicht garantiert korrekt wiedergegeben. Für Fotos, bei denen es auf Genauigkeit ankommt, etwa Dokumente oder Beweisbilder, ist das ungeeignet. Die Geschwindigkeits- und Qualitätswerte stammen von NVIDIA selbst und beziehen sich auf generierte Bilder. Unabhängige Vergleiche mit etablierten Hochskalierern stehen noch aus, ebenso Tests, wie gut der FLUX.2-VAE-Umweg bei echten Fotos funktioniert.

Quellen

#bildgenerierung#upscaling#nvidia#comfyui#flux
Originalquelle lesen

Selbst ausprobieren: NVIDIA PiD (Pixel Diffusion Decoder)

Schritt für Schritt erklärt, auch ohne Vorkenntnisse – auf deinem Rechner oder kostenlos im Browser.

Was kann ich damit machen?

PiD ist kein eigenständiger Bildgenerator, sondern ein Decoder. Er ersetzt bei Modellen wie FLUX.1, FLUX.2, SD3, SDXL oder Qwen-Image (erste Version) den letzten Schritt, in dem das interne Latent zum fertigen Bild wird. Dabei zeichnet er das Bild direkt mit vierfacher Breite und Höhe, laut Paper sogar bis achtfach, in nur vier Schritten. Mit dem Community-Trick, ein beliebiges Bild erst mit dem FLUX.2-VAE zu codieren, wird PiD zum Hochskalierer für jedes Foto, jeden Render und jeden Videoframe. Die Ergebnisse zeigen deutlich mehr Feindetail bei Haut, Haaren, Laub und Texturen als eine einfache Vergrößerung. NVIDIA gibt an, dass PiD rund sechsmal schneller ist als die Kombination aus VAE und dem Hochskalierer SeedVR2-3B, bei besserer Bildqualität. Die Grenze: PiD erfindet passende Details hinzu, statt verlorene Informationen exakt zurückzuholen. Schrift, Gesichter von echten Personen oder Dokumente können dadurch verfälscht werden.

Für wen lohnt es sich?

Lohnt sich für alle, die lokal mit ComfyUI und Modellen wie FLUX, SDXL oder Qwen-Image Bilder erzeugen und große, detailreiche Ausgaben wollen, sowie für Hobby-Fotografen und Gestalter, die kleine Bilder ansprechend vergrößern möchten. Weniger geeignet ist es, wenn das vergrößerte Bild exakt dem Original entsprechen muss, etwa bei Dokumenten, Screenshots mit Text oder Beweisfotos. Ohne NVIDIA-Grafikkarte mit genügend Speicher bleibt nur die Cloud-Variante.

Ideen: Was du damit anstellen kannst

Eigene KI-Bilder in Postergröße

Erzeuge ein Motiv mit FLUX oder SDXL und lass PiD statt des normalen VAE decodieren. Du bekommst direkt ein Bild mit vierfacher Kantenlänge und feinen Details, das sich für Druck oder Wallpaper eignet, ohne separaten Hochskalierer.

Alte Fotos aufwerten

Kleine Digitalfotos aus frühen Handy-Zeiten mit dem FLUX.2-VAE codieren und über PiD vierfach vergrößern. Das Ergebnis wirkt deutlich detailreicher. Bedenke aber, dass Details hinzuerfunden werden, daher eher für Deko-Zwecke als zur Dokumentation.

Texturen für Spiele und 3D

Niedrig aufgelöste Texturen wie Holz, Stein oder Stoff durch PiD schicken und mit passender Beschreibung hochskalieren. So entstehen schnell hochaufgelöste Varianten für 3D-Szenen oder Mods.

Videoframes als Standbilder

Einzelne Frames aus eigenen Videos als Standbild exportieren und vergrößern, etwa für ein Vorschaubild oder einen Ausdruck. Für ganze Videos ist PiD nicht ausgelegt, da jedes Bild einzeln neu gezeichnet wird.

Schnellere Bildpipeline

In bestehenden ComfyUI-Workflows den Schritt aus VAE und separatem Hochskalierer durch PiD ersetzen. Laut NVIDIA spart das bei 2048×2048-Ausgaben rund den Faktor sechs an Decodierzeit.

Download1,2 GB (bei 100 MBit/s ca. 2 Min.)
ArtBildbearbeitung
Hugging Facenvidia/PiD

Was dein Rechner braucht

Grafikkarte (NVIDIA) mind. 6 GB VRAMfast jede Grafikkarte ab 4 GB (z. B. GTX 1650, RTX 3050)
Mac (Apple Silicon M1–M5) ab 8 GB gemeinsamer Speicherläuft über Metal (MPS), aber deutlich langsamer als mit NVIDIA-Karte
Nur Prozessor (ohne Grafikkarte) Möglich, aber sehr langsammehrere Minuten pro Bild. Nicht empfehlenswert.
Speicherplatz ca. 3,2 GB freiModell-Download plus Programme
Google Colab läuft kostenlosGratis-GPU Tesla T4 mit 15 GB reicht

NVIDIA liefert einzelne PiD-Decoder pro Latent-Raum: FLUX.1, FLUX.2, Qwen-Image (erste Version), SD3, SDXL sowie DINOv2 und SigLIP. Nimm den Decoder, der zum VAE deines Bildmodells passt. Für das Hochskalieren beliebiger Bilder ist der FLUX.2-Decoder zusammen mit dem FLUX.2-VAE die richtige Wahl. Quantisierte Varianten nennen die Quellen nicht. Laut Paper reichen für 2048×2048 rund 13 GB VRAM, also eine 16-GB-Karte als sinnvolles Minimum.

  • Laut NVIDIA-Paper liegt die Speicherspitze bei 13 GB VRAM, um ein 512×512-Latent auf 2048×2048 Pixel zu decodieren (gemessen auf einer RTX 5090), Dauer unter einer Sekunde.
  • Eine NVIDIA-Grafikkarte mit mindestens 16 GB VRAM ist eine realistische Untergrenze. Bei 12 GB oder weniger fehlen offizielle Angaben.
  • Größere Ausgaben, etwa 8-fache Vergrößerung, brauchen voraussichtlich deutlich mehr Speicher. Konkrete Zahlen dazu nennen die Quellen nicht.
  • Auf Rechenzentrums-GPUs wie der GB200 dauert der Decode laut Paper nur rund 210 Millisekunden.
  • Ob PiD auf Apple Silicon oder rein auf der CPU sinnvoll läuft, ist nicht dokumentiert. Als Alternative gibt es den Community-Workflow in der ComfyUI-Cloud.
Wie finde ich heraus, was mein Rechner hat?
  • Windows: Strg + Umschalt + Esc drücken → Task-Manager → Reiter Leistung → links GPU anklicken. Unten steht Dedizierter GPU-Speicher (das ist dein VRAM). Den Arbeitsspeicher findest du unter Arbeitsspeicher.
  • Mac: Apfel-Menü oben links → Über diesen Mac. Dort stehen Chip (z. B. M2) und Speicher (z. B. 16 GB). Bei Apple-Chips teilen sich Grafik und Prozessor diesen Speicher.
  • Linux: Im Terminal nvidia-smi eingeben (zeigt Grafikkarte und Speicher) und free -h für den Arbeitsspeicher.

Anleitung

Dieses Modell läuft mit einem eigenen Programm seiner Entwickler (bytetriper/RAE auf GitHub). Die Befehle unten stammen aus der Model Card und der Anleitung der Entwickler.

Windows 10 / 11

Windows 10 / 11: nicht offiziell getestet. Windows wird in der Quelle nicht erwähnt. Mit einer NVIDIA-Karte sollte es grundsätzlich laufen. Zuverlässiger ist aber WSL2 (ein Linux innerhalb von Windows), dort folgst du einfach der Linux-Anleitung.

  1. Voraussetzungen prüfen. Installiere Python (3.10 hat sich bewährt), Git und den aktuellen NVIDIA-Treiber. Öffne PowerShell und prüfe mit den Befehlen, ob alles da ist. Plane rund 80 GB freien Speicherplatz für PiD-Checkpoints und FLUX.1-dev ein.
    python --version
    git --version
    nvidia-smi
  2. Programm herunterladen. Hol dir den PiD-Code von GitHub und wechsle in den Ordner.
    git clone https://github.com/nv-tlabs/PiD.git
    cd PiD
  3. Virtuelle Umgebung anlegen. Die virtuelle Umgebung hält die Pakete getrennt vom Rest. Meldet PowerShell, dass Skripte gesperrt sind, führe zuerst Set-ExecutionPolicy -Scope CurrentUser RemoteSigned aus. Danach steht (.venv) vor der Zeile.
    python -m venv .venv
    .venv\Scripts\Activate.ps1
  4. PyTorch und Abhängigkeiten installieren. Installiert PyTorch mit CUDA-Unterstützung. Die genaue PiD-Paketliste lag uns nicht vor. Gibt es eine requirements.txt im Ordner, installierst du sie mit der zweiten Zeile.
    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu129
    pip install -r requirements.txt
  5. Bei Hugging Face anmelden. Akzeptiere eingeloggt auf der Hugging-Face-Seite von black-forest-labs/FLUX.1-dev die Lizenz. Melde dich dann mit deinem Token an.
    pip install huggingface_hub
    hf auth login
  6. PiD-Gewichte herunterladen. Lädt den Ordner checkpoints (rund 50 GB) in den PiD-Ordner.
    hf download nvidia/PiD --local-dir . --include "checkpoints/*"
  7. Erstes Bild erzeugen. In PowerShell setzt du PYTHONPATH in einer eigenen Zeile. Das Zeichen ` am Zeilenende bedeutet: Der Befehl geht in der nächsten Zeile weiter. Beim ersten Start wird FLUX.1-dev heruntergeladen.
    $env:PYTHONPATH="."
    python -m pid._src.inference.from_ldm --backbone flux `
        --prompt "A photorealistic half-body portrait of a brown tabby cat with bold stripes sitting attentively on a rustic wooden kitchen table, soft morning light streaming sideways through a large window, fine fur detail and stripe patterns sharply visible, intense amber-green eyes in razor-sharp focus, warm farmhouse kitchen softly out of focus, cinematic shallow depth of field, ultra-detailed fur texture, photorealistic" `
        --ldm_inference_steps 28 --save_xt_steps 24 `
        --output_dir ./results/official_demo/flux `
        --pid_inference_steps 4
  8. Ergebnis ansehen. Öffne im Explorer den Ordner results\official_demo\flux. Dort liegen die Bilder.
    dir results\official_demo\flux
  9. Ergebnis. Im Ordner results/official_demo/flux liegt ein hochaufgelöstes Bild einer getigerten Katze auf einem Küchentisch, entschlüsselt von PiD.

macOS

macOS: nicht offiziell getestet. macOS wird in der Quelle nicht erwähnt. Der Code von NVIDIA ist auf NVIDIA-Grafikkarten (CUDA) ausgelegt, die es im Mac nicht gibt. Es kann also gut sein, dass er auf dem Mac gar nicht läuft. Als Alternative bietet sich ein gemieteter Cloud-Rechner mit NVIDIA-Karte an.

  1. Voraussetzungen prüfen. Installiere die Xcode-Kommandozeilenwerkzeuge (bringen Git mit) und Python 3.10 oder neuer. Plane rund 80 GB freien Speicher ein. Rechne damit, dass es ohne NVIDIA-Karte scheitern kann.
    xcode-select --install
    python3 --version
  2. Programm herunterladen. Hol dir den PiD-Code und wechsle in den Ordner.
    git clone https://github.com/nv-tlabs/PiD.git
    cd PiD
  3. Virtuelle Umgebung anlegen. Lege eine abgetrennte Python-Umgebung an und aktiviere sie. Danach steht (.venv) vor der Zeile.
    python3 -m venv .venv
    source .venv/bin/activate
  4. PyTorch und Abhängigkeiten installieren. Auf dem Mac gibt es kein CUDA, deshalb installierst du das normale PyTorch. Gibt es eine requirements.txt im Ordner, installierst du sie mit der zweiten Zeile.
    pip install torch torchvision torchaudio
    pip install -r requirements.txt
  5. Bei Hugging Face anmelden. Akzeptiere eingeloggt auf der Hugging-Face-Seite von black-forest-labs/FLUX.1-dev die Lizenz. Melde dich dann mit deinem Token an.
    pip install huggingface_hub
    hf auth login
  6. PiD-Gewichte herunterladen. Lädt den Ordner checkpoints (rund 50 GB) in den PiD-Ordner.
    hf download nvidia/PiD --local-dir . --include "checkpoints/*"
  7. Erstes Bild erzeugen. Das ist der Beispielbefehl aus der Model Card. Bricht er mit einem Fehler zu CUDA ab, läuft der Code auf dem Mac nicht.
    PYTHONPATH=. python -m pid._src.inference.from_ldm --backbone flux \
        --prompt "A photorealistic half-body portrait of a brown tabby cat with bold stripes sitting attentively on a rustic wooden kitchen table, soft morning light streaming sideways through a large window, fine fur detail and stripe patterns sharply visible, intense amber-green eyes in razor-sharp focus, warm farmhouse kitchen softly out of focus, cinematic shallow depth of field, ultra-detailed fur texture, photorealistic" \
        --ldm_inference_steps 28 --save_xt_steps 24 \
        --output_dir ./results/official_demo/flux \
        --pid_inference_steps 4
  8. Ergebnis. Im Ordner results/official_demo/flux liegt ein hochaufgelöstes Bild einer getigerten Katze auf einem Küchentisch, entschlüsselt von PiD.

Linux

Linux: unterstützt. Linux mit einer NVIDIA-Grafikkarte ist das übliche Umfeld für den PiD-Code von NVIDIA. Achtung: Die Lizenz NSCLv1 erlaubt nur nicht-kommerzielle Nutzung, also Forschung oder Ausprobieren.

  1. Voraussetzungen prüfen. Du brauchst Python (3.10 hat sich bewährt), Git und eine NVIDIA-Grafikkarte mit aktuellem Treiber. Mit nvidia-smi prüfst du, ob die Karte erkannt wird. Plane außerdem viel freien Speicherplatz ein: Alle PiD-Checkpoints zusammen sind rund 50 GB groß, FLUX.1-dev braucht noch einmal über 30 GB. Checkpoints sind gespeicherte Modellgewichte.
    python3 --version
    git --version
    nvidia-smi
  2. Programm herunterladen. Hol dir den PiD-Code von GitHub und wechsle in den Ordner. Wenn es geklappt hat, gibt es danach einen Ordner PiD mit einem Unterordner pid.
    git clone https://github.com/nv-tlabs/PiD.git
    cd PiD
  3. Virtuelle Umgebung anlegen. Eine virtuelle Umgebung (venv) ist ein abgetrennter Bereich für Python-Pakete. So kommt nichts mit deinem übrigen System durcheinander. Nach dem Aktivieren steht (.venv) vor der Eingabezeile.
    python3 -m venv .venv
    source .venv/bin/activate
  4. PyTorch und Abhängigkeiten installieren. PyTorch ist die Grundlage für das Modell. Der Befehl installiert die Version für CUDA 12.9, so wie im verwandten RAE-Projekt beschrieben. Die genaue Paketliste von PiD lag uns nicht vor. Liegt im Ordner eine Datei requirements.txt, installierst du sie mit der zweiten Zeile. Lies zur Sicherheit auch die README im PiD-Ordner.
    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu129
    pip install -r requirements.txt
  5. Bei Hugging Face anmelden. Die Demo lädt FLUX.1-dev. Für dieses Modell musst du auf seiner Hugging-Face-Seite (black-forest-labs/FLUX.1-dev) eingeloggt die Lizenz akzeptieren. Danach meldest du dich im Terminal mit einem Zugangsschlüssel (Token) an, den du in deinem Hugging-Face-Konto unter Settings, Access Tokens erstellst.
    pip install huggingface_hub
    hf auth login
  6. PiD-Gewichte herunterladen. Der Befehl lädt den Ordner checkpoints direkt in den PiD-Ordner. Die README und das Titelbild werden dabei übersprungen. Das sind rund 50 GB, plane also Zeit ein. Fertig ist es, wenn im Ordner checkpoints unter anderem ae.safetensors liegt.
    hf download nvidia/PiD --local-dir . --include "checkpoints/*"
  7. Erstes Bild erzeugen. Dieser Befehl kommt aus der Model Card. FLUX erzeugt zuerst ein Katzenbild im komprimierten Zwischenformat (Latent). PiD entschlüsselt es danach in nur 4 Schritten zu einem hochaufgelösten Bild. Beim ersten Start wird FLUX.1-dev automatisch heruntergeladen, das dauert lange.
    PYTHONPATH=. python -m pid._src.inference.from_ldm --backbone flux \
        --prompt "A photorealistic half-body portrait of a brown tabby cat with bold stripes sitting attentively on a rustic wooden kitchen table, soft morning light streaming sideways through a large window, fine fur detail and stripe patterns sharply visible, intense amber-green eyes in razor-sharp focus, warm farmhouse kitchen softly out of focus, cinematic shallow depth of field, ultra-detailed fur texture, photorealistic" \
        --ldm_inference_steps 28 --save_xt_steps 24 \
        --output_dir ./results/official_demo/flux \
        --pid_inference_steps 4
  8. Ergebnis ansehen. Öffne den Ordner results/official_demo/flux. Dort liegen die erzeugten Bilder. Meldet das Programm einen Speicherfehler (out of memory), reicht der Grafikspeicher für FLUX.1-dev nicht aus.
    ls results/official_demo/flux
  9. Ergebnis. Im Ordner results/official_demo/flux liegt ein hochaufgelöstes Bild einer getigerten Katze auf einem Küchentisch, entschlüsselt von PiD.

So geht es nach dem ersten Ergebnis weiter

  • Ersetze den Text hinter --prompt durch deine eigene Bildbeschreibung (am besten auf Englisch).
  • Mit --pid_ckpt_type 2kto4k_v1pt5 entschlüsselt PiD Bilder von FLUX, FLUX.2 und Qwen-Image bis in 4K-Auflösung. Für SD3 und SDXL nimmst du --pid_ckpt_type 2kto4k.
  • Über --backbone wählst du ein anderes Bildmodell, zum Beispiel zimage-turbo, flux2-klein-4b, qwenimage, sd3 oder sdxl. Kleinere Modelle wie flux2-klein-4b brauchen weniger Grafikspeicher als FLUX.1-dev.
  • Eine Web-Oberfläche wird in der Quelle nicht erwähnt. Gesteuert wird alles über die Kommandozeile.

Das kannst du ausprobieren

Ein selbst generiertes SDXL-Bild (1024×1024) mit dem SDXL-PiD-Decoder direkt auf 4096×4096 decodieren und mit dem normalen VAE-Ergebnis vergleichen.
Ein altes, kleines Urlaubsfoto (512×512) mit dem FLUX.2-VAE codieren und mit der Beschreibung „Waldweg im Herbst, Sonnenlicht durch die Blätter, detailreiches Laub“ vierfach hochskalieren.
Ein Porträt-Render aus einem beliebigen Modell mit der Bildbeschreibung „Nahaufnahme einer Frau, natürliche Hauttextur, feine Haare“ über den FLUX.2-Weg vergrößern und auf Haut- und Haardetails achten.
Bei FLUX.1 [dev] mit 28 Schritten die Generierung bei Schritt 24 abbrechen und das Zwischen-Latent an PiD übergeben, dann mit dem Abbruch bei Schritt 20 und bei 28 vergleichen.
Ein Bild mit Schrift, etwa ein Ladenschild, hochskalieren und prüfen, ob die Buchstaben korrekt bleiben, um die Grenzen des generativen Decoders zu testen.

Tipps für bessere Ergebnisse

  • Gib beim Hochskalieren eine kurze, treffende Bildbeschreibung mit. Sie lenkt, welche Art von Details PiD ergänzt, zum Beispiel Laub, Stoff oder Haut.
  • Wenn du PiD direkt in der Generierung nutzt, stoppe den Basis-Generator drei bis fünf Schritte vor dem Ende. Das lieferte im Paper bei FLUX.1 [dev] die beste Qualität und spart Zeit.
  • Vergleiche das Ergebnis immer mit dem Original, vor allem bei Gesichtern und Schrift, weil PiD Details erfindet statt sie wiederherzustellen.
  • Nutze eine Eingabe von etwa 512×512 als Ausgangspunkt. Dafür liegen die Messwerte aus dem Paper vor (2048×2048 Ausgabe, 13 GB VRAM).

Wenn es hakt

PiD funktioniert nur mit dem passenden Latent-Raum. Ein Latent von einem Modell mit anderem VAE an einen falschen Decoder zu schicken, liefert Unsinn. Für fremde Modelle das Bild erst mit dem FLUX.2-VAE codieren.

Für den Hochskalier-Trick muss der FLUX.2-VAE separat heruntergeladen und im Workflow geladen werden.

Die Decoder-Schritte sind auf vier destilliert. Mehr Schritte bringen nicht automatisch bessere Ergebnisse, die Standardwerte des Workflows also erst einmal beibehalten.

Wenn ComfyUI die PiD-Knoten nicht kennt, ComfyUI und die benötigten Custom Nodes aktualisieren. Der Community-Workflow zeigt fehlende Knoten in der Regel beim Laden an.

Lizenzbedingungen auf der Hugging-Face-Seite von nvidia/PiD vor einer kommerziellen Nutzung prüfen. Die Quellen nennen die Lizenz nicht.

Bei Speicherfehlern zuerst die Eingabegröße verkleinern, denn die Ausgabe wird viermal so breit und hoch und braucht entsprechend viel VRAM.

„out of memory“, Absturz oder der Rechner hängt

Das Modell ist zu groß für deinen Grafikspeicher. Nimm eine kleinere Variante aus der Tabelle oben und schließe andere Programme, vor allem Spiele und Browser mit vielen Tabs.

Es läuft, aber extrem langsam

Wahrscheinlich rechnet der Prozessor statt der Grafikkarte. Bei Ollama zeigt ollama ps in der Spalte PROCESSOR, wie viel auf der GPU läuft. Steht dort „100% CPU“, Grafiktreiber aktualisieren oder eine kleinere Variante nehmen, die komplett in den Grafikspeicher passt.

„ollama“ bzw. „python“ wird nicht gefunden

Das Eingabefenster schließen und neu öffnen, damit es das frisch installierte Programm kennt. Bei Python unter Windows: neu installieren und das Häkchen Add python.exe to PATH setzen.

Windows: „Die Ausführung von Skripts ist auf diesem System deaktiviert“

Das Skript genau mit dem Befehl oben starten: powershell -ExecutionPolicy Bypass -File try_windows.ps1. Das erlaubt die Ausführung nur dieses einen Mal.

Fehlermeldung beim Laden des Modells (Version, „trust_remote_code“, unbekannte Architektur)

Ganz neue Modelle brauchen oft die neueste Programmversion. Bei Ollama: Ollama aktualisieren. Bei Python: pip install -U transformers in der aktivierten Umgebung. Die Model Card nennt meist die genaue Version.

Skripte und Notebook erzeugt Tokenstrom automatisch. Bitte vor dem Ausführen kurz ansehen – sie sind lesbarer Klartext. Lizenz des Modells beachten: eigene Lizenz (siehe Model Card).

Frag den KI-Assistenten

Fragen zu diesem Artikel, zur Installation oder zu Hintergründen? Unser Assistent kennt diese Seite und läuft auf unserem eigenen Rechner, nicht in einer fremden Cloud.

Verbinde …

Der Assistent ist eine KI (Gemma 4) und kann sich irren – wichtige Angaben bitte in der Quelle prüfen. Fragen werden nur zum Beantworten genutzt und nach einer Stunde gelöscht. Bitte keine persönlichen Daten eingeben.

Kommentare

Was meinst du dazu? Schon ausprobiert? Schreib es hier, ohne Anmeldung.

  1. Kommentare werden geladen …

Kommentare sind öffentlich. Links sind nicht erlaubt, beleidigende Beiträge löschen wir. Deinen eigenen Kommentar kannst du in diesem Browser jederzeit wieder löschen. Mehr dazu in der Datenschutzerklärung.