KI-Video PLAN.md komplett ueberarbeitet: konkrete Architektur, Rollenverteilung, v1/v2 Split, 7-Phasen-Umsetzung

This commit is contained in:
root 2026-03-16 11:18:58 +07:00
parent ea7f04f0e6
commit cf4dbd6c11

View file

@ -3,8 +3,8 @@
## Ziel
Lokale, weitgehend automatisierte Produktionsstrecke fuer YouTube-Videos im Commentary-/Erklaerstil.
Kein Spielzeug-Demo, sondern eine praktisch nutzbare Pipeline: Thema rein → fertiges Video raus.
Lokale, praktisch nutzbare Produktionsstrecke fuer YouTube-Videos im Commentary-/Erklaerstil.
Kein Spielzeug-Demo, kein Forschungsprojekt: Thema rein → fertiges Video raus.
## Videoformat
@ -12,89 +12,30 @@ Kein Spielzeug-Demo, sondern eine praktisch nutzbare Pipeline: Thema rein → fe
|---|---|
| **Typ** | Commentary, Erklaervideos, Meinungs-/Analyseformate |
| **Stil** | Sprecherstimme + Bilder + leichte Bewegung + Einblendungen |
| **Optional** | Sprechender Avatar (SadTalker) |
| **Optional** | Sprechender Avatar (SadTalker) — erst ab v2 |
| **Nicht** | Realfilm, Hollywood-VFX, aufwendige 3D-Animation |
| **Vorbild** | Kanaele mit klarer Erzaehlung, guter Struktur, visueller Unterstuetzung |
## Pipeline-Schritte
## Pipeline
```
1. Themenfindung / Recherche
1. Themenfindung / Recherche (manuell)
2. Skript-Erstellung (lokales LLM)
2. Skript-Erstellung → Qwen 14B (ki-tower)
3. Bildgenerierung (Szenen / Illustrationen)
3. Bildgenerierung → FLUX.1-dev (ki-tower)
4. Sprachausgabe / Voiceover (TTS)
4. Voiceover → Piper TTS (CPU, ki-tower)
5. Optional: Avatar / sprechendes Gesicht
5. Compositing → FFmpeg + Ken-Burns (CPU, ki-tower)
6. Zusammenschnitt + Ken-Burns + Compositing
6. Encoding → FFmpeg + NVENC (ki-tower)
7. Export fuer YouTube
7. Export → fertiges MP4 fuer YouTube
```
## Geplante Komponenten
### Textgenerierung (Skripte)
| Komponente | Modell | VRAM | Anmerkung |
|---|---|---|---|
| **Skript-LLM** | Qwen 2.5 32B (Q4_K_M) | ~20 GB | Passt auf RTX 3090 (24 GB), eng aber machbar |
| **Alternative** | Qwen 2.5 14B (Q5) | ~12 GB | Komfortabler, laesst Platz fuer andere Tasks |
| **Fallback** | Qwen 2.5 7B | ~6 GB | Fuer Entwuerfe/Vorarbeit, parallel moeglich |
Realistisch: 32B fuer finale Skripte, 7B/14B fuer Brainstorming und Iteration.
32B belegt fast den gesamten VRAM — andere GPU-Tasks muessen warten.
### Bildgenerierung
| Komponente | Modell | VRAM | Anmerkung |
|---|---|---|---|
| **Bilder** | FLUX.1-dev | ~12 GB | Gute Qualitaet, laeuft auf RTX 3090 |
| **Alternative** | SDXL | ~7 GB | Weniger VRAM, mehr Flexibilitaet |
| **Upscaling** | Real-ESRGAN | ~2 GB | Nachschaerfung auf 4K |
FLUX.1-dev liefert bessere Qualitaet als SDXL, braucht aber mehr VRAM.
Kann NICHT gleichzeitig mit Qwen 32B laufen — sequentiell.
### Sprachausgabe (TTS)
| Komponente | Modell | VRAM | Anmerkung |
|---|---|---|---|
| **TTS** | XTTS v2 (Coqui) | ~2-4 GB | Deutsche Stimme, Voice-Cloning moeglich |
| **Alternative** | Piper TTS | CPU-only | Schneller, weniger natuerlich |
| **Fallback** | OpenAI TTS API | — | Beste Qualitaet, kostet Geld |
XTTS v2 ist der beste Kompromiss: lokal, deutsch, Stimme klonbar.
Kann auf GPU oder CPU laufen. Bei GPU: parallel zu leichteren Tasks moeglich.
### Avatar (optional)
| Komponente | Modell | VRAM | Anmerkung |
|---|---|---|---|
| **Talking Head** | SadTalker | ~4-6 GB | Foto + Audio → sprechendes Gesicht |
| **Alternative** | Wav2Lip | ~2 GB | Einfacher, weniger natuerlich |
| **Zukunft** | LivePortrait / EMO | variabel | Bessere Qualitaet, noch nicht stabil |
SadTalker ist ausgereift und braucht wenig VRAM.
Input: 1 Foto + 1 Audiodatei → Video mit Lippensync.
### Video-Compositing
| Komponente | Tool | GPU? | Anmerkung |
|---|---|---|---|
| **Schnitt** | FFmpeg | Nein (CPU) | Ken-Burns, Ueberblendungen, Text-Overlays |
| **Sequenzierung** | Python + moviepy | Nein | Szenen zusammenfuegen |
| **Encoding** | FFmpeg + NVENC | Optional | GPU-beschleunigtes Encoding |
| **Untertitel** | Whisper + FFmpeg | ~1.5 GB | Automatische Untertitel |
FFmpeg ist das Rueckgrat — robust, scriptbar, keine GPU noetig fuer die meisten Operationen.
NVENC (RTX 3090) fuer schnelles Encoding im letzten Schritt.
## Hardware
### Hauptmaschine: ki-tower (Muldenstein, geplant)
### ki-tower — Hauptmaschine (Muldenstein, geplant)
| Eigenschaft | Wert |
|---|---|
@ -102,69 +43,98 @@ NVENC (RTX 3090) fuer schnelles Encoding im letzten Schritt.
| **RAM** | 64 GB DDR5 |
| **GPU** | NVIDIA RTX 3090 (24 GB VRAM) |
| **Storage** | 1 TB NVMe |
| **OS** | Debian 12 oder Proxmox (noch offen) |
| **OS** | Debian 12 + Docker + CUDA |
| **Logischer Name** | ki-tower |
| **Rolle** | Chef. Alle schweren Aufgaben, Orchestrierung, Hauptpfad. |
### Unterstuetzung: gpu-worker (Mining-Rig, Muldenstein, geplant)
### gpu-worker — AMD-Rig (Muldenstein, geplant)
| Eigenschaft | Wert |
|---|---|
| **GPUs** | Mehrere AMD RX 6600 XT (je 8 GB VRAM) |
| **Funktion** | Worker-Pool fuer leichtere Pipeline-Schritte |
| **Geeignet fuer** | Upscaling, TTS, Whisper, Batch-Bildgenerierung (SDXL) |
| **Nicht geeignet fuer** | Qwen 32B, FLUX.1-dev, SadTalker auf hoher Qualitaet |
| **ROCm** | Inoffiziell (gfx1032), 1-Karten-Test steht aus |
| **GPUs** | 8x AMD RX 6600 XT Dual (je 8 GB GDDR6, PCIe 4.0 x8) |
| **Chip** | Navi 23 (gfx1032), RDNA 2 |
| **ROCm** | Inoffiziell (HSA_OVERRIDE_GFX_VERSION=10.3.0 noetig) |
| **OS** | Debian 12 + Docker + ROCm (kein Proxmox) |
| **Logischer Name** | gpu-worker |
| **Rolle** | Arbeiterkolonne. Nur Nebenjobs, nichts Produktionskritisches. |
| **Status** | 1-Karten-Test steht aus. Kein Aufbau vor positivem Test. |
### Arbeitsteilung
## Rollenverteilung — Was laeuft wo
### ki-tower (RTX 3090) — Hauptpfad
| Aufgabe | Modell | VRAM | Anmerkung |
|---|---|---|---|
| **Skripte** | Qwen 2.5 14B (Q5) | ~12 GB | Default. 32B nur wenn 14B nachweislich nicht reicht. |
| **Hauptbilder** | FLUX.1-dev | ~12 GB | Visueller Kern der Videos |
| **TTS (v1)** | Piper TTS | CPU-only | Fuer v1 ausreichend, kein VRAM-Verbrauch |
| **TTS (v2)** | XTTS v2 | ~4 GB | Upgrade in v2, bessere Stimme, Voice-Cloning |
| **Avatar (v2)** | SadTalker | ~6 GB | Optional, erst ab v2 |
| **Compositing** | FFmpeg | CPU | Ken-Burns, Ueberblendungen, Overlays |
| **Encoding** | FFmpeg + NVENC | ~1 GB | Hardware-beschleunigt |
| **Orchestrator** | Python | CPU | Steuert alle Schritte |
Wichtig: Schritte laufen SEQUENTIELL. Nur eine schwere GPU-Aufgabe gleichzeitig.
14B statt 32B als Default — laesst 12 GB VRAM frei, kein Flush zwischen Schritten noetig.
### gpu-worker (RX 6600 XT) — Nebenjobs
| Aufgabe | VRAM | Karten | Anmerkung |
|---|---|---|---|
| **Whisper** (Untertitel) | ~1.5 GB | 1 | whisper.cpp + HIP, gut getestet auf AMD |
| **Real-ESRGAN** (Upscaling) | ~2 GB | 1 | Einfache Inference, ROCm-Support vorhanden |
| **SDXL** (Nebenbilder, Batch) | ~7 GB | 1-2 | NUR wenn ROCm-Test erfolgreich |
| **Piper TTS** | CPU | 0 | Braucht keine GPU, nutzt CPU/RAM des Rigs |
| **Embeddings** (lokale) | ~1 GB | 1 | Fuer Jarvis/RAG, nicht Video-Pipeline |
Realistisch nutzbar: 3-4 von 8 Karten. Rest idle lassen oder ausbauen (Strom sparen).
Das Rig wird NICHT 24/7 laufen — nur einschalten wenn Batch-Jobs anstehen.
### NICHT auf das Rig
| Aufgabe | Warum nicht |
|---|---|
| Qwen (jede Groesse) | PyTorch + ROCm + Textgen auf inoffizieller HW = Frust |
| FLUX.1-dev | >8 GB VRAM, CUDA-optimiert |
| SadTalker | CUDA-only in der Praxis |
| XTTS v2 | PyTorch + ROCm ungetestet — erst v2 wenn ROCm stabil |
| Irgendwas im Hauptpfad | Rig-Absturz darf Produktion nicht blockieren |
## Worker-Architektur
```
ki-tower (RTX 3090, 24 GB) gpu-worker (RX 6600 XT, je 8 GB)
├── Qwen 32B (Skripte) ├── SDXL Batch (Nebenbilder)
├── FLUX.1-dev (Hauptbilder) ├── Real-ESRGAN (Upscaling)
├── SadTalker (Avatar) ├── XTTS v2 / Piper (TTS)
├── FFmpeg + NVENC (Finaler Render) ├── Whisper (Untertitel)
└── Orchestrierung └── Vorverarbeitung
ki-tower (3090, Chef) gpu-worker (RX 6600 XT, Arbeiter)
┌─────────────────────────┐ ┌──────────────────────────────┐
│ Orchestrator (Python) │ │ Debian 12 + Docker + ROCm │
│ ├── Job Queue (SQLite) │ Tailscale │ │
│ ├── /api/submit-job │◄────────────►│ GPU #0: whisper-worker :8501 │
│ ├── /api/job-status │ │ GPU #1: upscale-worker :8502 │
│ └── /api/get-result │ │ GPU #2: sdxl-worker :8503 │
│ │ │ (GPU #3-7: idle/aus) │
│ Qwen 14B (vLLM) :8401 │ │ │
│ FLUX.1 (ComfyUI):8402 │ │ piper-tts (CPU) :8504 │
│ FFmpeg (lokal) │ └──────────────────────────────┘
└─────────────────────────┘
```
## VRAM-Budget pro Pipeline-Schritt (RTX 3090)
Prinzipien:
- 1 Container = 1 GPU = 1 Aufgabe. Feste Zuordnung, kein dynamisches Scheduling.
- SQLite als Job-Queue. Ein User, nicht tausend. Eine Datei reicht.
- HTTP-APIs pro Worker. Orchestrator ruft per REST auf, pollt Status.
- Kein Service-Mesh, kein Kubernetes. Tailscale verbindet die zwei Maschinen.
Die Schritte laufen SEQUENTIELL, nicht parallel — nur eine schwere Aufgabe gleichzeitig:
## VRAM-Budget (ki-tower, sequentiell)
```
Schritt 1: Skript → Qwen 32B → ~20 GB VRAM → entladen
Schritt 2: Bilder → FLUX.1-dev → ~12 GB VRAM → entladen
Schritt 3: TTS → XTTS v2 → ~4 GB VRAM → entladen
Schritt 4: Avatar → SadTalker → ~6 GB VRAM → entladen
Schritt 5: Compositing → FFmpeg (CPU) → 0 GB VRAM
Schritt 6: Encoding → NVENC → ~1 GB VRAM
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
```
Gesamtzeit pro Video (geschaetzt, 10 Min Video):
- Skript: 5-15 Min
- Bilder (20-30 Stueck): 20-40 Min
- TTS: 5-10 Min
- Avatar: 10-20 Min
- Compositing: 5-10 Min
- Encoding: 2-5 Min
- **Gesamt: ca. 1-2 Stunden pro 10-Min-Video**
## Architektur
```
Orchestrator (Python)
├── /scripts/ → Skript-Generierung (Qwen via llama.cpp / vLLM)
├── /images/ → Bild-Generierung (ComfyUI / FLUX)
├── /audio/ → TTS (XTTS v2 Server)
├── /avatar/ → Talking Head (SadTalker)
├── /compose/ → Video-Assembly (FFmpeg + moviepy)
├── /export/ → Finaler Render + Upload-Vorbereitung
└── /projects/ → Pro Video ein Projektordner mit allen Assets
```
Jeder Schritt ist ein eigener Service/Container:
- Kann einzeln gestartet/gestoppt werden
- Belegt VRAM nur wenn aktiv
- Austauschbar (z.B. FLUX → SDXL, XTTS → Piper)
Mit Qwen 14B statt 32B: kein VRAM-Flush zwischen Schritt 1 und 2 noetig.
Geschaetzte Produktionszeit: ~1-2 Stunden pro 10-Min-Video.
## Nicht-Ziele
@ -172,63 +142,137 @@ Jeder Schritt ist ein eigener Service/Container:
- Keine Bastelwiese ohne Ergebnis
- Keine Dauerabhaengigkeit von Cloud-Abos
- Keine Architektur die nur auf dem Papier funktioniert
- Kein Hollywood-Kino
- Kein sofortiger Avatar als Kernbestandteil
- Keine ueberkomplizierte Proxmox-/VM-Orgie auf dem Rig
- Kein Schoenreden von AMD-ROCm-Limitierungen
## Stufenplan
## v1 — Minimal Viable Pipeline (nur ki-tower)
### Stufe 1 — Grundlagen (ki-tower aufbauen)
| Was | Status |
v1 beweist: die Pipeline funktioniert. Kein Rig, kein Avatar, keine Automatisierung.
```
v1 Pipeline (alles auf ki-tower):
Thema (manuell)
Qwen 14B → Skript (vLLM, :8401)
FLUX.1-dev → 20-30 Bilder (ComfyUI, :8402)
Piper TTS → Voiceover (CPU, :8504)
FFmpeg → Ken-Burns + Audio + Overlays → fertiges MP4
```
Was v1 NICHT hat:
- Keinen Avatar
- Kein GPU-Worker-Rig
- Keine automatische Orchestrierung (Schritte manuell anstossen)
- Keinen YouTube-Upload
- Keine XTTS v2 (Piper reicht fuer v1)
Erfolgskriterium v1: Ein 10-Minuten-Video komplett lokal produziert.
## v2 — Erweiterungen (nach funktionierender v1)
| Feature | Abhaengigkeit |
|---|---|
| ki-tower Hardware zusammenbauen | geplant |
| Debian 12 + NVIDIA-Treiber + CUDA + Docker | geplant |
| llama.cpp / vLLM mit Qwen 2.5 installieren | geplant |
| Erster Skript-Test: Thema → strukturiertes Skript | geplant |
| **XTTS v2** statt Piper | Auf ki-tower (3090), bessere Stimme |
| **SadTalker Avatar** | Auf ki-tower, optional pro Video |
| **GPU-Worker-Rig** | ROCm 1-Karten-Test muss positiv sein |
| **Python-Orchestrator** | Erst manuell verstehen, dann automatisieren |
| **Qwen 32B** statt 14B | Nur wenn 14B-Skripte nachweislich zu schwach |
### Stufe 2 — Bilder + TTS
| Was | Status |
## v3+ — Spaeter
| Feature | Anmerkung |
|---|---|
| ComfyUI + FLUX.1-dev installieren | geplant |
| XTTS v2 Server aufsetzen (Docker) | geplant |
| Test: Skript → passende Bilder + Voiceover | geplant |
| 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 |
### Stufe 3 — Avatar + Compositing
| Was | Status |
|---|---|
| SadTalker installieren | geplant |
| FFmpeg-Pipeline: Bilder + Audio + Avatar → Video | geplant |
| Erster kompletter Durchlauf: Thema → fertiges Video | geplant |
## Umsetzungsreihenfolge
### Stufe 4 — Orchestrierung + Automatisierung
| Was | Status |
|---|---|
| Python-Orchestrator: alle Schritte verkettet | geplant |
| Projektordner-Struktur (Assets pro Video) | geplant |
| GPU-Worker-Integration (falls ROCm-Test erfolgreich) | geplant |
```
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"
### Stufe 5 — Produktion + Optimierung
| Was | Status |
|---|---|
| Regelmaessige Videoproduktion (1-2 pro Woche) | geplant |
| Prompt-Templates fuer verschiedene Videoformate | geplant |
| Qualitaetskontrolle + Feedback-Loop | geplant |
| Optional: Semi-automatischer YouTube-Upload | geplant |
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"
## Offene Entscheidungen
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"
| Frage | Optionen | Tendenz |
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 — RX 6600 XT 1-Karten-Test (Woche 7-8)
├── Eine Karte in Testrechner
├── Debian + ROCm + whisper.cpp + Real-ESRGAN testen
├── Go/No-Go Entscheidung fuer Rig-Aufbau
└── Ergebnis: "Weiss ob das Rig sich lohnt"
PHASE 6 — Rig-Integration (nur wenn Phase 5 positiv)
├── Rig aufbauen (3-4 Karten, Debian + Docker + ROCm)
├── Whisper-Worker + Upscale-Worker aufsetzen
├── In Pipeline einbinden via Tailscale
└── Ergebnis: "Nebenjobs laufen parallel auf dem Rig"
PHASE 7 — v2 Features (nach stabiler Produktion)
├── XTTS v2 auf ki-tower (bessere Stimme)
├── SadTalker Avatar (optional pro Video)
├── Python-Orchestrator (automatische Verkettung)
└── Ergebnis: "Semi-automatische Videoproduktion"
```
## Entscheidungen (getroffen)
| Frage | Entscheidung | Begruendung |
|---|---|---|
| OS fuer ki-tower | Debian 12 vs Proxmox | Debian (einfacher fuer GPU) |
| LLM-Server | llama.cpp vs vLLM vs Ollama | vLLM (schneller bei Batch) |
| Bild-UI | ComfyUI vs API-only | ComfyUI (flexibler, Workflows) |
| TTS Sprache | Deutsch-only vs Multi | Deutsch zuerst, Englisch spaeter |
| Avatar ja/nein | Immer vs nur bei manchen Videos | Optional pro Video |
| OS ki-tower | **Debian 12** | Einfacher fuer GPU, Docker, kein Hypervisor-Overhead |
| OS gpu-worker | **Debian 12** | GPU-Passthrough in Proxmox auf AMD = Kampf |
| LLM-Modell | **Qwen 14B** (Default) | 12 GB VRAM, laesst Platz. 32B nur als Upgrade. |
| LLM-Server | **vLLM** | Schneller als llama.cpp bei Batch, Model-Unloading |
| Bildgenerierung | **ComfyUI + FLUX.1-dev** | Flexibel, Workflow-basiert, gute Qualitaet |
| TTS v1 | **Piper TTS** (CPU) | Kein GPU-Verbrauch, sofort einsatzbereit |
| TTS v2 | **XTTS v2** (3090) | Voice-Cloning, natuerlichere Stimme |
| Avatar | **Nicht in v1** | Nice-to-have, nicht Kernprodukt |
| Job-Queue | **SQLite** | Ein User, kein Redis/RabbitMQ noetig |
| Netzwerk | **Tailscale** | Verbindet ki-tower + gpu-worker, fertig |
## Risiken
| Risiko | Schwere | Mitigation |
| # | Risiko | Wahrscheinlichkeit | Impact | Mitigation |
|---|---|---|---|---|
| 1 | **ROCm auf RX 6600 XT instabil** | Hoch | Mittel | 1-Karten-Test VOR Rig-Aufbau. Fallback: alles auf 3090. |
| 2 | **Piper TTS deutsch zu robotisch** | Mittel | Hoch | Testen. Wenn zu schlecht: OpenAI TTS als Bruecke (~0.50 EUR/Video). XTTS in v2. |
| 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 | **Stromkosten Rig vs. Nutzen** | Mittel | Niedrig | Nur 3-4 Karten bestuecken. Rig nur bei Batch-Jobs einschalten. |
## Kosten-Schaetzung
| Posten | Einmalig | Monatlich |
|---|---|---|
| VRAM-Engpass bei 32B + Bildern | Mittel | Sequentiell arbeiten, 14B als Alternative |
| TTS-Qualitaet Deutsch | Mittel | XTTS v2 Voice-Cloning testen, Fallback OpenAI |
| Avatar wirkt unnatuerlich | Niedrig | Avatar nur optional, kann weggelassen werden |
| Pipeline zu komplex | Mittel | Stufe fuer Stufe, jeder Schritt einzeln testbar |
| GPU-Worker ROCm-Probleme | Mittel | 1-Karten-Test, Fallback: alles auf ki-tower |
| ki-tower Hardware | vorhanden | — |
| gpu-worker Hardware | vorhanden | — |
| Strom ki-tower (24/7) | — | ~30-40 EUR |
| Strom gpu-worker (bei Bedarf) | — | ~10-30 EUR (nicht 24/7) |
| Cloud-APIs (Fallback TTS) | — | ~5-10 EUR |
| **Gesamt** | 0 EUR | ~45-80 EUR |
Zum Vergleich: Vollstaendig cloud-basierte Videoproduktion (Runway, ElevenLabs, GPT-4) = 100-300 EUR/Monat.