In Teil 1 dieser Reihe hast du erfahren, wie du Sprachmodelle (LLMs) vollständig lokal auf deinem Rechner betreibst — mit Ollama, llama.cpp und OpenWebUI. Jetzt gehen wir einen Schritt weiter: Bilder zeichnen, Sprache transkribieren, Stimmen synthetisieren — alles offline, ohne Cloud-API, ohne Datenschutzbedenken. Dieser Teil zeigt dir, wie multimodale lokale KI-Generierung in der Praxis aussieht.
Voraussetzungen
- Du hast Teil 1 gelesen und weißt, wie lokale Modelle grundsätzlich funktionieren (Quantisierung, GGUF, VRAM-Limits).
- GPU empfohlen: NVIDIA-Karte mit mindestens 6 GB VRAM für Bildgenerierung (8–12 GB für komfortables Arbeiten). AMD via ROCm ist möglich, aber aufwändiger.
- RAM: Mindestens 16 GB Systemspeicher.
- Python 3.10+ und
gitsind installiert. - Für CPU-only-Betrieb: mehr Geduld. Whisper und Piper laufen auch ohne GPU gut.
Bildgenerierung lokal: Das Konzept verstehen
Bevor wir Befehle tippen, kurz das mentale Modell: Lokale Bildgenerierung basiert fast immer auf Diffusion-Modellen. Das Modell startet mit Rauschen und "entrauscht" Schritt für Schritt, geleitet durch deinen Text-Prompt (Text-zu-Bild) oder ein Ausgangsbild (Bild-zu-Bild).
Modelle, Checkpoints und LoRAs
- Checkpoint (
.safetensorsoder.ckpt): Das vollständige Basismodell. Beispiele: Stable Diffusion 1.5, SDXL 1.0, Flux.1-dev. Größe: 2–20 GB. - LoRA (Low-Rank Adaptation): Kleines Zusatzgewicht (~50–300 MB), das den Stil oder bestimmte Konzepte beibringt. Wird on-the-fly auf den Checkpoint addiert.
- VAE (Variational Autoencoder): Wandelt latente Darstellungen in Pixel um. Manchmal separat — beeinflusst Farbsättigung und Schärfe.
- Sampler/Scheduler: Euler, DPM++ 2M, DDIM — bestimmen, wie das Entrauschen abläuft. Mehr Schritte = länger, aber nicht immer besser.
Hinweis zu Lizenzen: Viele populäre Modelle (z. B. Flux.1-dev) haben eigene Nutzungsbedingungen. Prüfe vor dem kommerziellen Einsatz immer die jeweilige Modell-Lizenz auf Hugging Face oder CivitAI.
VRAM-Bedarf im Überblick
| Modell / Architektur | Minimaler VRAM | Empfohlen | Anmerkung |
|---|---|---|---|
| SD 1.5 (512px) | 4 GB | 6 GB | Ältester Standard, schnell |
| SDXL 1.0 (1024px) | 6 GB | 10–12 GB | Deutlich bessere Qualität |
| SDXL Turbo / Lightning | 6 GB | 8 GB | 1–4 Schritte, sehr schnell |
| Flux.1-schnell | 8 GB | 12 GB | Open-Source, Top-Qualität |
| Flux.1-dev | 12 GB | 16–24 GB | Non-commercial license |
| CPU-only (SD 1.5) | — | 32 GB RAM | Minuten pro Bild |
ComfyUI: Der flexible Node-Graph
ComfyUI ist aktuell das mächtigste lokale Frontend für Bildgenerierung. Du baust Workflows als visuellen Graph — jeder Node ist ein Verarbeitungsschritt.
Installation
# Repository klonen
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
# Virtuelle Umgebung erstellen
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
# Abhängigkeiten installieren (CUDA 12.1 Beispiel)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install -r requirements.txt
# Modell herunterladen (Beispiel: SDXL Base)
# Platziere .safetensors-Dateien in: models/checkpoints/
# LoRAs kommen nach: models/loras/
# Starten
python main.py --listen 0.0.0.0 --port 8188
Öffne danach http://localhost:8188 im Browser. Der Standard-Workflow ist bereits geladen — du musst nur einen Checkpoint auswählen und auf "Queue Prompt" klicken.
Einfacher Text-zu-Bild Workflow (CLI via API)
ComfyUI bietet eine REST-API. Hier ein minimales Python-Skript, das einen Prompt abschickt:
import json
import urllib.request
COMFY_URL = "http://127.0.0.1:8188"
workflow = {
"3": {
"class_type": "KSampler",
"inputs": {
"seed": 42,
"steps": 20,
"cfg": 7.0,
"sampler_name": "euler",
"scheduler": "normal",
"denoise": 1.0,
"model": ["4", 0],
"positive": ["6", 0],
"negative": ["7", 0],
"latent_image": ["5", 0]
}
},
"4": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "sd_xl_base_1.0.safetensors"}},
"5": {"class_type": "EmptyLatentImage", "inputs": {"width": 1024, "height": 1024, "batch_size": 1}},
"6": {"class_type": "CLIPTextEncode", "inputs": {"text": "a photorealistic cat on a rooftop, golden hour", "clip": ["4", 1]}},
"7": {"class_type": "CLIPTextEncode", "inputs": {"text": "blurry, ugly, deformed", "clip": ["4", 1]}},
"8": {"class_type": "VAEDecode", "inputs": {"samples": ["3", 0], "vae": ["4", 2]}},
"9": {"class_type": "SaveImage", "inputs": {"images": ["8", 0], "filename_prefix": "output"}}
}
payload = json.dumps({"prompt": workflow}).encode("utf-8")
req = urllib.request.Request(f"{COMFY_URL}/prompt", data=payload, headers={"Content-Type": "application/json"})
response = urllib.request.urlopen(req)
print(json.loads(response.read()))
Automatic1111: Die klassische Web-UI
Für einen einfacheren Einstieg ohne Node-Graphen ist AUTOMATIC1111 / stable-diffusion-webui nach wie vor beliebt. Die Installation ist ähnlich:
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui
# Modell in models/Stable-diffusion/ ablegen, dann:
./webui.sh # Linux/macOS
# oder webui-user.bat auf Windows
Die Web-UI startet auf http://localhost:7860. Hier findest du txt2img, img2img, Inpainting und eine LoRA-Integration per Dropdown — gut für schnelles Experimentieren.
Tipp: Für Flux-Modelle ist ComfyUI aktuell die bessere Wahl, da Automatic1111 Flux erst mit Zusatz-Erweiterungen unterstützt.
Speech-to-Text lokal: Whisper
OpenAIs Whisper ist das De-facto-Standardmodell für lokale Spracherkennung. Es transkribiert Audio in über 90 Sprachen mit beeindruckender Genauigkeit — und läuft vollständig offline.
faster-whisper: Der schnelle Weg
faster-whisper ist eine optimierte Reimplementierung auf Basis von CTranslate2 und deutlich schneller als das originale OpenAI-Paket:
pip install faster-whisper
# Einfaches Transkriptionsskript
python3 - <<'EOF'
from faster_whisper import WhisperModel
# Modell-Größen: tiny, base, small, medium, large-v3
# device="cuda" für GPU, "cpu" für CPU
model = WhisperModel("large-v3", device="cuda", compute_type="float16")
segments, info = model.transcribe("aufnahme.mp3", language="de", beam_size=5)
print(f"Erkannte Sprache: {info.language} ({info.language_probability:.0%})")
for segment in segments:
print(f"[{segment.start:.1f}s → {segment.end:.1f}s] {segment.text}")
EOF
whisper.cpp: Für ARM und CPU
Wer eine Apple-Silicon-Mac oder keinen CUDA-Support hat, greift zu whisper.cpp — reines C++, läuft auf Metal (Apple GPU), AVX2 und ARM NEON:
git clone https://github.com/ggerganov/whisper.cpp.git
cd whisper.cpp
# Für Apple Silicon (Metal-Beschleunigung)
make -j WHISPER_METAL=1
# Modell herunterladen (ggml-Format)
bash ./models/download-ggml-model.sh large-v3
# Transkribieren
./main -m models/ggml-large-v3.bin -l de -f aufnahme.wav
Hinweis:
whisper.cpperwartet WAV-Dateien (16kHz, mono). Konvertiere mitffmpeg -i input.mp3 -ar 16000 -ac 1 output.wav.
Text-to-Speech lokal: Stimmen synthetisieren
Piper: Schnell und ressourcenschonend
Piper ist ein lokales TTS-System von der Mozilla Foundation (jetzt open community), das vortrainierte VITS-Modelle nutzt. Es läuft sogar auf einem Raspberry Pi und hat gute deutsche Stimmen:
pip install piper-tts
# Deutsche Stimme herunterladen
# Modelle: https://huggingface.co/rhasspy/piper-voices
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/thorsten/medium/de_DE-thorsten-medium.onnx
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/thorsten/medium/de_DE-thorsten-medium.onnx.json
# Text zu Audio
echo "Hallo Welt, ich bin eine lokale KI-Stimme." | \
piper --model de_DE-thorsten-medium.onnx --output_file ausgabe.wav
# Direkt abspielen (Linux mit aplay)
echo "Noch ein Test." | \
piper --model de_DE-thorsten-medium.onnx --output-raw | \
aplay -r 22050 -f S16_LE -t raw -
Coqui TTS: Mehr Kontrolle, mehr Qualität
Coqui TTS (früher Mozilla TTS) bietet hochwertigere Modelle wie XTTS v2, das sogar Voice-Cloning aus wenigen Sekunden Referenz-Audio ermöglicht:
pip install TTS
# Verfügbare Modelle auflisten
tts --list_models | grep tts_models/de
# Synthese mit deutschem Modell
tts --text "Das ist ein Test der lokalen Sprachsynthese." \
--model_name "tts_models/de/thorsten/tacotron2-DDC" \
--out_path ausgabe.wav
# XTTS v2 mit Stimm-Klonierung (englisch, aber sprachunabhängig)
tts --text "Lokale KI ist beeindruckend." \
--model_name "tts_models/multilingual/multi-dataset/xtts_v2" \
--speaker_wav referenz_stimme.wav \
--language_idx de \
--out_path geklont.wav
Rechtlicher Hinweis: Voice-Cloning mit fremden Stimmen ohne Einwilligung ist in vielen Ländern rechtlich problematisch. Nutze nur eigene Aufnahmen oder lizenzfreie Stimm-Samples.
Audio- und Musikgenerierung: Ein kurzer Überblick
Lokale Musikgenerierung ist noch nicht so ausgereift wie Bildgenerierung, aber es gibt erste praktikable Tools:
- AudioCraft (Meta):
audiocraftauf GitHub — umfasst MusicGen (Text zu Musik) und AudioGen (Text zu Soundeffekten). Läuft lokal mit ~8 GB VRAM für diemedium-Variante. - Stable Audio Open: Stability AIs offenes Modell für Audio-Generierung, über
diffusersnutzbar. - Bark (Suno): Hauptsächlich für expressive TTS mit Emotionen und Soundeffekten, aber auch für kurze Musik-Snippets.
# AudioCraft / MusicGen Beispiel
pip install audiocraft
python3 - <<'EOF'
from audiocraft.models import MusicGen
from audiocraft.data.audio import audio_write
model = MusicGen.get_pretrained("facebook/musicgen-medium")
model.set_generation_params(duration=10) # 10 Sekunden
descriptions = ["upbeat electronic background music, 120 BPM"]
wav = model.generate(descriptions)
audio_write("musik_output", wav[0].cpu(), model.sample_rate, strategy="loudness")
print("Datei gespeichert: musik_output.wav")
EOF
Häufige Fehler
1. CUDA out of memory — auch bei "ausreichend" VRAM
SDXL belegt im Standard-Modus mehr VRAM als erwartet. Lösung: In ComfyUI --lowvram oder --medvram als Startargument übergeben. In Automatic1111 die Einstellung "Medvram" im Webinterface aktivieren. Alternativ: Modell in fp8 statt fp16 laden.
2. Modell lädt, erzeugt aber nur graues Rauschen
Häufig ein VAE-Problem. Lade einen passenden VAE separat herunter und wähle ihn explizit aus (z. B. sdxl_vae.safetensors für SDXL-Checkpoints). Der in manchen Checkpoints eingebettete VAE kann korrupt oder in falschem Format sein.
3. whisper.cpp erzeugt nonsensischen Text bei kurzen Clips
Whisper ist für Audio ab ca. 3–5 Sekunden optimiert. Sehr kurze Clips unter einer Sekunde produzieren Halluzinationen. Füge --no-speech-thold 0.6 hinzu, um Stille besser zu filtern.
4. Piper gibt Audio mit extremem Rauschen aus
Meist ein Sample-Rate-Mismatch. Stelle sicher, dass dein Ausgabegerät oder aplay exakt die im Modell hinterlegte Rate (meist 22050 Hz oder 16000 Hz) verwendet. Die JSON-Konfigurationsdatei neben dem .onnx-Modell enthält den korrekten Wert.
5. Modell-Lizenzen übersehen Flux.1-dev, viele Checkpoints auf CivitAI und XTTS v2 haben keine "tue-was-du-willst"-Lizenzen. Vor dem Produktiveinsatz oder der Weitergabe von generierten Inhalten immer die Lizenzbedingungen prüfen. Flux.1-schnell ist unter Apache 2.0 freier nutzbar.
6. ComfyUI Custom Nodes brechen nach Update
ComfyUI entwickelt sich schnell. Halte ComfyUI-Manager installiert, um Custom Nodes konsistent zu aktualisieren. Vor größeren Updates ein git stash oder Snapshot des venv-Ordners ist sinnvoll.
Nächste Schritte
Du kannst jetzt Bilder, Sprache und Audio lokal generieren — unabhängig von jeder Cloud. Im abschließenden Teil 3: Lokale Agenten & Pipelines schauen wir uns an, wie du diese Bausteine zusammenfügst:
- Lokale Agenten mit LangChain oder LlamaIndex, die Werkzeuge wie Bildgenerierung und Whisper-Transkription automatisch aufrufen
- n8n und Ollama als Self-hosted Automatisierungs-Pipeline
- Multimodale Workflows: Ein LLM beschreibt ein Bild, ein Diffusion-Modell erzeugt es, Piper liest das Ergebnis vor — vollständig lokal
- Ressourcen-Scheduling: Wie du GPU-Zeit sinnvoll aufteilst, wenn mehrere Dienste gleichzeitig laufen
Teil 3 erscheint in Kürze. Bis dahin: Experimentiere mit LoRAs für deinen persönlichen Stil oder trainiere eine eigene Piper-Stimme — beides geht komplett lokal.