diff --git a/ki-video/PLAN.md b/ki-video/PLAN.md index 6f205e66..cab2456a 100644 --- a/ki-video/PLAN.md +++ b/ki-video/PLAN.md @@ -3,430 +3,253 @@ ## Ziel -Lokale, praktisch nutzbare Produktionsstrecke fuer YouTube-Videos im Commentary-/Erklaerstil. -Kein Spielzeug-Demo, kein Forschungsprojekt: Thema rein → fertiges Video raus. +Lokale, produktiv nutzbare Pipeline fuer YouTube-Videos im Commentary-/Erklaerstil. +Thema rein → fertiges Video raus. Kein Forschungsprojekt, kein Proof-of-Concept. ## 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) +Referenz-Stil: **"Geld & Imperien"** / **"Money & People"** (YouTube) +- https://youtu.be/4XfhrrbklbM (24 Min, Geld & Imperien) +- https://youtu.be/MIkAOwJYaP0 (19 Min, Money & People) -| Eigenschaft | Beschreibung | +| Eigenschaft | v1 | |---|---| -| **Typ** | Commentary, Erklaervideos, Meinungs-/Analyseformate | +| **Typ** | Commentary, Erklaervideo, Analyse | | **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 | +| **Visuell** | Bilder + Karten + Infografiken + Text-Overlays + Ken-Burns | +| **Stimme** | XTTS v2, natuerliche deutsche Maennerstimme, Voice-Cloning | +| **Untertitel** | Automatisch (faster-whisper → SRT) | +| **Avatar** | **Nein.** Erst ab v1.5 als optionaler PiP-Test. | +| **Kein** | Face-Cam, Realfilm, Vollbild-Avatar, Piper TTS | -### Avatar-Konzept (Picture-in-Picture) +Das fertige Video besteht aus: Bilder mit Ken-Burns-Effekten + Voiceover + Hintergrundmusik ++ Text-Overlays + eingebrannte Untertitel. Das reicht. Die Referenz-Kanaele machen es genauso. -``` -┌─────────────────────────────────────────────────────────┐ -│ │ -│ HAUPTBILD (80%) │ -│ Karten, Infografiken, Szenenbilder │ -│ Ken-Burns, Zoom, Ueberblendungen │ -│ │ -│ │ -│ │ -│ ┌─────────────┐ │ -│ │ │ │ -│ │ AVATAR │ │ -│ │ (~20%) │ │ -│ │ lip-sync │ │ -│ │ sprechend │ │ -│ └─────────────┘ │ -└─────────────────────────────────────────────────────────┘ - 1920 x 1080 (Full HD) +### Anatomie eines 20-Min-Videos -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 | +| Element | Menge | Quelle | |---|---|---| -| **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 | +| **Skript** | ~3500-5000 Woerter | GPT-5.4 (Cloud) + menschliches Review | +| **Szenenplan** | ~100 Szenen (JSON) | Qwen 14B (lokal) | +| **Hero-Bilder** | 10-15 Stueck | FLUX.1-dev (3090) | +| **Standard-Bilder** | 70-100 Stueck | SDXL (3x 3080) | +| **Voiceover** | 20 Min WAV | XTTS v2 (3080) | +| **Untertitel** | SRT-Datei | faster-whisper (3080) | +| **Hintergrundmusik** | 1-2 Tracks | Lizenzfrei, manuell gewaehlt | +| **Text-Overlays** | 20-40 Stueck | FFmpeg (aus Szenenplan) | -## Produktions-Pipeline (5 GPUs parallel) +## v1 — Produktions-Pipeline -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. +### Prinzip ``` -PHASE 1 — SKRIPT + SZENENPLAN (~15-30 Min, Cloud + lokal) -═════════════════════════════════════════════════════════ +GPT-5.4 (Cloud) → Qwen 14B (lokal) → 5 GPUs parallel → FFmpeg → MP4 + Skript Szenenplan Bilder + Voice Assembly +``` + +Kein Avatar. Kein dynamisches Scheduling. Kein Service-Mesh. +5 GPUs, feste Zuordnung, SQLite als Zustand, Python als Orchestrator. + +### Pipeline-Schritte + +``` +PHASE 1 — SKRIPT + SZENENPLAN (~30 Min, Cloud + lokal + Mensch) +═══════════════════════════════════════════════════════════════ 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 +GPT-5.4 (OpenAI API) → Skript (~4000 Woerter) + │ Kosten: ~0.10-0.50 EUR + ▼ +Mensch reviewt, korrigiert, gibt frei (~20 Min) │ ▼ -Menschliches Review (~20-30 Min) → Korrektur, Feinschliff, Faktencheck +Qwen 14B (vLLM, :8401) → Szenenplan (JSON): + 100 Szenen mit je: + - Bildprompt (EN, fuer FLUX oder SDXL) + - Szenentyp: hero | standard | karte | infografik + - Text-Overlay (oder null) + - Dauer in Sekunden │ ▼ -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 +Orchestrator uebernimmt -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 2 — PARALLEL-PRODUKTION (alle 5 GPUs, ~20 Min) +═════════════════════════════════════════════════════ -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). + ┌──────────────────────────────────────────────────────────┐ + │ ORCHESTRATOR (ki-tower, Python) │ + │ Verteilt Jobs, pollt Status, sammelt Ergebnisse │ + └──────┬──────────┬──────────┬──────────┬──────────────────┘ + │ │ │ │ + ▼ ▼ ▼ ▼ + ┌──────────┐┌──────────┐┌──────────┐┌──────────────────────┐ + │ 3090 ││ 3080 #0 ││ 3080 #1 ││ 3080 #2 + #3 │ + │ ki-tower ││ Worker ││ Worker ││ Worker │ + │ ││ ││ ││ │ + │ FLUX.1 ││ XTTS v2 ││ SDXL ││ SDXL │ Whisper │ + │ Hero- ││ Voice ││ Standard ││ Standard│ + ESRGAN │ + │ Bilder ││ → SDXL ││ Bilder ││ Bilder │ Untertit. │ + │ 10-15 St ││ → Rest ││ ~40 Stk ││ ~40 Stk │ + Upscale │ + │ ~10 Min ││ ~20 Min ││ ~20 Min ││ ~20 Min │ ~5 Min │ + └──────────┘└──────────┘└──────────┘└──────────────────────┘ -PHASE 2b — PARALLEL-PRODUKTION (alle 5 GPUs, ~30-40 Min) -══════════════════════════════════════════════════════════ + Alle GPUs starten SOFORT. Keine Abhaengigkeitskette. + 3080 #0: XTTS v2 Voiceover (~15 Min), danach SDXL Restbilder (~5 Min). + 3080 #3: Whisper (braucht Audio, wartet auf #0) + ESRGAN parallel. + Engpass = Bildgenerierung (~20 Min fuer ~100 Bilder auf 3+1 GPUs). - ┌──────────────────────────────────────────────────────────────────┐ - │ 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 +PHASE 3 — ASSEMBLY (ki-tower, ~10-15 Min) +══════════════════════════════════════════ +FFmpeg: Bilder + Ken-Burns + Zoom + Ueberblendungen → Videospur +FFmpeg: Audio-Mix (Voiceover + Hintergrundmusik) +FFmpeg: Text-Overlays einbrennen +FFmpeg: Untertitel (SRT) einbetten +NVENC: H.265 Encoding → fertiges MP4 (1080p) +Export: Thumbnail (FLUX hero-Bild) + Titel + Description + Tags ``` -### Zeitschaetzung: 20-Minuten-Video mit Avatar +### Zeitschaetzung: 20-Min-Video (ohne Avatar) -| Phase | Dauer | GPUs aktiv | Engpass | +| Phase | Dauer | GPUs | 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** | | | +| 1. Skript + Szenenplan | ~30 Min | 1 (3090) + Cloud | Mensch (Review) | +| 2. Parallel-Produktion | ~20 Min | 5 (alle) | Bildgenerierung | +| 3. Assembly | ~10 Min | 1 (3090 NVENC) | FFmpeg Compositing | +| **Gesamt (Maschine)** | **~30 Min** | | | +| **Gesamt (inkl. Mensch)** | **~60 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. +Ohne Avatar: kein SadTalker-Engpass, keine TTS→Avatar-Abhaengigkeit. +Bildgenerierung ist der Engpass, aber auf 4 GPUs verteilt (3x SDXL + 1x FLUX). -### GPU-Auslastung waehrend Phase 2 +### GPU-Zuordnung v1 -| 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 | +| GPU | Aufgabe | VRAM | Dauer | Output | +|---|---|---|---|---| +| **3090** | Qwen 14B (Szenenplan) → FLUX.1-dev (Hero-Bilder) | 12 GB | ~10 Min | 10-15 hochwertige Key-Visuals | +| **3080 #0** | XTTS v2 (Voiceover) → SDXL (Restbilder) | 4→7 GB | ~20 Min | 20 Min Audio + ~15 Bilder | +| **3080 #1** | SDXL (Standard-Szenen, durchgehend) | 7 GB | ~20 Min | ~40 Bilder | +| **3080 #2** | SDXL (Standard-Szenen, durchgehend) | 7 GB | ~20 Min | ~40 Bilder | +| **3080 #3** | faster-whisper (Untertitel) + Real-ESRGAN (Upscaling) | 3 GB | ~5 Min | SRT + upscaled Thumbnails | -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. +Alle 4 Bild-GPUs zusammen: **~100 Bilder in ~20 Minuten.** +3080 #3 ist nach ~5 Min fertig und idle — kann bei Bedarf auch SDXL uebernehmen. ## Hardware -### ki-tower — Hauptmaschine (Muldenstein, geplant) +### ki-tower (RTX 3090, 24 GB) | 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. | +| 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 | +| Rolle | Chef: Szenenplan (Qwen), Hero-Bilder (FLUX), Assembly (FFmpeg), Orchestrator | -### gpu-worker — NVIDIA-Rig (Muldenstein, geplant) — PRIMAERER WORKER +### gpu-worker (4x RTX 3080, je 10 GB) | 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. | +| GPUs | 4x NVIDIA RTX 3080 (je 10 GB GDDR6X) | +| OS | Debian 12 + Docker + CUDA (identisch mit ki-tower) | +| Rolle | Worker: XTTS v2, SDXL-Batch, Whisper, ESRGAN | +| Vorteil | Selber CUDA-Stack — Code einmal schreiben, ueberall deployen | -### gpu-reserve — AMD-Rig (Muldenstein, Reserve) +### gpu-reserve (8x RX 6600 XT) — NICHT in v1 -| 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. | +Zurueckgestellt. Kein Aufbau, keine Planung, keine Ressourcen. +Entscheidung nach 3 Monaten produktiver v1: behalten oder verkaufen. -## Rollenverteilung — Was laeuft wo +## Rollenverteilung -### Cloud — Skript-Generierung +### Cloud: GPT-5.4 → Skripte -| Aufgabe | Modell | Kosten | Anmerkung | +Skriptqualitaet ist der Flaschenhals. Kein lokales Modell liefert +Persoenlichkeit, Meinung und natuerliches deutsches Storytelling auf diesem Niveau. +Kosten: ~0.10-0.50 EUR/Skript. Irrelevant vs. Stromkosten. + +### ki-tower (3090): Szenenplan + Hero-Bilder + Assembly + +| Dienst | Tool | Port | VRAM | |---|---|---|---| -| **Skripte** | GPT-5.4 (OpenAI API) | ~0.10-0.50 EUR/Skript | Persoenlichkeit, Storytelling, Meinung | +| Szenenplan-LLM | Qwen 2.5 14B (vLLM) | :8401 | ~12 GB | +| Hero-Bilder | FLUX.1-dev (ComfyUI) | :8402 | ~12 GB | +| Assembly | FFmpeg + NVENC | — | ~1 GB | +| Orchestrator | Python | — | CPU | -Skriptqualitaet ist der Flaschenhals. Kein lokales Modell kommt an GPT-5.4 ran fuer -kreatives, meinungsstarkes, deutsches Storytelling. Cloud-Kosten sind vernachlaessigbar. +Schritte laufen sequentiell auf der 3090. Erst Qwen (Szenenplan), dann FLUX (Bilder), +dann FFmpeg (Assembly). Kein VRAM-Flush noetig (14B = 12 GB, FLUX = 12 GB). -### ki-tower (RTX 3090) — Hauptpfad +### gpu-worker (3080): Voice + Bilder + Untertitel -| 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 | +| GPU | Dienst | Tool | Port | VRAM | |---|---|---|---|---| -| **#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 | +| #0 | TTS → Bilder | XTTS v2 → SDXL | :8501 | 4 → 7 GB | +| #1 | Bilder | SDXL | :8502 | 7 GB | +| #2 | Bilder | SDXL | :8503 | 7 GB | +| #3 | Untertitel + Upscaling | faster-whisper + Real-ESRGAN | :8504 | 3 GB | -Feste Zuordnung pro Video-Produktion. Kein dynamisches Scheduling. -Kernvorteil: Identischer CUDA-Stack wie ki-tower. +1 Container pro GPU. HTTP-API pro Worker. Orchestrator auf ki-tower pollt Status. +Tailscale verbindet ki-tower und gpu-worker. -### gpu-reserve (8x RX 6600 XT) — Reserve/Nebenrolle +## Produktions-Datenbank -| 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 | +Zentrale Steuerung: **`production.db`** (SQLite) auf ki-tower. -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 +### 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 + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + slug TEXT UNIQUE NOT NULL, + voice_path TEXT NOT NULL, -- XTTS Voice-Cloning Referenz + prompt_template TEXT, -- GPT-5.4 System-Prompt (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 + id INTEGER PRIMARY KEY, + channel_id INTEGER REFERENCES channels(id), + title TEXT NOT NULL, + topic TEXT, + status TEXT DEFAULT 'draft', -- draft→script→scenes→producing→assembly→review→published + script TEXT, + scene_plan TEXT, -- JSON + voiceover_path TEXT, + subtitle_path TEXT, + final_path TEXT, + thumbnail_path TEXT, + yt_title TEXT, + yt_description TEXT, + yt_tags TEXT, + 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 + scene_type TEXT NOT NULL, -- hero | standard | karte | infografik + prompt TEXT NOT NULL, + overlay TEXT, + duration_s REAL NOT NULL, + image_path TEXT, + 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 + job_type TEXT NOT NULL, -- tts | sdxl | flux | whisper | esrgan | assembly + gpu TEXT, + status TEXT DEFAULT 'queued', -- queued→running→done→failed + input_data TEXT, + output_path TEXT, + error TEXT, queued_at DATETIME DEFAULT CURRENT_TIMESTAMP, started_at DATETIME, finished_at DATETIME @@ -437,392 +260,257 @@ CREATE TABLE jobs ( ``` /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/ -│ └── ... -│ +├── production.db +├── channels/ +│ └── kanal-a/ +│ ├── voice-sample.wav # XTTS Referenz (~30s) +│ └── prompt.md # GPT-5.4 Persoenlichkeits-Prompt +├── videos/ +│ └── 2026-03-16-iran-hyperschall/ +│ ├── script.md +│ ├── scenes.json +│ ├── images/ # 80-120 generierte Bilder +│ ├── audio/ +│ │ ├── voiceover.wav +│ │ └── music.mp3 +│ ├── subtitles.srt +│ ├── thumbnail.png +│ └── final.mp4 └── 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 + ├── ffmpeg-kenburns.sh + └── music/ ``` -### Produktions-Ablauf (Statusmaschine) +### 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 │ │ - │ └───────────┘ └──────────┘ └──────────┘ │ - │ │ - └──────────────────────────────────────────────────┘ +draft → script → scenes → producing → assembly → review → published -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 +draft : Thema angelegt +script : GPT-5.4 Skript + menschliches Review +scenes : Qwen generiert Szenenplan +producing : 5 GPUs arbeiten parallel (Bilder + Voice + Untertitel) +assembly : FFmpeg baut Video zusammen +review : Mensch schaut fertiges Video +published : YouTube-Upload ``` -### Orchestrator-Logik (Python, laeuft auf ki-tower) +### Orchestrator (Python, 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) + 1. videos WHERE status = 'scenes' + → Jobs erstellen: 1x TTS, Nx SDXL, Mx FLUX, 1x Whisper, 1x ESRGAN - 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 + 2. jobs WHERE status = 'queued' + → Abhaengigkeiten pruefen (Whisper wartet auf TTS) + → An Worker senden (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 + 3. jobs WHERE status = 'running' + → Worker pollen, Status updaten - 4. Checke videos WHERE status = 'producing' - AND alle zugehoerigen jobs.status = 'done' - → Starte Assembly-Job (FFmpeg) - → Status → 'assembly' + 4. Alle Jobs eines Videos done? + → Assembly-Job starten (FFmpeg) - 5. Checke videos WHERE status = 'assembly' - AND assembly-job.status = 'done' + 5. Assembly done? → Status → 'review' - → Benachrichtigung an Telegram (Hausmeister-Bot!) + → Telegram-Benachrichtigung (Hausmeister-Bot) ``` -### CLI fuer den Alltag +### CLI ```bash -# Neues Video anlegen -./produce.py new --channel kanal-a --topic "Irans Hyperschall-Schlag" - -# Status aller Videos +./produce.py new --channel kanal-a --topic "Oelpreis-Krise 2026" ./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 publish 42 ./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 │ +ki-tower (3090) gpu-worker (4x 3080) +┌─────────────────────────┐ ┌──────────────────────────────┐ +│ Orchestrator (Python) │ │ Debian 12 + Docker + CUDA │ │ ├── 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 │ └──────────────────┘ +│ ├── /api/submit-job │◄────────────►│ #0: xtts+sdxl :8501 │ +│ ├── /api/job-status │ │ #1: sdxl :8502 │ +│ └── /api/get-result │ │ #2: sdxl :8503 │ +│ │ │ #3: whisper+esrgan :8504 │ │ Qwen 14B (vLLM) :8401 │ │ │ │ FLUX.1 (ComfyUI):8402 │ │ 10 GB VRAM pro Karte │ -│ FFmpeg (lokal) │ │ CUDA-nativ, kein Workaround │ +│ FFmpeg (lokal) │ │ CUDA-nativ │ └─────────────────────────┘ └──────────────────────────────┘ ``` -## VRAM-Budget (ki-tower, sequentiell) +## Konkretes Beispiel: "Irans Hyperschall-Schlag" (24 Min) ``` -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 +INPUT: + Thema: "Irans Hyperschallrakete — geopolitische Folgen" + Recherche: 3-4 Quellenlinks + +PHASE 1 (~30 Min): + GPT-5.4 → Skript (4500 Woerter) + Mensch reviewt (~20 Min) + Qwen 14B → Szenenplan: 105 Szenen (JSON) + +PHASE 2 (~20 Min, alle 5 GPUs parallel): + 3090: 12 Hero-Bilder (FLUX.1-dev) + 3080 #0: XTTS v2 → 24 Min Voiceover → danach 15 SDXL-Bilder + 3080 #1: 40 Standardbilder (SDXL) + 3080 #2: 40 Standardbilder (SDXL) + 3080 #3: Whisper → Untertitel-SRT + ESRGAN Upscaling + +PHASE 3 (~10 Min): + FFmpeg: 105 Szenen × Ken-Burns → Videospur + FFmpeg: Audio-Mix (Voiceover + Ambient-Musik) + FFmpeg: Text-Overlays + Untertitel + NVENC: H.265 → final.mp4 (1080p) + +Gesamtzeit Maschine: ~30 Min +Gesamtzeit inkl. Mensch: ~60 Min ``` -Mit Qwen 14B statt 32B: kein VRAM-Flush zwischen Schritt 1 und 2 noetig. +## Nicht-Ziele (v1) -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 | +- Kein Avatar (kommt spaeter als Test) +- Kein Vollbild-Avatar +- Kein Piper TTS (zu robotisch, XTTS v2 direkt) +- Kein AMD-Rig +- Kein Multi-Kanal (erst ein Kanal stabil betreiben) +- Keine YouTube-Upload-Automation +- Keine Batch-Produktion (ein Video nach dem anderen) +- Kein Kubernetes, kein Service-Mesh, kein Proxmox ## 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" +├── Debian 12 + NVIDIA 550+ Treiber + CUDA 12.x + Docker +├── vLLM + Qwen 2.5 14B → Szenenplan-Test +├── GPT-5.4 API anbinden → erster Skript-Test +└── Ergebnis: "Skript + Szenenplan funktionieren" 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" +├── ComfyUI + FLUX.1-dev in Docker → Hero-Bilder testen +├── SDXL in Docker (gleicher ComfyUI oder A1111) +├── Workflow: Szenenplan-JSON → Bildprompts → Bilder +└── Ergebnis: "100 Bilder in <30 Min generiert" -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 3 — 3080-Rig parallel aufbauen (Woche 3-5) +├── Debian 12 + CUDA + Docker (identischer Stack) +├── SDXL-Worker auf #1, #2 (sofort produktiv) +├── Tailscale + Worker-API anbinden +└── Ergebnis: "3 SDXL-Worker generieren Bilder parallel" -PHASE 4 — Polieren + erstes echtes Video (Woche 6) +PHASE 4 — Voice + Untertitel (Woche 5-6) +├── XTTS v2 auf 3080 #0 → Voice-Cloning mit eigener Referenz testen +├── Deutsche Stimme tunen (Sprechstil, Tempo, Betonung) +├── faster-whisper auf 3080 #3 → SRT-Untertitel +└── Ergebnis: "Natuerliches deutsches Voiceover + Untertitel" + +PHASE 5 — FFmpeg Assembly + erstes Video (Woche 6-7) +├── Ken-Burns-Presets (Schwenk, Zoom, statisch je Szenentyp) +├── Audio-Mix (Voiceover + Musik, Lautstaerke-Normalisierung) +├── Text-Overlay-Pipeline (aus Szenenplan-JSON) +├── Untertitel einbetten +├── Thumbnail-Generierung (FLUX hero-Bild) +├── NVENC Encoding +└── Ergebnis: "Erstes komplettes 10-Min-Video" + +PHASE 6 — Orchestrator + Produktionsbetrieb (Woche 7-8) +├── Python-Orchestrator: production.db + Job-Verteilung +├── CLI (produce.py) +├── Telegram-Benachrichtigung bei fertigem Video +├── Erstes Video auf YouTube hochladen +└── Ergebnis: "v1 laeuft produktiv" + +PHASE 7 — Stabilisierung + Tempo (Woche 9-10) ├── 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" +├── XTTS-Stimme weiter tunen +├── 3-5 Videos produzieren und Workflow optimieren +└── Ergebnis: "v1 ist stabil, 2-3 Videos/Woche moeglich" ``` -## Entscheidungen (getroffen) +## Spaeter (v1.5+) + +Erst nach mindestens 10 produzierten Videos und stabilem Workflow. + +### v1.5 — Avatar-Test (optional) + +| Feature | Beschreibung | +|---|---| +| SadTalker PiP (~20%) | Sprechender Avatar unten rechts, 384x384 | +| Laeuft auf 3080 #2 | SDXL wird auf #1 und #0 (nach TTS) konzentriert | +| Abhaengigkeit | TTS muss vorher fertig sein (Audio → Lip-Sync) | +| Risiko | Qualitaet moeglicherweise nicht ausreichend. Alternativen: LivePortrait, MuseTalk | +| Entscheidung | Erst testen, dann entscheiden ob es im Kanal bleibt | + +``` +Avatar-Layout (nur v1.5): +┌─────────────────────────────────────────────┐ +│ │ +│ HAUPTBILD (Bilder, Karten) │ +│ │ +│ ┌─────────┐ │ +│ │ Avatar │ │ +│ │ ~20% │ │ +│ └─────────┘ │ +└─────────────────────────────────────────────┘ +``` + +### v2 — Erweiterungen + +| Feature | Voraussetzung | +|---|---| +| Multi-Kanal | v1 stabil, erster Kanal hat >20 Videos | +| Avatar-Varianten | SadTalker/LivePortrait qualitativ validiert | +| Batch-Produktion | Mehrere Videos in Queue | +| YouTube-Upload-API | Manueller Upload nervt (>3 Videos/Woche) | +| Vollbild-Avatar | Nur wenn Qualitaet stimmt. Aktuell unrealistisch mit SadTalker. | + +### AMD-Rig + +Nicht in der Planung. Entscheidung nach 3 Monaten v1: +- Wenn 3080-Rig Kapazitaetsgrenze erreicht: 1-Karten-Test (Whisper) +- Sonst: verkaufen, Erloese in Storage investieren + +## Entscheidungen | 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 | +| Skript-LLM | **GPT-5.4** (Cloud) | Kreativitaet > lokale Inferenz. ~0.50 EUR/Skript. | +| Szenenplan-LLM | **Qwen 14B** (lokal) | Strukturiertes JSON, keine Kreativitaet noetig | +| Hero-Bilder | **FLUX.1-dev** (3090) | Beste Qualitaet fuer Thumbnails, Titel, Kapitelwechsel | +| Standard-Bilder | **SDXL** (3x 3080) | Schnell, gut genug, massiv parallelisierbar | +| Stimme (v1) | **XTTS v2** (3080 #0) | Voice-Cloning, natuerlich, deutsch. Keine Uebergangsloesung. | +| Untertitel | **faster-whisper** (3080 #3) | CUDA-nativ, schnell | +| Avatar (v1) | **Nein** | Fragil, Qualitaetsrisiko, unnoetige Komplexitaet | +| Assembly | **FFmpeg + NVENC** | Stabil, flexibel, hardware-beschleunigt | +| DB | **SQLite** | Ein User, eine Datei. | +| Netzwerk | **Tailscale** | ki-tower ↔ gpu-worker, fertig | +| OS | **Debian 12** | Beide Maschinen identisch. Docker + CUDA. | +| AMD-Rig | **Nicht in v1** | Kein Aufwand, keine Planung | ## 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. | +| # | Risiko | Impact | Mitigation | +|---|---|---|---| +| 1 | **XTTS v2 deutsche Stimme klingt unnatuerlich** | Hoch | Voice-Cloning mit guter Referenz. Fallback: OpenAI TTS als Bruecke (~0.50 EUR/Video). | +| 2 | **VRAM-Tetris auf 3090** (Qwen + FLUX) | Mittel | Sequentiell, nicht parallel. vLLM Model-Unloading. 14B statt 32B. | +| 3 | **Pipeline wird zu komplex vor erstem Video** | Hoch | Erste 3 Videos manuell (Bash-Scripts). Orchestrator erst in Phase 6. | +| 4 | **SDXL-Bilder stilistisch inkonsistent** | Mittel | Feste Negativprompts + Style-Presets pro Kanal. Seed-Listen. | +| 5 | **FFmpeg-Assembly hat Artefakte** | Mittel | Ken-Burns-Presets manuell testen. Ueberblendungen standardisieren. | -## Kosten-Schaetzung +## Kosten -| 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. +| Posten | Monatlich | +|---|---| +| Strom ki-tower (24/7) | ~30-40 EUR | +| Strom gpu-worker (bei Bedarf) | ~10-30 EUR | +| GPT-5.4 API (Skripte) | ~3-15 EUR | +| Cloud-TTS Fallback | ~0-10 EUR | +| **Gesamt** | **~45-85 EUR** |