28 KiB
28 KiB
KI-Video — Lokale Produktionspipeline
Stand: 16.03.2026
Ziel
Lokale, praktisch nutzbare Produktionsstrecke fuer YouTube-Videos im Commentary-/Erklaerstil. Kein Spielzeug-Demo, kein Forschungsprojekt: Thema rein → fertiges Video raus.
Videoformat
Referenz-Stil: "Geld & Imperien" / "Money & People" (YouTube, geopolitische Commentary-Kanaele) Beispielvideos:
- https://youtu.be/4XfhrrbklbM (24 Min, "Irans Hyperschall-Schlag", Geld & Imperien)
- https://youtu.be/MIkAOwJYaP0 (19 Min, "Irans Machtuebernahme", Money & People)
| Eigenschaft | Beschreibung |
|---|---|
| Typ | Commentary, Erklaervideos, Meinungs-/Analyseformate |
| Laenge | 10-30 Minuten |
| Stil | Professionelle Erzaehlstimme + Bilder + Karten + Infografiken + Text-Overlays + Ken-Burns |
| Avatar | Sprechender KI-Avatar als PiP-Overlay (~20% Bildschirm, unten rechts) |
| Kein | Echte Face-Cam, Realfilm, Hollywood-VFX |
Avatar-Konzept (Picture-in-Picture)
┌─────────────────────────────────────────────────────────┐
│ │
│ HAUPTBILD (80%) │
│ Karten, Infografiken, Szenenbilder │
│ Ken-Burns, Zoom, Ueberblendungen │
│ │
│ │
│ │
│ ┌─────────────┐ │
│ │ │ │
│ │ AVATAR │ │
│ │ (~20%) │ │
│ │ lip-sync │ │
│ │ sprechend │ │
│ └─────────────┘ │
└─────────────────────────────────────────────────────────┘
1920 x 1080 (Full HD)
Avatar-Overlay:
- Groesse: ~384 x 384 px (20% der Bildhoehe)
- Position: unten rechts, 40px Padding
- Hintergrund: halbtransparenter Kreis oder abgerundetes Rechteck
- Inhalt: Sprechende Person (SadTalker) synchron zum Voiceover
- Stil: professionell, Brustbild, neutraler Hintergrund
Der Avatar laeuft DURCHGEHEND waehrend des gesamten Videos. Das Referenzbild fuer SadTalker ist ein einmalig generiertes Portraet (FLUX/SDXL). Die Lippenbewegung wird aus dem XTTS-Voiceover-Audio abgeleitet.
Anatomie eines 20-Min-Videos (Referenz)
| Element | Menge | Beschreibung |
|---|---|---|
| Skript | ~3500-5000 Woerter | Monolog, professioneller Ton, analytisch |
| Szenenbilder | 80-120 Stueck | Karten, Infografiken, Symbolbilder, Illustrationen |
| Hero-Bilder | 10-15 Stueck | Hochwertige Key-Visuals fuer Titelszenen/Kapitelwechsel |
| Text-Overlays | 20-40 Stueck | Zahlen, Namen, Fakten als Einblendung |
| Avatar-Video | 20 Min (durchgehend) | SadTalker lip-sync, PiP unten rechts, ~20% Bildschirm |
| Voiceover | 20 Min Audio | XTTS v2, natuerliche deutsche Maennerstimme |
| Hintergrundmusik | 1-2 Tracks | Ambient, dezent, lizenzfrei |
| Uebergaenge | ~80-120 | Ken-Burns, Ueberblendungen, Zoom-Ins |
Produktions-Pipeline (5 GPUs parallel)
Kernidee: Phase 1 ist seriell (Skript), Phase 2 nutzt alle 5 GPUs parallel, Phase 3 ist Assembly. Das macht aus 3-4 Stunden seriellem Rendern ca. 40-60 Minuten Gesamtzeit.
PHASE 1 — SKRIPT (ki-tower, seriell, ~10-15 Min)
══════════════════════════════════════════════════
Thema + Recherche-Notizen (manuell)
│
▼
Qwen 14B (vLLM, :8401) → Skript (~4000 Woerter, 20 Min Lesezeit)
│
▼
Qwen 14B → Szenenplan: 100 Szenen mit je:
- Bildprompt (EN, fuer FLUX/SDXL)
- Szenentyp (hero / standard / infografik / karte)
- Text-Overlay (falls noetig)
- Geschaetzte Dauer (Sekunden)
│
▼
Skript + Szenenplan als JSON → Orchestrator
PHASE 2a — TTS-VOICEOVER (3080 #0, ~15 Min, startet sofort)
═════════════════════════════════════════════════════════════
Orchestrator schickt Skript-Text an XTTS v2 Worker.
Output: 20 Min deutsches Voiceover als WAV-Datei.
Muss VOR SadTalker fertig sein (Avatar braucht Audio als Input).
PHASE 2b — PARALLEL-PRODUKTION (alle 5 GPUs, ~30-40 Min)
══════════════════════════════════════════════════════════
┌──────────────────────────────────────────────────────────────────┐
│ ORCHESTRATOR (ki-tower CPU) │
│ Verteilt Jobs, pollt Status, sammelt Ergebnisse │
└──────┬──────────┬──────────┬──────────┬──────────┬───────────────┘
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
┌──────────┐┌──────────┐┌──────────┐┌──────────┐┌──────────┐
│ 3090 ││ 3080 #0 ││ 3080 #1 ││ 3080 #2 ││ 3080 #3 │
│ ki-tower ││ Worker ││ Worker ││ Worker ││ Worker │
│ ││ ││ ││ ││ │
│ FLUX.1 ││ SDXL ││ SDXL ││ SadTalker││ ESRGAN │
│ Hero- ││ Standard-││ Standard-││ AVATAR ││ Upscale │
│ Bilder ││ Szenen ││ Szenen ││ lip-sync ││ + Whisper│
│ 15 Stk ││ ~50 Stk ││ ~50 Stk ││ 20 Min ││ Untertit.│
│ ~15 Min ││ ~25 Min ││ ~25 Min ││ ~25 Min ││ ~10 Min │
└──────────┘└──────────┘└──────────┘└──────────┘└──────────┘
Ablauf 3080 #0: XTTS v2 Voiceover (15 Min) → sobald fertig → SDXL Bilder (10 Min)
Ablauf 3080 #2: Wartet auf Voiceover → SadTalker Avatar (25 Min, GPU-intensivster Job)
Alle anderen starten sofort parallel.
Engpass = SadTalker Avatar-Rendering (~25 Min fuer 20 Min Video).
SadTalker-Details:
- Input: Referenz-Portraet (einmalig generiert) + Voiceover-Audio (aus Phase 2a)
- Output: 20 Min Video (384x384 px) mit synchroner Lippenbewegung
- Verarbeitung in ~30s-Clips, sequentiell auf 3080 #2
- ~6 GB VRAM (passt auf 10 GB 3080)
- Laengster Einzeljob → bestimmt Gesamtdauer Phase 2
PHASE 3 — ASSEMBLY + EXPORT (ki-tower, seriell, ~15-20 Min)
════════════════════════════════════════════════════════════
│
▼
FFmpeg: Bilder + Ken-Burns + Zoom + Ueberblendungen → Hintergrund-Video
│
▼
FFmpeg: Avatar-PiP compositen (unten rechts, 384x384, halbtransparenter Rahmen)
│ ┌─────────────────────────────────────────────┐
│ │ Hauptbild (Szene/Karte/Infografik) │
│ │ │
│ │ │
│ │ ┌──────────┐ │
│ │ │ Avatar │ │
│ │ │ lip-sync │ │
│ │ └──────────┘ │
│ └─────────────────────────────────────────────┘
│
▼
FFmpeg: Audio-Mix (Voiceover + Hintergrundmusik + Lautstaerke-Normalisierung)
│
▼
FFmpeg: Text-Overlays (Fakten, Zahlen, Namen) einbrennen
│
▼
FFmpeg: Untertitel (SRT aus Whisper) einbetten
│
▼
NVENC: H.264/H.265 Encoding → fertiges MP4 (1080p)
│
▼
Export: Thumbnail (FLUX hero-Bild, upscaled) + Titel + Description + Tags
Zeitschaetzung: 20-Minuten-Video mit Avatar
| Phase | Dauer | GPUs aktiv | Engpass |
|---|---|---|---|
| 1. Skript + Szenenplan | ~15 Min | 1 (3090) | LLM-Inferenz |
| 2a. TTS-Voiceover | ~15 Min | 1 (3080 #0) | XTTS v2 Inferenz |
| 2b. Parallel-Produktion | ~25 Min | 5 (alle) | SadTalker Avatar |
| 3. Assembly + Export | ~20 Min | 1 (3090 NVENC) | FFmpeg PiP-Compositing |
| Gesamt | ~75 Min |
SadTalker ist jetzt der Engpass (statt Bildgenerierung). 20 Min Lip-Sync-Video auf 3080 = ~25 Min Renderzeit. Zum Vergleich: Seriell auf nur 1 GPU = ~5-6 Stunden.
GPU-Auslastung waehrend Phase 2
| GPU | Schritt 1 | Dauer | Schritt 2 (wenn fertig) | Dauer | Output |
|---|---|---|---|---|---|
| 3090 | FLUX.1-dev Hero-Bilder | ~15 Min | idle / Thumbnail-Varianten | ~5 Min | 15 Key-Visuals |
| 3080 #0 | XTTS v2 Voiceover | ~15 Min | SDXL Restbilder | ~10 Min | 20 Min Audio + ~20 Bilder |
| 3080 #1 | SDXL Standard-Szenen | ~25 Min | — | — | ~50 Szenenbilder |
| 3080 #2 | (wartet auf Audio) | — | SadTalker Avatar | ~25 Min | 20 Min Lip-Sync-Video (384x384) |
| 3080 #3 | Real-ESRGAN Upscaling | ~5 Min | Whisper → SRT | ~5 Min | Upscaled Bilder + Untertitel |
Ablauf-Kette: TTS muss vor SadTalker fertig sein (Audio → Lip-Sync). Deshalb: 3080 #0 macht zuerst TTS, dann SDXL. 3080 #2 wartet auf Audio, dann SadTalker. Alle anderen GPUs starten sofort.
Konkretes Beispiel: "Irans Hyperschall-Schlag" (24 Min)
So wuerde ein Video im Stil von "Geld & Imperien" durch die Pipeline laufen:
INPUT:
Thema: "Irans neue Hyperschallrakete — geopolitische und wirtschaftliche Folgen"
Recherche: 3-4 Quellenlinks, eigene Stichpunkte
PHASE 1 — Qwen 14B generiert:
├── Skript: ~4500 Woerter, 24 Min Lesezeit
│ "Was ich euch heute zeige, veraendert die Welt..."
│ Kapitel: Waffentechnik → Strategie → Oel → Europa → Fazit
│
└── Szenenplan (JSON): 105 Szenen
Szene 001: { typ: "hero", prompt: "dramatic missile launch, night sky, photorealistic",
overlay: "Mach 15 — Irans Hyperschallwaffe", dauer: 8s }
Szene 002: { typ: "karte", prompt: "middle east map, iran highlighted, military bases marked",
overlay: null, dauer: 12s }
Szene 003: { typ: "standard", prompt: "patriot missile defense system, desert, realistic photo",
overlay: "Patriot-System: $3 Mio pro Abfangrakete", dauer: 10s }
...
Szene 105: { typ: "hero", prompt: "world map with shifting power balance, dramatic lighting",
overlay: "Die neue Weltordnung", dauer: 15s }
PHASE 2a — TTS zuerst (3080 #0, 15 Min):
3080 #0: XTTS v2 → 24 Min deutsches Voiceover (WAV)
PHASE 2b — Alles parallel (alle 5 GPUs, 25 Min):
3090: 15 Hero-Bilder (FLUX.1-dev) → Titel, Kapitelwechsel, Outro
3080 #0: (TTS fertig) → 30 Standardbilder (SDXL) → Militaer, Wirtschaft
3080 #1: 50 Standardbilder (SDXL) → Karten, Infografiken, Symbolbilder
3080 #2: SadTalker → 24 Min Avatar-Video (384x384, lip-sync aus Voiceover)
3080 #3: Upscaling aller Bilder auf 1920x1080 + Whisper → Untertitel-SRT
PHASE 3 — Assembly (20 Min):
FFmpeg: 105 Szenen × Ken-Burns/Zoom → Hintergrund-Videospur
FFmpeg: Avatar-PiP compositen (unten rechts, 20%, halbtransparenter Rahmen)
FFmpeg: Audio-Mix (Voiceover + Ambient-Musik)
FFmpeg: Text-Overlays + Untertitel einbrennen
NVENC: H.265 Encoding
Output: "irans-hyperschall-2026-03.mp4" (1080p, ~1.5 GB)
Bonus: Thumbnail + YouTube-Description + Tags
Gesamtzeit: ~75 Minuten fuer ein 24-Minuten-Video mit sprechendem Avatar. Fertig zum Hochladen.
Hardware
ki-tower — Hauptmaschine (Muldenstein, geplant)
| Eigenschaft | Wert |
|---|---|
| CPU | AMD Ryzen 7 7700 (8C/16T) |
| RAM | 64 GB DDR5 |
| GPU | NVIDIA RTX 3090 (24 GB VRAM) |
| Storage | 1 TB NVMe |
| OS | Debian 12 + Docker + CUDA |
| Logischer Name | ki-tower |
| Rolle | Chef. Alle schweren Aufgaben, Orchestrierung, Hauptpfad. |
gpu-worker — NVIDIA-Rig (Muldenstein, geplant) — PRIMAERER WORKER
| Eigenschaft | Wert |
|---|---|
| GPUs | 4x NVIDIA RTX 3080 (je 10 GB GDDR6X, PCIe 4.0 x16) |
| CUDA | Voll unterstuetzt, identischer Stack wie ki-tower |
| OS | Debian 12 + Docker + CUDA |
| Logischer Name | gpu-worker |
| Rolle | Produktiver Worker-Pool. CUDA-nativ, kein Workaround noetig. |
| Vorteil | Selber Code wie auf der 3090 — kein Portierungsaufwand. |
gpu-reserve — AMD-Rig (Muldenstein, Reserve)
| Eigenschaft | Wert |
|---|---|
| GPUs | 8x AMD RX 6600 XT Dual (je 8 GB GDDR6, PCIe 4.0 x8) |
| ROCm | Inoffiziell (gfx1032, Workaround noetig) |
| Logischer Name | gpu-reserve |
| Rolle | Reserve/Nebenrolle. Nur Whisper + CPU-Batch wenn 3080-Rig ausgelastet. |
| Status | Zurueckgestellt. Entscheidung nach 3080-Rig-Aufbau. Alternative: verkaufen. |
Rollenverteilung — Was laeuft wo
ki-tower (RTX 3090) — Hauptpfad
| Aufgabe | Modell | VRAM | Anmerkung |
|---|---|---|---|
| Skripte | Qwen 2.5 14B (Q5) | ~12 GB | Default. 32B nur wenn 14B nachweislich nicht reicht. |
| Hero-Bilder | FLUX.1-dev | ~12 GB | Hochwertige Key-Visuals (Kapitelwechsel, Titel, Outro) |
| Compositing | FFmpeg | CPU | Ken-Burns + Avatar-PiP + Overlays + Audio-Mix |
| Encoding | FFmpeg + NVENC | ~1 GB | Hardware-beschleunigt |
| Orchestrator | Python | CPU | Steuert alle Schritte, verteilt Jobs an Worker |
Auf der 3090 nur: LLM + FLUX + Assembly. Keine TTS, kein Avatar — das machen die 3080er.
gpu-worker (4x RTX 3080) — Produktive Worker-Jobs
| 3080 | Primaeraufgabe | VRAM | Sekundaeraufgabe | Anmerkung |
|---|---|---|---|---|
| #0 | XTTS v2 (Voiceover) | ~4 GB | → SDXL Restbilder (~7 GB) | TTS zuerst, dann Bilder |
| #1 | SDXL (Standard-Szenen) | ~7 GB | — | Bildgenerierung durchgehend |
| #2 | SadTalker (Avatar) | ~6 GB | — | Lip-Sync, laengster Job, wartet auf Audio |
| #3 | Real-ESRGAN + Whisper | ~3 GB | Thumbnail-Varianten | Upscaling + Untertitel |
Feste Zuordnung pro Video-Produktion. Kein dynamisches Scheduling. Kernvorteil: Identischer CUDA-Stack wie ki-tower.
gpu-reserve (8x RX 6600 XT) — Reserve/Nebenrolle
| Aufgabe | VRAM | Karten | Anmerkung |
|---|---|---|---|
| Whisper (whisper.cpp) | ~1.5 GB | 1-2 | Einziger gut getesteter AMD-Usecase |
| CPU-Batch-Jobs | — | — | Piper TTS, FFmpeg, Text-Vorverarbeitung |
Realistisch nutzbar: 1-2 Karten fuer Whisper, Rest bringt kaum Mehrwert. Empfehlung: Erst aufbauen wenn 3080-Rig voll ausgelastet. Alternative: verkaufen.
NICHT auf das AMD-Rig
| Aufgabe | Warum nicht |
|---|---|
| SDXL / Bildgenerierung | ROCm inoffiziell, CUDA-Version laeuft auf 3080 besser |
| XTTS v2 | PyTorch + ROCm ungetestet, auf 3080 CUDA-nativ |
| SadTalker | CUDA-only |
| Qwen / LLMs | PyTorch + ROCm + Textgen = Frust auf inoffizieller HW |
| Irgendwas Produktionskritisches | Workaround-basierte HW darf Produktion nicht blockieren |
Hardware-Priorisierung: 3080 vs. 6600 XT
Klare Rangfolge:
| Rang | Hardware | Rolle | Begruendung |
|---|---|---|---|
| 1 | RTX 3090 (ki-tower) | Chef | 24 GB VRAM, schwere Modelle, Orchestrierung |
| 2 | 4x RTX 3080 (gpu-worker) | Produktiver Worker | CUDA-nativ = selber Code wie ki-tower. 10 GB VRAM pro Karte reicht fuer SDXL, XTTS, SadTalker, Whisper. Kein Portierungsaufwand. |
| 3 | 8x RX 6600 XT (gpu-reserve) | Reserve / ggf. verkaufen | ROCm inoffiziell. Jeder Usecase, den die 6600 XT kann, kann die 3080 besser + einfacher. Einziger Vorteil: Kartenanzahl fuer massiv-paralleles Whisper. Realistisch nicht gebraucht. |
Warum 4x 3080 > 8x 6600 XT:
- Gleicher Software-Stack wie ki-tower (CUDA). Code einmal schreiben, ueberall deployen.
- 10 GB VRAM vs. 8 GB VRAM. Klingt wenig, macht bei SDXL/SadTalker den Unterschied.
- PyTorch + CUDA ist getestet, stabil, dokumentiert. ROCm auf Navi 23 ist Kampf.
- Weniger Karten = weniger Strom, weniger Kuehlung, weniger moegliche Fehlerquellen.
- 4 parallele CUDA-Worker decken den gesamten Bedarf ab.
Empfehlung AMD-Rig: Nicht aktiv aufbauen. Falls 3080-Rig irgendwann an Kapazitaetsgrenzen stoesst: 1-Karten-Test mit Whisper. Wenn selbst das nicht lohnt: verkaufen und in NVMe-Storage oder RAM investieren.
Worker-Architektur
ki-tower (3090, Chef) gpu-worker (4x 3080, Worker) gpu-reserve (RX 6600 XT)
┌─────────────────────────┐ ┌──────────────────────────────┐ ┌──────────────────┐
│ Orchestrator (Python) │ │ Debian 12 + Docker + CUDA │ │ Reserve/Whisper │
│ ├── Job Queue (SQLite) │ Tailscale │ │
│ ├── /api/submit-job │◄────────────►│ GPU #0: xtts+sdxl :8501 │ │ Whisper :8601 │
│ ├── /api/job-status │ │ GPU #1: sdxl-worker :8502 │ │ CPU-Batch :8602 │
│ └── /api/get-result │ Tailscale │ GPU #2: sadtalker :8503 │ │ (nur bei Bedarf)│
│ │ │ GPU #3: esrgan+whisper :8504 │ └──────────────────┘
│ Qwen 14B (vLLM) :8401 │ │ │
│ FLUX.1 (ComfyUI):8402 │ │ 10 GB VRAM pro Karte │
│ FFmpeg (lokal) │ │ CUDA-nativ, kein Workaround │
└─────────────────────────┘ └──────────────────────────────┘
Prinzipien:
- 1 Container = 1 GPU = 1 Aufgabe. Feste Zuordnung, kein dynamisches Scheduling.
- SQLite als Job-Queue. Ein User, nicht tausend. Eine Datei reicht.
- HTTP-APIs pro Worker. Orchestrator ruft per REST auf, pollt Status.
- Kein Service-Mesh, kein Kubernetes. Tailscale verbindet die zwei Maschinen.
VRAM-Budget (ki-tower, sequentiell)
Schritt 1: Skript → Qwen 14B → ~12 GB VRAM
Schritt 2: Bilder → FLUX.1-dev → ~12 GB VRAM
Schritt 3: TTS → Piper (CPU) → 0 GB VRAM
Schritt 4: Compositing → FFmpeg (CPU) → 0 GB VRAM
Schritt 5: Encoding → NVENC → ~1 GB VRAM
Mit Qwen 14B statt 32B: kein VRAM-Flush zwischen Schritt 1 und 2 noetig.
Geschaetzte Produktionszeit:
- v1 (nur ki-tower, seriell, ohne Avatar): ~2-3 Stunden pro 10-Min-Video
- v1.5 (5 GPUs parallel, mit Avatar): ~75 Min pro 20-Min-Video
- Langfristig mit Optimierung: ~60 Min pro 20-Min-Video
Nicht-Ziele
- Kein Forschungsprojekt
- Keine Bastelwiese ohne Ergebnis
- Keine Dauerabhaengigkeit von Cloud-Abos
- Keine Architektur die nur auf dem Papier funktioniert
- Keine ueberkomplizierte Proxmox-/VM-Orgie auf dem Rig
- Kein Schoenreden von AMD-ROCm-Limitierungen
v1 — Minimal Viable Pipeline (nur ki-tower)
v1 beweist: die Pipeline funktioniert auf einer Maschine. Schritte manuell anstossen.
v1 Pipeline (alles auf ki-tower, seriell):
Thema (manuell)
│
▼
Qwen 14B → Skript + Szenenplan (vLLM, :8401)
│
▼
FLUX.1-dev → 30-50 Bilder (ComfyUI, :8402) ← seriell, ~30-45 Min
│
▼
Piper TTS → Voiceover (CPU, :8504) ← parallel moeglich
│
▼
FFmpeg → Ken-Burns + Audio + Overlays → fertiges MP4
Was v1 NICHT hat:
- Kein 3080 Worker-Rig (alles seriell auf 3090)
- Keinen Avatar
- Keine XTTS v2 (Piper reicht fuer v1)
- Keine automatische Orchestrierung
- Geschaetzte Produktionszeit: ~2-3 Stunden pro 10-Min-Video
Erfolgskriterium v1: Ein 10-Minuten-Video komplett lokal produziert.
v1.5 — 5-GPU-Parallelisierung + Avatar (ki-tower + 3080-Rig)
v1.5 ist der grosse Sprung: 5 GPUs parallel + sprechender Avatar.
v1.5 Pipeline (5 GPUs parallel, mit Avatar):
Thema (manuell)
│
▼
Qwen 14B → Skript + Szenenplan JSON (ki-tower)
│
▼
Orchestrator Phase 2a (TTS zuerst):
└── 3080 #0: XTTS v2 → 20 Min deutsches Voiceover (WAV)
│
▼
Orchestrator Phase 2b (alle 5 GPUs parallel):
├── 3090: FLUX.1-dev → Hero-Bilder
├── 3080 #0: (TTS fertig) → SDXL Restbilder
├── 3080 #1: SDXL → Standard-Szenen
├── 3080 #2: SadTalker → 20 Min Avatar-Video (lip-sync, 384x384)
└── 3080 #3: Real-ESRGAN + Whisper → Upscaling + Untertitel
│
▼
FFmpeg → Assembly:
├── Hintergrund: Bilder + Ken-Burns + Zoom
├── Avatar-PiP: unten rechts, ~20% Bildschirm, halbtransparenter Rahmen
├── Audio-Mix: Voiceover + Hintergrundmusik
├── Text-Overlays + Untertitel
└── NVENC Export → MP4 + Thumbnail + YouTube-Metadaten
Was v1.5 bringt:
- Sprechender Avatar als PiP durchgehend im Video (~20% Bildschirm)
- XTTS v2 statt Piper (natuerlichere Stimme, Voice-Cloning)
- Produktionszeit: ~75 Min statt ~5-6 Stunden fuer 20-Min-Video
- Automatische Untertitel
- Orchestrator verteilt und sammelt automatisch
Erfolgskriterium v1.5: 20-Min-Video mit Avatar in unter 90 Minuten produziert.
Avatar-Referenzbild (einmalig)
Das Portraet fuer SadTalker wird EINMAL generiert und dann fuer alle Videos wiederverwendet. So entsteht ein konsistenter "Sprecher" / "Moderator" fuer den Kanal.
Generierung (einmalig, auf 3090 mit FLUX.1-dev):
Prompt: "professional male news anchor, german, mid-30s, neutral expression,
chest up portrait, clean studio background, photorealistic, 8k"
Output: referenz-avatar.png (512x512)
Nachbearbeitung: ggf. manuelles Feintuning in GIMP/Photoshop
SadTalker nutzt dann:
- referenz-avatar.png (festes Bild)
- voiceover.wav (pro Video neu)
→ Output: avatar-video.mp4 (384x384, 25fps, lip-sync)
v2 — Erweiterungen (nach funktionierender v1.5)
| Feature | Abhaengigkeit |
|---|---|
| Avatar-Varianten | Verschiedene Gesichtsausdruecke/Posen je Szene |
| Mehrere Sprecher | Zweiter Avatar fuer Interview-/Dialog-Format |
| Qwen 32B statt 14B | Nur wenn 14B-Skripte nachweislich zu schwach |
| Batch-Produktion | Mehrere Videos in Queue, automatisch nacheinander |
| YouTube-Upload-API | Automatischer Upload mit Metadaten |
v3+ — Spaeter
| Feature | Anmerkung |
|---|---|
| YouTube-Upload-Automation | Manueller Upload = 2 Klicks. Lohnt erst bei >3 Videos/Woche |
| Multi-User / geklonte Instanzen | Erst ein funktionierendes Produkt haben |
| Prompt-Templates Bibliothek | Waechst organisch mit der Produktion |
| Research-Hub-Integration | Themenvorschlaege automatisch aus RSS/News |
Umsetzungsreihenfolge
PHASE 1 — ki-tower Grundinstallation (Woche 1-2)
├── Debian 12 + NVIDIA-Treiber + CUDA 12 + Docker
├── vLLM + Qwen 2.5 14B → erster Skript-Test
└── Ergebnis: "Ich kann lokal ein Skript generieren"
PHASE 2 — Bildgenerierung (Woche 3-4)
├── ComfyUI + FLUX.1-dev in Docker
├── Workflow: Skript-Szene → Bildprompt → Bild
└── Ergebnis: "Ich kann passende Bilder zu einem Skript erzeugen"
PHASE 3 — TTS + Assembly (Woche 5)
├── Piper TTS in Docker (CPU)
├── FFmpeg-Pipeline: Bilder + Audio → Video mit Ken-Burns
└── Ergebnis: "Erstes komplettes Video, lokal produziert"
PHASE 4 — Polieren + erstes echtes Video (Woche 6)
├── Prompt-Templates fuer Skripte verfeinern
├── FFmpeg-Presets fuer verschiedene Szenentypen
├── Erstes Video auf YouTube hochladen
└── Ergebnis: "v1 steht und produziert"
PHASE 5 — 3080-Rig Aufbau + v1.5 mit Avatar (Woche 7-10)
├── Debian 12 + NVIDIA-Treiber + CUDA + Docker (selber Stack wie ki-tower)
├── 4 Worker: XTTS+SDXL, SDXL, SadTalker, ESRGAN+Whisper
├── Tailscale + Job-API anbinden
├── SadTalker Avatar einrichten:
│ ├── Referenz-Portraet generieren (FLUX auf 3090)
│ ├── SadTalker Docker-Container auf 3080 #2
│ ├── Lip-Sync Pipeline: Audio → 30s-Clips → zusammenfuegen
│ └── Test: 5-Min-Testvideo mit Avatar-PiP
├── XTTS v2 statt Piper (bessere Stimme, Voice-Cloning)
├── FFmpeg PiP-Compositing: Avatar unten rechts, ~20% Bildschirm
├── Python-Orchestrator: TTS → SadTalker → Bilder → Assembly
└── Ergebnis: "20-Min-Video mit Avatar in unter 90 Min, 5 GPUs parallel"
PHASE 6 — v2 Features (nach stabiler v1.5-Produktion)
├── Avatar-Varianten: verschiedene Ausdruecke/Posen je Kapitel
├── Automatische Thumbnail-Generierung (FLUX hero + Text-Overlay)
├── YouTube-Metadaten-Generator (Titel, Description, Tags aus Skript)
├── Batch-Produktion: mehrere Videos in Queue
└── Ergebnis: "Semi-automatische Videoproduktion mit Worker-Pool"
PHASE 7 — AMD-Rig Entscheidung (optional, spaeter)
├── Bewertung ob 3080-Rig Kapazitaet reicht
├── Falls nicht: 1-Karten-Test mit RX 6600 XT + Whisper
├── Falls ja: AMD-Rig verkaufen, Erloese in Storage investieren
└── Ergebnis: "Klare Entscheidung ueber AMD-Hardware"
Entscheidungen (getroffen)
| Frage | Entscheidung | Begruendung |
|---|---|---|
| OS ki-tower | Debian 12 | Einfacher fuer GPU, Docker, kein Hypervisor-Overhead |
| OS gpu-worker | Debian 12 | Identisch mit ki-tower, CUDA-nativ, kein Sonderweg |
| Worker-Rig | 4x RTX 3080 | CUDA-nativ > 8x RX 6600 XT mit ROCm-Workarounds |
| LLM-Modell | Qwen 14B (Default) | 12 GB VRAM, laesst Platz. 32B nur als Upgrade. |
| LLM-Server | vLLM | Schneller als llama.cpp bei Batch, Model-Unloading |
| Bildgenerierung | ComfyUI + FLUX.1-dev | Flexibel, Workflow-basiert, gute Qualitaet |
| TTS v1 | Piper TTS (CPU) | Kein GPU-Verbrauch, sofort einsatzbereit |
| TTS v2 | XTTS v2 (3090 oder 3080) | Voice-Cloning, natuerlichere Stimme. 4 GB VRAM, passt auf 3080. |
| Avatar | SadTalker, ab v1.5 | PiP ~20% unten rechts, durchgehend im Video. Kernbestandteil. |
| Job-Queue | SQLite | Ein User, kein Redis/RabbitMQ noetig |
| Netzwerk | Tailscale | Verbindet ki-tower + gpu-worker, fertig |
Risiken
| # | Risiko | Wahrscheinlichkeit | Impact | Mitigation |
|---|---|---|---|---|
| 1 | ROCm auf RX 6600 XT instabil | Hoch | Niedrig | Betrifft nur Reserve-Rig. 3080-Worker ist CUDA-nativ. |
| 2 | Piper TTS deutsch zu robotisch | Mittel | Mittel | v1-only-Problem. XTTS v2 ab v1.5 loest das. OpenAI TTS als Bruecke (~0.50€/Video). |
| 3 | VRAM-Tetris auf 3090 | Mittel | Mittel | 14B statt 32B. Sequentiell. vLLM Model-Unloading. |
| 4 | Pipeline wird zu komplex vor v1 | Hoch | Hoch | v1 brutal einfach. Bash-Scripts, keine Frameworks. |
| 5 | SadTalker Qualitaet/Artefakte | Mittel | Hoch | Avatar ist Kernbestandteil. Wenn Lip-Sync schlecht: LivePortrait oder Wav2Lip als Alternative testen. Fallback: Avatar nur bei Kapitelwechseln (5-10% Screentime statt durchgehend). |
| 6 | SadTalker Renderzeit 20+ Min | Mittel | Mittel | 30s-Clips parallel auf 2 GPUs verteilen wenn noetig. Oder Resolution reduzieren (256x256). |
| 7 | Stromkosten Rig vs. Nutzen | Mittel | Niedrig | 3080-Rig nur bei Batch-Jobs einschalten. AMD-Rig im Zweifel verkaufen. |
Kosten-Schaetzung
| Posten | Einmalig | Monatlich |
|---|---|---|
| ki-tower Hardware | vorhanden | — |
| gpu-worker Hardware | vorhanden | — |
| Strom ki-tower (24/7) | — | ~30-40 EUR |
| Strom gpu-worker (bei Bedarf) | — | ~10-30 EUR (nicht 24/7) |
| Cloud-APIs (Fallback TTS) | — | ~5-10 EUR |
| Gesamt | 0 EUR | ~45-80 EUR |
Zum Vergleich: Vollstaendig cloud-basierte Videoproduktion (Runway, ElevenLabs, GPT-4) = 100-300 EUR/Monat.