Video/Audio Prozessor
Verarbeitet Video- und Audioaufnahmen in Texttranskripte und visuelle Frame-Aufnahmen für die Analyse. Erkennt automatisch Ihre Hardware und wählt das optimale Transkriptionsmodell, Gerät und Einstellungen aus.
Phase 0: Compute-Umgebung erkennen
Führen Sie dies zu Beginn jeder Ausführung aus. Es bestimmt alles nachfolgende.
python3 -c "
import platform, shutil, subprocess, json
info = {'os': platform.system(), 'arch': platform.machine(), 'ram_gb': 0, 'gpu': 'none', 'vram_gb': 0, 'device': 'cpu', 'dtype': 'float32'}
# RAM
try:
if platform.system() == 'Darwin':
import os; info['ram_gb'] = round(os.sysconf('SC_PAGE_SIZE') * os.sysconf('SC_PHYS_PAGES') / (1024**3))
elif platform.system() == 'Linux':
with open('/proc/meminfo') as f:
for line in f:
if line.startswith('MemTotal'):
info['ram_gb'] = round(int(line.split()[1]) / (1024**2))
break
else:
import ctypes
mem = ctypes.c_ulonglong(0)
ctypes.windll.kernel32.GetPhysicallyInstalledMemory(ctypes.byref(mem))
info['ram_gb'] = round(mem.value / (1024**2))
except: pass
# GPU-Erkennung
try:
import torch
if torch.cuda.is_available():
info['gpu'] = torch.cuda.get_device_name(0)
info['vram_gb'] = round(torch.cuda.get_device_properties(0).total_mem / (1024**3))
info['device'] = 'cuda'
info['dtype'] = 'float16'
elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
info['gpu'] = 'Apple Silicon (MPS)'
info['vram_gb'] = info['ram_gb'] # unified memory
info['device'] = 'mps'
info['dtype'] = 'float16'
elif hasattr(torch, 'hip') or 'AMD' in str(getattr(torch, '_C', '')):
info['gpu'] = 'AMD (ROCm)'
info['device'] = 'cuda' # ROCm verwendet CUDA API
info['dtype'] = 'float16'
except ImportError:
pass
# ffmpeg-Erkennung
info['ffmpeg'] = shutil.which('ffmpeg') is not None
info['ffprobe'] = shutil.which('ffprobe') is not None
print(json.dumps(info))
"
Parsen Sie die JSON-Ausgabe und speichern Sie sie intern als COMPUTE. Präsentieren Sie die Ergebnisse dem Benutzer:
Erkannte Hardware:
- OS: {os} ({arch})
- RAM: {ram_gb} GB
- GPU: {gpu} ({vram_gb} GB VRAM)
- Compute-Gerät: {device}
- ffmpeg: {installiert/fehlt}
Whisper-Engine Auswahl
Basierend auf der Hardware wählen Sie die Transkriptions-Engine:
| Bedingung | Engine | Grund |
|---|---|---|
| CUDA GPU verfügbar | faster-whisper | GPU-beschleunigtes CTranslate2, 4x schneller als Standard Whisper |
| MPS (Apple Silicon) | openai-whisper | Standard Whisper, nutzt MPS-Beschleunigung wenn verfügbar |
| Nur CPU | openai-whisper | Standard Whisper auf CPU, zuverlässiger Fallback |
Modellauswahlmatrix
Basierend auf Hardware und Aufnahmelänge empfehlen Sie ein Modell:
| Bedingung | Empfohlenes Modell | Geschwindigkeit (1h Aufnahme) | Genauigkeit |
|---|---|---|---|
| CUDA >= 8 GB VRAM | large-v3 | ~5 min | Beste |
| CUDA 4-7 GB VRAM | medium | ~8 min | Hoch |
| MPS (Apple Silicon, 16+ GB) | medium | ~15 min | Hoch |
| MPS (Apple Silicon, 8 GB) | small | ~10 min | Gut |
| CPU + RAM >= 16 GB | small | ~30 min | Gut |
| CPU + RAM < 16 GB | base | ~15 min | Ausreichend |
Präsentieren Sie die Empfehlung und lassen Sie den Benutzer wählen:
AskUserQuestion: "Welches Transkriptionsmodell soll ich verwenden?"
Optionen:
- [Empfohlenes Modell] (Empfohlen) - [Grund basierend auf ihrer Hardware]
- large-v3 - Beste Genauigkeit, benötigt 8+ GB VRAM oder viel RAM
- medium - Hohe Genauigkeit, ausgewogene Geschwindigkeit
- small - Gute Genauigkeit, schnellere Verarbeitung
- base - Ausreichend für die meisten Meetings, am schnellsten
Speichern Sie das gewählte Modell als WHISPER_MODEL und die Engine als WHISPER_ENGINE.
Phase 1: Aufnahme identifizieren
Finden Sie die Datei. Zoom-Aufnahmen folgen typischerweise dem Muster:
GMT{datum}-{uhrzeit}_Recording_{auflösung}.mp4(Video)GMT{datum}-{uhrzeit}_Recording.m4a(nur Audio)GMT{datum}-{uhrzeit}_RecordingnewChat.txt(Chat-Protokoll)
Überprüfen Sie auf alle drei Artefakte. Lesen Sie zuerst die Chat-Datei (sie ist klein und gibt sofortigen Kontext).
Phase 2: Abhängigkeiten installieren
Überprüfen und installieren Sie, was basierend auf der Plattform benötigt wird.
ffmpeg
# Überprüfen, ob ffmpeg verfügbar ist
ffmpeg -version 2>&1 | head -1
ffprobe -version 2>&1 | head -1
Wenn ffmpeg fehlt, installieren Sie basierend auf der Plattform:
| Plattform | Installationsbefehl |
|---|---|
| macOS (Homebrew) | brew install ffmpeg |
| macOS (kein Homebrew) | Benutzer anleiten, zuerst Homebrew und dann ffmpeg zu installieren |
| Ubuntu/Debian | sudo apt update && sudo apt install -y ffmpeg |
| Fedora/RHEL | sudo dnf install -y ffmpeg |
| Arch Linux | sudo pacman -S ffmpeg |
| Windows (winget) | winget install Gyan.FFmpeg |
| Windows (choco) | choco install ffmpeg |
| Windows (scoop) | scoop install ffmpeg |
Python + Whisper
python3 -c "import torch; print(torch.__version__)" 2>&1
Wenn torch fehlt, installieren Sie basierend auf der Plattform:
| Plattform | Installationsbefehl |
|---|---|
| macOS (MPS) | pip3 install torch torchvision torchaudio |
| Linux (CUDA) | pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 |
| Linux (ROCm) | pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.0 |
| Linux/Windows (CPU) | pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu |
| Windows (CUDA) | pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 |
Installieren Sie dann die Transkriptions-Engine:
# Für CUDA-Systeme (faster-whisper mit CTranslate2-Beschleunigung)
pip3 install faster-whisper
# Für MPS / CPU-Systeme (Standard OpenAI Whisper)
pip3 install openai-whisper
Phase 3: Dauer ermitteln
Verwenden Sie ffprobe (plattformübergreifend), um die Dateidauer zu ermitteln:
ffprobe -v quiet -show_entries format=duration -of csv=p=0 "/path/to/file"
Dies gibt die Dauer in Sekunden zurück. Konvertieren Sie in ein lesbares Format und zeigen Sie es dem Benutzer an. Verwenden Sie dies, um die Transkriptionszeit basierend auf dem ausgewählten Modell und der Hardware zu schätzen.
Präsentieren Sie den Plan:
Verarbeitungsplan:
- Datei: {dateiname} ({dauer})
- Engine: {WHISPER_ENGINE} mit {WHISPER_MODEL} Modell auf {device}
- Geschätzte Transkriptionszeit: {schätzung}
- Frame-Extraktion: 1 pro Minute ({frame_count} Frames)
Möchten Sie etwas anpassen, bevor ich beginne?
Zeitschätzungen
| Gerät | base | small | medium | large-v3 |
|---|---|---|---|---|
| CUDA (RTX 3060+) | ~1 min/Std | ~2 min/Std | ~4 min/Std | ~5 min/Std |
| CUDA (faster-whisper) | ~30s/Std | ~1 min/Std | ~2 min/Std | ~3 min/Std |
| MPS (M1/M2/M3/M4) | ~3 min/Std | ~6 min/Std | ~15 min/Std | ~25 min/Std |
| CPU (16GB+ RAM) | ~8 min/Std | ~15 min/Std | ~30 min/Std | ~60 min/Std |
Phase 4: Visuelle Frames extrahieren
Extrahieren Sie einen Frame pro Minute für visuellen Kontext. Verwenden Sie ein plattformübergreifendes temporäres Verzeichnis:
# Temporäres Verzeichnis erstellen (plattformübergreifend)
python3 -c "import tempfile, os; d = os.path.join(tempfile.gettempdir(), 'av-frames'); os.makedirs(d, exist_ok=True); print(d)"
Dann Frames extrahieren:
ffmpeg -i "/path/to/video.mp4" \
-vf "fps=1/60,scale=1280:-1" -q:v 3 {TEMP_DIR}/frame_%03d.jpg
Verwenden Sie das Read-Tool, um jeden Frame zu betrachten. Frames zeigen:
- Bildschirmfreigaben (Code, Folien, UIs)
- Teilnehmernamen (unten links in jedem Videofenster)
- Zeitstempel (falls in der Bildschirmfreigabe sichtbar)
Phase 5: Audio transkribieren
Führen Sie die Transkriptions-Engine aus. Wählen Sie den richtigen Code basierend auf WHISPER_ENGINE:
faster-whisper (CUDA-Systeme)
from faster_whisper import WhisperModel
import json
model = WhisperModel("{WHISPER_MODEL}", device="cuda", compute_type="float16")
segments, info = model.transcribe("/path/to/audio", beam_size=5, language="en")
results = []
for segment in segments:
results.append({
"start": segment.start,
"end": segment.end,
"text": segment.text.strip()
})
# Zeitgestempeltes Transkript speichern
with open("{TEMP_DIR}/transcript.json", "w") as f:
json.dump({"language": info.language, "segments": results}, f, indent=2)
with open("{TEMP_DIR}/transcript.txt", "w") as f:
for seg in results:
start = int(seg["start"])
mins, secs = divmod(start, 60)
f.write(f"[{mins:02d}:{secs:02d}] {seg['text']}\n")
print(f"Transkribiert {len(results)} Segmente")
openai-whisper (MPS / CPU-Systeme)
import whisper, json
model = whisper.load_model("{WHISPER_MODEL}")
result = model.transcribe("/path/to/audio", verbose=False)
# Zeitgestempeltes Transkript speichern
with open("{TEMP_DIR}/transcript.json", "w") as f:
json.dump(result, f, indent=2)
with open("{TEMP_DIR}/transcript.txt", "w") as f:
for seg in result["segments"]:
start = int(seg["start"])
mins, secs = divmod(start, 60)
f.write(f"[{mins:02d}:{secs:02d}] {seg['text'].strip()}\n")
print(f"Transkribiert {len(result['segments'])} Segmente")
Führen Sie die Transkription im Hintergrund aus, da sie viel Zeit in Anspruch nimmt. Während sie läuft, überprüfen Sie die extrahierten Frames visuell.
Phase 6: Synthese
Kombinieren Sie visuelle Frames + Transkript + Chat, um ein Verständnis aufzubauen:
- Wer: Teilnehmer anhand von Videobezeichnungen und Stimmzuweisung identifizieren
- Was: Was auf dem Bildschirm gezeigt wurde (Demos, Folien, Code)
- Gesagt: Wichtige Zitate, Entscheidungen, Anforderungen, Feedback
- Aktionspunkte: Explizite Zusagen und Folgemaßnahmen
Modellreferenz
| Modell | Parameter | Geschwindigkeit | Genauigkeit | Am besten geeignet für |
|---|---|---|---|---|
tiny | 39M | Sehr schnell | Niedrig | Schnelle Überprüfung, ob Audio verwendbar ist |
base | 74M | Schnell | Ausreichend | Standard für kurze/klare Meetings |
small | 244M | Mäßig | Gut | Allgemeine Meetings mit Akzenten |
medium | 769M | Langsam | Hoch | Wichtige Meetings, kundenorientiert |
large-v3 | 1.5B | Sehr langsam | Am besten | Kritische Aufnahmen, schlechte Audioqualität |
Tipps
- Führen Sie die Transkription immer im Hintergrund aus, während Sie Frames visuell überprüfen
- Lesen Sie Frames in Batches von 8 (Werkzeug-Parallelitätsgrenze)
- Standard Whisper verwendet FP32 auf CPU und MPS; faster-whisper verwendet CTranslate2 mit FP16 auf CUDA
- Bei sehr langen Aufnahmen (>1 Stunde) erwägen Sie, das Audio zuerst zu splitten
- Chat-Dateien von Zoom enthalten Zeitstempel und geteilte Links; lesen Sie sie zuerst für schnellen Kontext
- Unter Windows verwenden Sie Schrägstriche oder Raw-Strings für Dateipfade in Python
Fehlerbehandlung
| Fehler | Ursache | Lösung |
|---|---|---|
ffmpeg: command not found | ffmpeg nicht installiert | Installieren gemäß Plattformtabelle oben |
No module named 'whisper' | Whisper nicht installiert | pip3 install openai-whisper |
No module named 'faster_whisper' | faster-whisper nicht installiert | pip3 install faster-whisper |
CUDA out of memory | Modell zu groß für VRAM | Auf kleineres Modell umsteigen |
RuntimeError: MPS backend | MPS-Problem auf älterem macOS | macOS aktualisieren, oder auf CPU zurückfallen mit PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0 |
torch not found | Python-Abhängigkeiten fehlen | torch gemäß Plattformtabelle oben installieren |
| Verworrenes Transkript | Falsche Sprache oder schlechtes Audio | Versuchen, language="en" anzugeben oder ein größeres Modell verwenden |
| Sehr langsame Transkription | Großes Modell auf CPU ausgeführt | Auf base oder small Modell umsteigen |