828 lines
40 KiB
Markdown
828 lines
40 KiB
Markdown
# 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 = Cloud-LLM (Skript), Phase 2 = alle 5 lokale GPUs parallel, Phase 3 = Assembly.**
|
||
Skriptqualitaet ist der Flaschenhals — deshalb Cloud-LLM fuer Kreativarbeit, lokale GPUs fuer Massenproduktion.
|
||
|
||
```
|
||
PHASE 1 — SKRIPT + SZENENPLAN (~15-30 Min, Cloud + lokal)
|
||
═════════════════════════════════════════════════════════
|
||
Thema + Recherche-Notizen (manuell)
|
||
│
|
||
▼
|
||
GPT-5.4 (OpenAI API) → Skript (~4000 Woerter, 20 Min Lesezeit)
|
||
│ Persoenlichkeit, Meinung, Storytelling, Stil
|
||
│ Kosten: ~0.10-0.50 EUR pro Skript
|
||
│
|
||
▼
|
||
Menschliches Review (~20-30 Min) → Korrektur, Feinschliff, Faktencheck
|
||
│
|
||
▼
|
||
Qwen 14B (lokal, vLLM, :8401) → Szenenplan aus fertigem Skript:
|
||
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
|
||
|
||
Warum hybrid?
|
||
- GPT-5.4 fuer Skripte: beste Qualitaet, Persoenlichkeit, deutsche Sprache auf Top-Niveau
|
||
- Qwen 14B lokal fuer Szenenplan: strukturierte JSON-Generierung, braucht keine Kreativitaet
|
||
- Kein Vendor-Lock: Skript kann auch mit Claude, Gemini o.ae. generiert werden
|
||
- Kosten pro Video: ~0.10-0.50 EUR (irrelevant vs. Stromkosten der GPUs)
|
||
|
||
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 — Skript + Szenenplan:
|
||
├── GPT-5.4 (Cloud): Skript ~4500 Woerter, 24 Min Lesezeit
|
||
│ "Was ich euch heute zeige, veraendert die Welt..."
|
||
│ Kapitel: Waffentechnik → Strategie → Oel → Europa → Fazit
|
||
│ → Mensch reviewt und korrigiert (~20 Min)
|
||
│
|
||
└── Qwen 14B (lokal): Szenenplan (JSON) aus fertigem Skript: 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
|
||
|
||
### Cloud — Skript-Generierung
|
||
|
||
| Aufgabe | Modell | Kosten | Anmerkung |
|
||
|---|---|---|---|
|
||
| **Skripte** | GPT-5.4 (OpenAI API) | ~0.10-0.50 EUR/Skript | Persoenlichkeit, Storytelling, Meinung |
|
||
|
||
Skriptqualitaet ist der Flaschenhals. Kein lokales Modell kommt an GPT-5.4 ran fuer
|
||
kreatives, meinungsstarkes, deutsches Storytelling. Cloud-Kosten sind vernachlaessigbar.
|
||
|
||
### ki-tower (RTX 3090) — Hauptpfad
|
||
|
||
| Aufgabe | Modell | VRAM | Anmerkung |
|
||
|---|---|---|---|
|
||
| **Szenenplan** | Qwen 2.5 14B (Q5) | ~12 GB | Strukturiertes JSON aus fertigem Skript. Braucht keine Kreativitaet. |
|
||
| **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 |
|
||
|
||
3090 macht NUR: Szenenplan (Qwen) + Hero-Bilder (FLUX) + Assembly.
|
||
Skripte kommen fertig aus der Cloud. TTS + Avatar 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.
|
||
|
||
## Produktions-Datenbank + Orchestrierung
|
||
|
||
Zentrale Steuerung: **eine SQLite-Datei** (`production.db`) auf ki-tower.
|
||
Alles passiert hier: Kanaele, Videos, Szenen, Jobs, Assets, Status.
|
||
|
||
### Datenbank-Schema
|
||
|
||
```sql
|
||
-- Kanaele (je einer pro YouTube-Kanal)
|
||
CREATE TABLE channels (
|
||
id INTEGER PRIMARY KEY,
|
||
name TEXT NOT NULL, -- "Geld & Imperien Stil"
|
||
slug TEXT UNIQUE NOT NULL, -- "kanal-a"
|
||
avatar_path TEXT NOT NULL, -- "/data/channels/kanal-a/avatar.png"
|
||
voice_path TEXT NOT NULL, -- "/data/channels/kanal-a/voice-sample.wav"
|
||
style TEXT NOT NULL, -- "pip_20" oder "fullscreen"
|
||
prompt_template TEXT, -- System-Prompt fuer GPT-5.4 Skripte (Ton, Stil, Persoenlichkeit)
|
||
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
|
||
);
|
||
|
||
-- Videos (ein Eintrag pro Video)
|
||
CREATE TABLE videos (
|
||
id INTEGER PRIMARY KEY,
|
||
channel_id INTEGER REFERENCES channels(id),
|
||
title TEXT NOT NULL, -- "Irans Hyperschall-Schlag"
|
||
topic TEXT, -- Thema + Recherche-Notizen
|
||
status TEXT DEFAULT 'draft', -- draft → script → scenes → producing → assembly → review → published
|
||
script TEXT, -- Fertiges Skript (aus GPT-5.4 + Review)
|
||
scene_plan TEXT, -- JSON: Szenenplan (aus Qwen 14B)
|
||
voiceover_path TEXT, -- Pfad zur fertigen WAV
|
||
avatar_path TEXT, -- Pfad zum fertigen Avatar-Video
|
||
subtitle_path TEXT, -- Pfad zur SRT-Datei
|
||
final_path TEXT, -- Pfad zum fertigen MP4
|
||
thumbnail_path TEXT, -- Pfad zum Thumbnail
|
||
yt_title TEXT, -- YouTube-Titel
|
||
yt_description TEXT, -- YouTube-Description
|
||
yt_tags TEXT, -- YouTube-Tags (JSON array)
|
||
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
published_at DATETIME
|
||
);
|
||
|
||
-- Szenen (aus dem Szenenplan, je eine Zeile pro Szene)
|
||
CREATE TABLE scenes (
|
||
id INTEGER PRIMARY KEY,
|
||
video_id INTEGER REFERENCES videos(id),
|
||
scene_nr INTEGER NOT NULL,
|
||
scene_type TEXT NOT NULL, -- "hero", "standard", "karte", "infografik"
|
||
prompt TEXT NOT NULL, -- Bildprompt (EN)
|
||
overlay TEXT, -- Text-Overlay (oder NULL)
|
||
duration_s REAL NOT NULL, -- Geschaetzte Dauer in Sekunden
|
||
image_path TEXT, -- Pfad zum generierten Bild (nach Produktion)
|
||
upscaled BOOLEAN DEFAULT 0,
|
||
status TEXT DEFAULT 'pending' -- pending → generating → done → failed
|
||
);
|
||
|
||
-- GPU-Jobs (jede Aufgabe die ein Worker erledigt)
|
||
CREATE TABLE jobs (
|
||
id INTEGER PRIMARY KEY,
|
||
video_id INTEGER REFERENCES videos(id),
|
||
job_type TEXT NOT NULL, -- "tts", "sdxl", "flux", "sadtalker", "whisper", "esrgan", "assembly"
|
||
gpu TEXT, -- "3090", "3080_0", "3080_1", "3080_2", "3080_3"
|
||
status TEXT DEFAULT 'queued', -- queued → running → done → failed → retry
|
||
input_data TEXT, -- JSON: was der Worker braucht
|
||
output_path TEXT, -- Pfad zum Ergebnis
|
||
error TEXT, -- Fehlermeldung falls failed
|
||
queued_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
started_at DATETIME,
|
||
finished_at DATETIME
|
||
);
|
||
```
|
||
|
||
### Verzeichnisstruktur
|
||
|
||
```
|
||
/data/ki-video/
|
||
├── production.db # SQLite — zentrale Steuerung
|
||
│
|
||
├── channels/ # Pro Kanal
|
||
│ ├── kanal-a/
|
||
│ │ ├── avatar.png # Referenz-Portraet (FLUX-generiert)
|
||
│ │ ├── voice-sample.wav # XTTS Voice-Cloning Referenz (~30s)
|
||
│ │ ├── style.json # { "avatar": "pip_20", "position": "bottom_right" }
|
||
│ │ └── prompt.md # GPT-5.4 System-Prompt (Persoenlichkeit, Ton, Stil)
|
||
│ └── kanal-b/
|
||
│ ├── avatar.png # Anderes Gesicht
|
||
│ ├── voice-sample.wav # Andere Stimme
|
||
│ ├── style.json # { "avatar": "fullscreen" }
|
||
│ └── prompt.md # Anderer Stil/Persoenlichkeit
|
||
│
|
||
├── videos/ # Pro Video ein Ordner
|
||
│ ├── 2026-03-16-iran-hyperschall/
|
||
│ │ ├── script.md # Fertiges Skript
|
||
│ │ ├── scenes.json # Szenenplan
|
||
│ │ ├── images/
|
||
│ │ │ ├── hero-001.png
|
||
│ │ │ ├── scene-002.png
|
||
│ │ │ ├── scene-003.png
|
||
│ │ │ └── ... # 80-120 Bilder
|
||
│ │ ├── audio/
|
||
│ │ │ ├── voiceover.wav # XTTS v2 Output
|
||
│ │ │ └── music.mp3 # Hintergrundmusik
|
||
│ │ ├── avatar/
|
||
│ │ │ ├── clip-001.mp4 # SadTalker 30s-Clips
|
||
│ │ │ ├── clip-002.mp4
|
||
│ │ │ └── full.mp4 # Zusammengefuegt
|
||
│ │ ├── subtitles.srt # Whisper → SRT
|
||
│ │ ├── thumbnail.png # FLUX hero + Text
|
||
│ │ └── final.mp4 # FERTIGES VIDEO
|
||
│ └── 2026-03-18-oelpreis-analyse/
|
||
│ └── ...
|
||
│
|
||
└── templates/
|
||
├── ffmpeg-pip20.sh # FFmpeg-Preset: 20% Avatar unten rechts
|
||
├── ffmpeg-fullscreen.sh # FFmpeg-Preset: 100% Avatar
|
||
├── ffmpeg-kenburns.sh # Ken-Burns-Effekt Presets
|
||
└── music/ # Lizenzfreie Hintergrundmusik
|
||
├── ambient-01.mp3
|
||
└── ambient-02.mp3
|
||
```
|
||
|
||
### Produktions-Ablauf (Statusmaschine)
|
||
|
||
```
|
||
┌──────────────────────────────────────────────────┐
|
||
│ │
|
||
┌─────────┐ │ ┌──────────┐ ┌──────────┐ ┌───────────┐ │
|
||
│ draft │──────┼─►│ script │───►│ scenes │───►│ producing │ │
|
||
│ │ │ │ │ │ │ │ │ │
|
||
│ Thema │ │ │ GPT-5.4 │ │ Qwen 14B │ │ 5 GPUs │ │
|
||
│ anlegen │ │ │ + Review │ │ Szenen- │ │ parallel │ │
|
||
└─────────┘ │ └──────────┘ │ plan │ └─────┬─────┘ │
|
||
│ └──────────┘ │ │
|
||
│ ▼ │
|
||
│ ┌───────────┐ ┌──────────┐ ┌──────────┐ │
|
||
│ │ published │◄───│ review │◄──│ assembly │ │
|
||
│ │ │ │ │ │ │ │
|
||
│ │ YouTube │ │ Mensch │ │ FFmpeg │ │
|
||
│ │ Upload │ │ schaut │ │ PiP/Full │ │
|
||
│ └───────────┘ └──────────┘ └──────────┘ │
|
||
│ │
|
||
└──────────────────────────────────────────────────┘
|
||
|
||
Status-Uebergaenge:
|
||
draft → script : Mensch gibt Thema ein, startet GPT-5.4 Skript
|
||
script → scenes : Mensch reviewt Skript, bestaetigt, Qwen generiert Szenenplan
|
||
scenes → producing : Orchestrator erstellt Jobs fuer alle 5 GPUs
|
||
producing → assembly : Alle GPU-Jobs fertig (TTS + Avatar + Bilder + Untertitel)
|
||
assembly → review : FFmpeg Assembly fertig, Video liegt als MP4 vor
|
||
review → published : Mensch schaut Video, gibt frei, Upload
|
||
```
|
||
|
||
### Orchestrator-Logik (Python, laeuft auf ki-tower)
|
||
|
||
```
|
||
Alle 10 Sekunden:
|
||
1. Checke videos WHERE status = 'scenes'
|
||
→ Erstelle GPU-Jobs:
|
||
- 1x TTS-Job (3080 #0)
|
||
- N x SDXL-Jobs (3080 #0 nach TTS, #1)
|
||
- M x FLUX-Jobs (3090, nur hero-Szenen)
|
||
- 1x Whisper-Job (3080 #3, nach TTS)
|
||
- 1x ESRGAN-Job (3080 #3, nach Bilder)
|
||
- 1x SadTalker-Job (3080 #2, nach TTS)
|
||
|
||
2. Checke jobs WHERE status = 'queued'
|
||
→ Pruefe ob Abhaengigkeiten erfuellt:
|
||
- SadTalker wartet auf TTS (voiceover.wav muss existieren)
|
||
- Whisper wartet auf TTS
|
||
- ESRGAN wartet auf Bilder
|
||
→ Sende an Worker via HTTP REST
|
||
|
||
3. Checke jobs WHERE status = 'running'
|
||
→ Polle Worker-Status
|
||
→ Bei done: speichere output_path, update status
|
||
→ Bei failed: retry (max 3x), dann menschliche Aufmerksamkeit
|
||
|
||
4. Checke videos WHERE status = 'producing'
|
||
AND alle zugehoerigen jobs.status = 'done'
|
||
→ Starte Assembly-Job (FFmpeg)
|
||
→ Status → 'assembly'
|
||
|
||
5. Checke videos WHERE status = 'assembly'
|
||
AND assembly-job.status = 'done'
|
||
→ Status → 'review'
|
||
→ Benachrichtigung an Telegram (Hausmeister-Bot!)
|
||
```
|
||
|
||
### CLI fuer den Alltag
|
||
|
||
```bash
|
||
# Neues Video anlegen
|
||
./produce.py new --channel kanal-a --topic "Irans Hyperschall-Schlag"
|
||
|
||
# Status aller Videos
|
||
./produce.py status
|
||
# ID | Kanal | Thema | Status | Fortschritt
|
||
# 42 | kanal-a | Irans Hyperschall-Schlag | producing | 3/5 Jobs done
|
||
# 43 | kanal-b | Oelpreis-Analyse 2026 | script | Review pending
|
||
|
||
# Skript bestaetigen und Produktion starten
|
||
./produce.py approve-script 42
|
||
|
||
# Fertiges Video reviewen und freigeben
|
||
./produce.py publish 42 --yt-upload
|
||
|
||
# GPU-Auslastung
|
||
./produce.py gpus
|
||
# GPU | Status | Job | Video | Progress
|
||
# 3090 | busy | flux-hero | #42 | 8/15 images
|
||
# 3080 #0 | busy | sdxl-batch | #42 | 23/50 images
|
||
# 3080 #1 | busy | sdxl-batch | #42 | 31/50 images
|
||
# 3080 #2 | busy | sadtalker | #42 | 12:30/24:00
|
||
# 3080 #3 | idle | — | — | waiting for images
|
||
```
|
||
|
||
## Worker-Architektur
|
||
|
||
```
|
||
ki-tower (3090, Chef) gpu-worker (4x 3080, Worker) gpu-reserve (RX 6600 XT)
|
||
┌─────────────────────────┐ ┌──────────────────────────────┐ ┌──────────────────┐
|
||
│ Orchestrator (Python) │ │ Debian 12 + Docker + CUDA │ │ Reserve/Whisper │
|
||
│ ├── production.db │ 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 │
|
||
└─────────────────────────┘ └──────────────────────────────┘
|
||
```
|
||
|
||
## 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 |
|
||
| Skript-LLM | **GPT-5.4** (Cloud) | Beste Qualitaet fuer Kreativarbeit. ~0.10-0.50 EUR/Skript. |
|
||
| Szenenplan-LLM | **Qwen 14B** (lokal) | Strukturiertes JSON aus Skript, braucht keine Kreativitaet. |
|
||
| LLM-Server (lokal) | **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) |
|
||
| **GPT-5.4 API (Skripte)** | — | **~3-15 EUR** (6-24 Skripte/Monat) |
|
||
| Cloud-APIs (Fallback TTS) | — | ~5-10 EUR |
|
||
| **Gesamt** | 0 EUR | ~50-95 EUR |
|
||
|
||
Zum Vergleich: Vollstaendig cloud-basierte Videoproduktion (Runway, ElevenLabs, GPT-4) = 100-300 EUR/Monat.
|
||
Die GPT-5.4-Kosten fuer Skripte sind der beste ROI im ganzen Projekt: ~0.50 EUR fuer
|
||
ein Skript, das ein lokales 14B-Modell qualitativ nie erreichen wuerde.
|