MiniMax-H3-Image: Offenes Bildmodell erzeugt direkt 16-Megapixel-Bilder

Im Browser (ohne Installation)

Die Entwickler haben eine Online-Demo auf Hugging Face. Dort kannst du das Modell sofort ausprobieren, ohne etwas zu installieren. Manchmal musst du kurz warten, bis die Demo aufgewacht ist.

Online-Demo öffnen

Windows 10 / 11

Windows 10 / 11: nicht offiziell getestet. Die Quelle sagt nichts zu Windows, und SGLang ist auf Linux mit NVIDIA ausgelegt. Am ehesten klappt es über WSL2 (ein Linux innerhalb von Windows) mit den Linux-Schritten. Ohne Rechenzentrums-GPU nimmst du besser die Web-App hailuoai.video oder die MiniMax-API.

1. Voraussetzungen prüfen. Du brauchst ein aktuelles Python 3, Git, einen aktuellen NVIDIA-Treiber mit CUDA und rund 140 GB freien Speicher auf der Festplatte. Öffne PowerShell. Zeigt nvidia-smi deine Grafikkarte an, passt alles. Klappt einer der Schritte unten nicht, richte WSL2 ein und folge der Linux-Anleitung.

   python --version
   git --version
   nvidia-smi

2. Arbeitsordner und Umgebung anlegen. Eine virtuelle Umgebung (venv) hält die Python-Pakete getrennt vom Rest. Steht danach (.venv) vor der Eingabezeile, ist sie aktiv. Meldet PowerShell, dass Skripte gesperrt sind, gib vorher Set-ExecutionPolicy -Scope CurrentUser RemoteSigned ein.

   mkdir minimax-h3-image; cd minimax-h3-image
   python -m venv .venv
   .venv\Scripts\Activate.ps1

3. SGLang und Download-Werkzeug installieren. SGLang ist das Server-Programm für das Modell. Das Paket huggingface_hub bringt den Befehl hf mit. Bricht die Installation unter Windows ab, wechselst du zu WSL2.

   pip install --upgrade pip
   pip install sglang huggingface_hub

4. Modell herunterladen. Hier kommen das Bildmodell (rund 69 GB) und der Text-Encoder aus MiniMax-H3 (rund 67 GB) auf die Platte. Das dauert lange. Nach einer Unterbrechung startest du den Befehl einfach neu.

   hf download MiniMaxAI/MiniMax-H3-Image
   hf download MiniMaxAI/MiniMax-H3 --include "text_encoder/*"

5. Server starten. Der Befehl startet das Modell auf Port 30000. Lass dieses Fenster offen und mach ein zweites PowerShell-Fenster auf. Aktiviere dort ebenfalls die venv.

   sglang serve --model-path MiniMaxAI/MiniMax-H3-Image --host 0.0.0.0 --port 30000 --warmup-mode off

6. Anfrage-Skript anlegen. Öffne den Editor, füge den Code ein und speichere ihn als demo.py im Ordner minimax-h3-image. Achte darauf, dass die Datei nicht als demo.py.txt gespeichert wird.

   import json, base64, urllib.request
   body = json.dumps({
     "prompt": "A photorealistic close-up portrait of a shaggy highland cow standing in a misty Scottish meadow at sunrise, long reddish-brown fur with dew drops, curved horns, soft golden backlight, green grass and purple heather, shallow depth of field, highly detailed.",
     "size": "4096x4096", "seed": 42,
     "generator_device": "cpu", "response_format": "b64_json"}).encode()
   req = urllib.request.Request("http://localhost:30000/v1/images/generations", data=body, headers={"Content-Type": "application/json"})
   data = json.load(urllib.request.urlopen(req, timeout=3600))
   open("bild.png", "wb").write(base64.b64decode(data["data"][0]["b64_json"]))
   print("Fertig: bild.png")

7. Erstes Bild erzeugen. Starte das Skript im zweiten Fenster. Steht am Ende „Fertig: bild.png“, liegt das Bild im Ordner.

   python demo.py

8. Ergebnis. Im Ordner liegt die Datei bild.png, ein 4096×4096 Pixel großes Bild (16 Megapixel), das dein lokaler SGLang-Server erzeugt hat.

macOS

macOS: nicht offiziell getestet. Die Quelle nennt nur den Betrieb mit SGLang auf Grafikkarten und erwähnt den Mac nicht. Bei rund 135 GB Gewichten ist es auch auf großen Apple-Silicon-Macs sehr unwahrscheinlich, dass es läuft. Realistisch nutzt du am Mac die Web-App hailuoai.video, die Desktop-App oder die MiniMax-API.

1. Voraussetzungen prüfen. Du brauchst Python 3, Git und die Xcode-Kommandozeilenwerkzeuge (Entwicklerwerkzeuge von Apple). Dazu kommen rund 140 GB freier Speicher. Erscheint bei git ein Installationsfenster, bestätige es.

   xcode-select --install
   python3 --version
   git --version

2. Arbeitsordner und Umgebung anlegen. Die virtuelle Umgebung (venv) hält die Pakete getrennt vom Rest. Steht danach (.venv) vor der Eingabezeile, ist sie aktiv.

   mkdir minimax-h3-image && cd minimax-h3-image
   python3 -m venv .venv
   source .venv/bin/activate

3. SGLang und Download-Werkzeug installieren. SGLang ist das Server-Programm für das Modell. Das Paket huggingface_hub bringt den Befehl hf mit. Schlägt die Installation fehl, wird das Modell auf deinem Mac nicht laufen. Nimm dann die Web-App.

   pip install --upgrade pip
   pip install sglang huggingface_hub

4. Modell herunterladen. Hier kommen das Bildmodell (rund 69 GB) und der Text-Encoder (rund 67 GB) auf die Platte. Prüf vorher, ob genug Platz frei ist.

   hf download MiniMaxAI/MiniMax-H3-Image
   hf download MiniMaxAI/MiniMax-H3 --include "text_encoder/*"

5. Server starten. Der Befehl startet das Modell auf Port 30000. Lass das Fenster offen und öffne ein zweites Terminal im selben Ordner.

   sglang serve --model-path MiniMaxAI/MiniMax-H3-Image --host 0.0.0.0 --port 30000 --warmup-mode off

6. Anfrage-Skript anlegen. Der Befehl legt die Datei demo.py an. Sie schickt eine englische Bildbeschreibung an den Server.

   cd minimax-h3-image
   cat > demo.py << 'EOF'
   import json, base64, urllib.request
   body = json.dumps({
     "prompt": "A photorealistic close-up portrait of a shaggy highland cow standing in a misty Scottish meadow at sunrise, long reddish-brown fur with dew drops, curved horns, soft golden backlight, green grass and purple heather, shallow depth of field, highly detailed.",
     "size": "4096x4096", "seed": 42,
     "generator_device": "cpu", "response_format": "b64_json"}).encode()
   req = urllib.request.Request("http://localhost:30000/v1/images/generations", data=body, headers={"Content-Type": "application/json"})
   data = json.load(urllib.request.urlopen(req, timeout=3600))
   open("bild.png", "wb").write(base64.b64decode(data["data"][0]["b64_json"]))
   print("Fertig: bild.png")
   EOF

7. Erstes Bild erzeugen. Starte das Skript. Steht am Ende „Fertig: bild.png“, öffne die Datei per Doppelklick in der Vorschau.

   python3 demo.py

8. Ergebnis. Im Ordner liegt die Datei bild.png, ein 4096×4096 Pixel großes Bild (16 Megapixel), das dein lokaler SGLang-Server erzeugt hat.

Linux

Linux: unterstützt. Die Quelle zeigt den Start mit SGLang auf einer NVIDIA-GPU unter Linux. Du brauchst eine Rechenzentrums-Grafikkarte mit sehr viel Speicher und rund 140 GB freien Plattenplatz. Mit normalen Gaming-Karten klappt das nicht, dann nimmst du besser die Web-App hailuoai.video oder die MiniMax-API.

1. Voraussetzungen prüfen. Du brauchst ein aktuelles Python 3, Git, einen aktuellen NVIDIA-Treiber mit CUDA und rund 140 GB freien Speicher auf der Festplatte. CUDA ist die Rechenschnittstelle von NVIDIA. Wenn nvidia-smi deine Grafikkarte und ihren Speicher anzeigt, passt alles.

   python3 --version
   git --version
   nvidia-smi

2. Arbeitsordner und Umgebung anlegen. Eine virtuelle Umgebung (venv) ist ein abgetrennter Bereich für Python-Pakete. So bringst du dein restliches System nicht durcheinander. Steht danach (.venv) vor deiner Eingabezeile, ist die Umgebung aktiv.

   mkdir minimax-h3-image && cd minimax-h3-image
   python3 -m venv .venv
   source .venv/bin/activate

3. SGLang und Download-Werkzeug installieren. SGLang ist das Server-Programm, das das Modell ausführt. Das Paket huggingface_hub bringt den Befehl hf zum Herunterladen mit. Fehlt beim Start später etwas, schau ins SGLang-Cookbook zu MiniMax-H3-Image.

   pip install --upgrade pip
   pip install sglang huggingface_hub

4. Modell herunterladen. Der erste Befehl lädt das Bildmodell (rund 69 GB). Der zweite lädt nur den Text-Encoder aus MiniMax-H3 (rund 67 GB). Der Text-Encoder ist der Teil, der deinen Text versteht. Das dauert lange. Unterbricht der Download, startest du denselben Befehl einfach neu.

   hf download MiniMaxAI/MiniMax-H3-Image
   hf download MiniMaxAI/MiniMax-H3 --include "text_encoder/*"

5. Server starten. Dieser Befehl startet das Modell auf einer Grafikkarte und wartet auf Port 30000 auf Anfragen. Das Laden dauert einige Minuten. Lass dieses Fenster offen und mach für die nächsten Schritte ein neues Terminal auf.

   sglang serve --model-path MiniMaxAI/MiniMax-H3-Image --host 0.0.0.0 --port 30000 --warmup-mode off

6. Anfrage-Skript anlegen. Geh im neuen Terminal in denselben Ordner. Der Befehl legt die Datei demo.py an. Sie braucht nur das, was Python schon mitbringt. Das Modell erwartet eine ausführliche englische Bildbeschreibung. Die Größe muss zum Modell passen, hier 4096x4096.

   cd minimax-h3-image
   cat > demo.py << 'EOF'
   import json, base64, urllib.request
   body = json.dumps({
     "prompt": "A photorealistic close-up portrait of a shaggy highland cow standing in a misty Scottish meadow at sunrise, long reddish-brown fur with dew drops, curved horns, soft golden backlight, green grass and purple heather, shallow depth of field, highly detailed.",
     "size": "4096x4096", "seed": 42,
     "generator_device": "cpu", "response_format": "b64_json"}).encode()
   req = urllib.request.Request("http://localhost:30000/v1/images/generations", data=body, headers={"Content-Type": "application/json"})
   data = json.load(urllib.request.urlopen(req, timeout=3600))
   open("bild.png", "wb").write(base64.b64decode(data["data"][0]["b64_json"]))
   print("Fertig: bild.png")
   EOF

7. Erstes Bild erzeugen. Das Skript schickt deine Beschreibung an den Server und speichert die Antwort als PNG-Bild. Steht am Ende „Fertig: bild.png“, hat alles geklappt. Öffne die Datei mit einem Bildbetrachter.

   python3 demo.py

8. Ergebnis. Im Ordner liegt die Datei bild.png, ein 4096×4096 Pixel großes Bild (16 Megapixel), das dein lokaler SGLang-Server erzeugt hat.