From faafb9938e92971c8cbba7e93990c5d137b7c463 Mon Sep 17 00:00:00 2001 From: root Date: Mon, 16 Mar 2026 11:48:00 +0700 Subject: [PATCH] PLAN.md: Konkreter Produktionsablauf fuer Geld-&-Imperien-Stil, 5-GPU-Parallelisierung, v1.5 Pipeline --- ki-video/PLAN.md | 239 ++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 207 insertions(+), 32 deletions(-) diff --git a/ki-video/PLAN.md b/ki-video/PLAN.md index 9cb40461..55c71680 100644 --- a/ki-video/PLAN.md +++ b/ki-video/PLAN.md @@ -8,31 +8,163 @@ Kein Spielzeug-Demo, kein Forschungsprojekt: Thema rein → fertiges Video raus. ## Videoformat +Referenz-Stil: **"Geld & Imperien"** (YouTube, geopolitischer Commentary-Kanal) +Beispielvideo: https://youtu.be/4XfhrrbklbM (24 Min, "Irans Hyperschall-Schlag") + | Eigenschaft | Beschreibung | |---|---| | **Typ** | Commentary, Erklaervideos, Meinungs-/Analyseformate | -| **Stil** | Sprecherstimme + Bilder + leichte Bewegung + Einblendungen | +| **Laenge** | 10-30 Minuten | +| **Stil** | Professionelle Erzaehlstimme + Bilder + Karten + Infografiken + Text-Overlays + Ken-Burns | +| **Kein** | Face-Cam, Schnitte auf Person, Realfilm | | **Optional** | Sprechender Avatar (SadTalker) — erst ab v2 | -| **Nicht** | Realfilm, Hollywood-VFX, aufwendige 3D-Animation | -## Pipeline +### 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 | +| **Voiceover** | 20 Min Audio | 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. ``` -1. Themenfindung / Recherche (manuell) - │ -2. Skript-Erstellung → Qwen 14B (ki-tower) - │ -3. Bildgenerierung → FLUX.1-dev (ki-tower) - │ -4. Voiceover → Piper TTS (CPU, ki-tower) - │ -5. Compositing → FFmpeg + Ken-Burns (CPU, ki-tower) - │ -6. Encoding → FFmpeg + NVENC (ki-tower) - │ -7. Export → fertiges MP4 fuer YouTube +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 2 — 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 ││ XTTS v2 ││ ESRGAN │ + │ Hero- ││ Standard-││ Standard-││ Voiceover ││ Upscale │ + │ Bilder ││ Szenen ││ Szenen ││ 20 Min ││ + Whisper│ + │ 15 Stk ││ ~45 Stk ││ ~45 Stk ││ Audio ││ Untertit.│ + │ ~15 Min ││ ~20 Min ││ ~20 Min ││ ~15 Min ││ ~10 Min │ + └──────────┘└──────────┘└──────────┘└──────────┘└──────────┘ + + Alle 5 GPUs arbeiten GLEICHZEITIG. Engpass = Bildgenerierung (~20-25 Min). + +PHASE 3 — ASSEMBLY + EXPORT (ki-tower, seriell, ~15-20 Min) +════════════════════════════════════════════════════════════ + │ + ▼ +FFmpeg: Bilder + Ken-Burns + Zoom + Ueberblendungen + │ + ▼ +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/4K) + │ + ▼ +Export: Thumbnail (FLUX hero-Bild, upscaled) + Titel + Description + Tags ``` +### Zeitschaetzung: 20-Minuten-Video im "Geld & Imperien"-Stil + +| Phase | Dauer | GPUs aktiv | Engpass | +|---|---|---|---| +| 1. Skript + Szenenplan | ~15 Min | 1 (3090) | LLM-Inferenz | +| 2. Parallel-Produktion | ~25 Min | 5 (alle) | Bildgenerierung | +| 3. Assembly + Export | ~15 Min | 1 (3090 NVENC) | FFmpeg Compositing | +| **Gesamt** | **~55 Min** | | | + +Zum Vergleich: Seriell auf nur 1 GPU = ~3-4 Stunden. +Mit 5 GPUs parallel: **unter 1 Stunde fuer ein 20-Min-Video.** + +### GPU-Auslastung waehrend Phase 2 + +| GPU | Aufgabe | VRAM | Dauer | Output | +|---|---|---|---|---| +| **3090** (ki-tower) | FLUX.1-dev Hero-Bilder | ~12 GB | ~15 Min | 15 hochwertige Key-Visuals (1024x1024) | +| **3080 #0** | SDXL Standard-Szenen | ~7 GB | ~20 Min | ~45 Szenenbilder (1024x1024) | +| **3080 #1** | SDXL Standard-Szenen | ~7 GB | ~20 Min | ~45 Szenenbilder (1024x1024) | +| **3080 #2** | XTTS v2 Voiceover | ~4 GB | ~15 Min | 20 Min deutsches Voiceover | +| **3080 #3** | Real-ESRGAN + Whisper | ~3 GB | ~10 Min | Upscaled Bilder + SRT-Untertitel | + +Nach Abschluss der Hauptaufgabe uebernehmen freie GPUs Restarbeiten: +- 3080 #2 (fertig mit TTS) → hilft bei restlichen SDXL-Bildern +- 3080 #3 (fertig mit Upscale) → generiert Thumbnail-Varianten + +## 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 2 — 5 GPUs parallel (25 Min): + 3090: 15 Hero-Bilder (FLUX.1-dev, beste Qualitaet) → Titel, Kapitelwechsel, Outro + 3080 #0: 45 Standardbilder (SDXL) → Militaer, Politik, Wirtschaft + 3080 #1: 45 Standardbilder (SDXL) → Karten, Infografiken, Symbolbilder + 3080 #2: 24 Min Voiceover (XTTS v2) → deutsche Maennerstimme, professioneller Ton + 3080 #3: Upscaling aller Bilder auf 1920x1080 + Untertitel-SRT aus Voiceover + +PHASE 3 — Assembly (15 Min): + FFmpeg: 105 Szenen × Ken-Burns/Zoom + Voiceover + Ambient-Musik + Overlays + Output: "irans-hyperschall-2026-03.mp4" (1080p, H.265, ~1.5 GB) + Bonus: Thumbnail (Hero-Bild #1, upscaled, mit Titel-Text) + YouTube-Description + Tags (aus Skript-Metadaten) +``` + +Gesamtzeit: **~55 Minuten** fuer ein 24-Minuten-Video. Fertig zum Hochladen. + ## Hardware ### ki-tower — Hauptmaschine (Muldenstein, geplant) @@ -176,7 +308,11 @@ Schritt 5: Encoding → NVENC → ~1 GB VRAM ``` Mit Qwen 14B statt 32B: kein VRAM-Flush zwischen Schritt 1 und 2 noetig. -Geschaetzte Produktionszeit: ~1-2 Stunden pro 10-Min-Video. + +Geschaetzte Produktionszeit: +- v1 (nur ki-tower, seriell): ~2-3 Stunden pro 10-Min-Video +- v1.5 (5 GPUs parallel): ~55 Min pro 20-Min-Video +- Langfristig mit Optimierung: ~40 Min pro 20-Min-Video ## Nicht-Ziele @@ -190,35 +326,71 @@ Geschaetzte Produktionszeit: ~1-2 Stunden pro 10-Min-Video. ## v1 — Minimal Viable Pipeline (nur ki-tower) -v1 beweist: die Pipeline funktioniert. Kein Rig, kein Avatar, keine Automatisierung. +v1 beweist: die Pipeline funktioniert auf einer Maschine. Schritte manuell anstossen. ``` -v1 Pipeline (alles auf ki-tower): +v1 Pipeline (alles auf ki-tower, seriell): Thema (manuell) │ ▼ -Qwen 14B → Skript (vLLM, :8401) +Qwen 14B → Skript + Szenenplan (vLLM, :8401) │ ▼ -FLUX.1-dev → 20-30 Bilder (ComfyUI, :8402) +FLUX.1-dev → 30-50 Bilder (ComfyUI, :8402) ← seriell, ~30-45 Min │ ▼ -Piper TTS → Voiceover (CPU, :8504) +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 -- Kein GPU-Worker-Rig -- Keine automatische Orchestrierung (Schritte manuell anstossen) -- Keinen YouTube-Upload - 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 (ki-tower + 3080-Rig) + +v1.5 ist der grosse Sprung: **5 GPUs parallel = 3-4x schneller.** + +``` +v1.5 Pipeline (5 GPUs parallel): + +Thema (manuell) + │ + ▼ +Qwen 14B → Skript + Szenenplan JSON (ki-tower) + │ + ▼ +Orchestrator verteilt Jobs an alle 5 GPUs gleichzeitig: + ├── 3090: FLUX.1-dev → Hero-Bilder (beste Qualitaet) + ├── 3080 #0: SDXL → Standard-Szenen Batch A + ├── 3080 #1: SDXL → Standard-Szenen Batch B + ├── 3080 #2: XTTS v2 → deutsches Voiceover + └── 3080 #3: Real-ESRGAN → Upscaling + Whisper → Untertitel + │ + ▼ +FFmpeg → Assembly (Ken-Burns + Audio + Overlays + Untertitel) + │ + ▼ +NVENC → Export MP4 + Thumbnail + YouTube-Metadaten +``` + +Was v1.5 bringt: +- Produktionszeit: ~55 Min statt ~3 Stunden fuer 20-Min-Video +- XTTS v2 statt Piper (natuerlichere Stimme) +- Automatische Untertitel +- 4K-Upscaling fuer Thumbnails +- Orchestrator-Script verteilt und sammelt automatisch + +Erfolgskriterium v1.5: 20-Min-Video in unter 1 Stunde produziert. + ## v2 — Erweiterungen (nach funktionierender v1) | Feature | Abhaengigkeit | @@ -263,16 +435,19 @@ PHASE 4 — Polieren + erstes echtes Video (Woche 6) ├── Erstes Video auf YouTube hochladen └── Ergebnis: "v1 steht und produziert" -PHASE 5 — 3080-Rig Aufbau (Woche 7-8, parallel moeglich) +PHASE 5 — 3080-Rig Aufbau + v1.5 (Woche 7-9) ├── Debian 12 + NVIDIA-Treiber + CUDA + Docker (selber Stack wie ki-tower) -├── SDXL-Worker, Whisper-Worker, XTTS-Worker aufsetzen +├── 4 Worker: SDXL #0, SDXL #1, XTTS v2, ESRGAN/Whisper ├── Tailscale + Job-API anbinden -└── Ergebnis: "4 parallele CUDA-Worker laufen" +├── Python-Orchestrator: Szenenplan → Jobs verteilen → sammeln +├── XTTS v2 statt Piper (bessere Stimme) +└── Ergebnis: "20-Min-Video in unter 1 Stunde, 5 GPUs parallel" -PHASE 6 — v2 Features (nach stabiler Produktion) -├── XTTS v2 auf 3080-Worker (bessere Stimme, Batch) -├── SadTalker Avatar auf 3080-Worker -├── Python-Orchestrator (automatische Verkettung) +PHASE 6 — v2 Features (nach stabiler v1.5-Produktion) +├── SadTalker Avatar auf 3080-Worker (optional pro Video) +├── 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)