Processeur Vidéo/Audio
Traite les enregistrements vidéo et audio en transcriptions textuelles et en captures d'images clés pour analyse. Détecte automatiquement votre matériel et sélectionne le modèle de transcription, le périphérique et les paramètres optimaux.
Phase 0 : Détection de l'Environnement de Calcul
Exécutez ceci au début de chaque invocation. Cela détermine tout ce qui suit.
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
# Détection GPU
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'] # mémoire unifiée
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 utilise l'API CUDA
info['dtype'] = 'float16'
except ImportError:
pass
# Détection ffmpeg
info['ffmpeg'] = shutil.which('ffmpeg') is not None
info['ffprobe'] = shutil.which('ffprobe') is not None
print(json.dumps(info))
"
Analysez la sortie JSON et stockez-la en interne sous le nom COMPUTE. Présentez les résultats à l'utilisateur :
Matériel détecté :
- OS : {os} ({arch})
- RAM : {ram_gb} Go
- GPU : {gpu} ({vram_gb} Go VRAM)
- Périphérique de calcul : {device}
- ffmpeg : {installé/manquant}
Sélection du Moteur Whisper
En fonction du matériel, choisissez le moteur de transcription :
| Condition | Moteur | Raison |
|---|---|---|
| GPU CUDA disponible | faster-whisper | CTranslate2 accéléré par GPU, 4x plus rapide que Whisper standard |
| MPS (Apple Silicon) | openai-whisper | Whisper standard, utilise l'accélération MPS quand disponible |
| CPU uniquement | openai-whisper | Whisper standard sur CPU, solution de repli fiable |
Matrice de Sélection du Modèle
En fonction du matériel et de la durée d'enregistrement, recommandez un modèle :
| Condition | Modèle Recommandé | Vitesse (enreg. 1h) | Précision |
|---|---|---|---|
| CUDA >= 8 Go VRAM | large-v3 | ~5 min | Meilleure |
| CUDA 4-7 Go VRAM | medium | ~8 min | Élevée |
| MPS (Apple Silicon, 16+ Go) | medium | ~15 min | Élevée |
| MPS (Apple Silicon, 8 Go) | small | ~10 min | Bonne |
| CPU + RAM >= 16 Go | small | ~30 min | Bonne |
| CPU + RAM < 16 Go | base | ~15 min | Adéquate |
Présentez la recommandation et laissez l'utilisateur choisir :
AskUserQuestion: "Quel modèle de transcription dois-je utiliser ?"
Options:
- [Modèle recommandé] (Recommandé) - [raison basée sur leur matériel]
- large-v3 - Meilleure précision, nécessite 8+ Go VRAM ou beaucoup de RAM
- medium - Haute précision, vitesse équilibrée
- small - Bonne précision, traitement plus rapide
- base - Adéquat pour la plupart des réunions, le plus rapide
Stockez le modèle choisi sous le nom WHISPER_MODEL et le moteur sous le nom WHISPER_ENGINE.
Phase 1 : Identifier l'Enregistrement
Trouvez le fichier. Les enregistrements Zoom suivent généralement le motif :
GMT{date}-{time}_Recording_{résolution}.mp4(vidéo)GMT{date}-{time}_Recording.m4a(audio uniquement)GMT{date}-{time}_RecordingnewChat.txt(journal de chat)
Vérifiez la présence des trois artefacts. Lisez d'abord le fichier de chat (il est petit et fournit un contexte immédiat).
Phase 2 : Installer les Dépendances
Vérifiez et installez ce qui est nécessaire en fonction de la plateforme.
ffmpeg
# Vérifiez si ffmpeg est disponible
ffmpeg -version 2>&1 | head -1
ffprobe -version 2>&1 | head -1
Si ffmpeg est manquant, installez-le selon la plateforme :
| Plateforme | Commande d'installation |
|---|---|
| macOS (Homebrew) | brew install ffmpeg |
| macOS (sans Homebrew) | Guidez l'utilisateur pour installer Homebrew d'abord, puis ffmpeg |
| 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
Si torch est manquant, installez-le selon la plateforme :
| Plateforme | Commande d'installation |
|---|---|
| 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 |
Installez ensuite le moteur de transcription :
# Pour les systèmes CUDA (faster-whisper avec accélération CTranslate2)
pip3 install faster-whisper
# Pour les systèmes MPS / CPU (Whisper OpenAI standard)
pip3 install openai-whisper
Phase 3 : Obtenir la Durée
Utilisez ffprobe (multi-plateforme) pour obtenir la durée du fichier :
ffprobe -v quiet -show_entries format=duration -of csv=p=0 "/chemin/vers/fichier"
Cela renvoie la durée en secondes. Convertissez-la en un format lisible et affichez-la à l'utilisateur. Utilisez-la pour estimer le temps de transcription basé sur le modèle sélectionné et le matériel.
Présentez le plan :
Plan de traitement :
- Fichier : {nomfichier} ({durée})
- Moteur : {WHISPER_ENGINE} avec le modèle {WHISPER_MODEL} sur {device}
- Temps de transcription estimé : {estimation}
- Extraction d'images : 1 par minute ({nombre_images} images)
Souhaitez-vous ajuster quelque chose avant de commencer ?
Estimations de Temps
| Périphérique | base | small | medium | large-v3 |
|---|---|---|---|---|
| CUDA (RTX 3060+) | ~1 min/h | ~2 min/h | ~4 min/h | ~5 min/h |
| CUDA (faster-whisper) | ~30 s/h | ~1 min/h | ~2 min/h | ~3 min/h |
| MPS (M1/M2/M3/M4) | ~3 min/h | ~6 min/h | ~15 min/h | ~25 min/h |
| CPU (16 Go+ RAM) | ~8 min/h | ~15 min/h | ~30 min/h | ~60 min/h |
Phase 4 : Extraire les Images Clés
Extrayez une image par minute pour le contexte visuel. Utilisez un répertoire temporaire multi-plateforme :
# Créer un répertoire temporaire (multi-plateforme)
python3 -c "import tempfile, os; d = os.path.join(tempfile.gettempdir(), 'av-frames'); os.makedirs(d, exist_ok=True); print(d)"
Extrayez ensuite les images :
ffmpeg -i "/chemin/vers/video.mp4" \
-vf "fps=1/60,scale=1280:-1" -q:v 3 {TEMP_DIR}/frame_%03d.jpg
Utilisez l'outil de lecture sur chaque image pour les visualiser. Les images montrent :
- Les partages d'écran (code, diapositives, interfaces utilisateur)
- Les noms des participants (en bas à gauche de chaque vignette vidéo)
- Les horodatages (si visibles dans le partage d'écran)
Phase 5 : Transcrire l'Audio
Exécutez le moteur de transcription. Choisissez le code correct en fonction de WHISPER_ENGINE :
faster-whisper (systèmes CUDA)
from faster_whisper import WhisperModel
import json
model = WhisperModel("{WHISPER_MODEL}", device="cuda", compute_type="float16")
segments, info = model.transcribe("/chemin/vers/audio", beam_size=5, language="en")
results = []
for segment in segments:
results.append({
"start": segment.start,
"end": segment.end,
"text": segment.text.strip()
})
# Sauvegarder la transcription horodatée
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"{len(results)} segments transcrits")
openai-whisper (systèmes MPS / CPU)
import whisper, json
model = whisper.load_model("{WHISPER_MODEL}")
result = model.transcribe("/chemin/vers/audio", verbose=False)
# Sauvegarder la transcription horodatée
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"{len(result['segments'])} segments transcrits")
Exécutez la transcription en arrière-plan car elle prend un temps significatif. Pendant qu'elle s'exécute, examinez visuellement les images extraites.
Phase 6 : Synthétiser
Combinez les images clés + la transcription + le chat pour construire une compréhension :
- Qui : Identifiez les participants à partir des étiquettes de noms vidéo et de l'attribution vocale
- Quoi : Ce qui a été montré à l'écran (démos, diapositives, code)
- Dit : Citations clés, décisions, exigences, retours
- Actions : Engagements explicites et suivis
Référence des Modèles
| Modèle | Paramètres | Vitesse | Précision | Idéal Pour |
|---|---|---|---|---|
tiny | 39M | Très rapide | Faible | Analyse rapide, vérifier si l'audio est utilisable |
base | 74M | Rapide | Adéquate | Par défaut pour les réunions courtes/claires |
small | 244M | Modéré | Bonne | Réunions générales avec accents |
medium | 769M | Lent | Élevée | Réunions importantes, face au client |
large-v3 | 1,5B | Très lent | Meilleure | Enregistrements critiques, mauvaise qualité audio |
Conseils
- Exécutez toujours la transcription en arrière-plan pendant que vous examinez les images visuellement
- Lisez les images par lots de 8 (limite de parallélisme de l'outil)
- Whisper standard utilise FP32 sur CPU et MPS ; faster-whisper utilise CTranslate2 avec FP16 sur CUDA
- Pour les enregistrements très longs (>1 heure), envisagez de diviser l'audio d'abord
- Les fichiers de chat de Zoom contiennent des horodatages et des liens partagés, lisez-les d'abord pour un contexte rapide
- Sous Windows, utilisez des barres obliques ou des chaînes brutes pour les chemins de fichiers en Python
Gestion des Erreurs
| Erreur | Cause | Solution |
|---|---|---|
ffmpeg: command not found | ffmpeg non installé | Installez selon le tableau de plateforme ci-dessus |
No module named 'whisper' | Whisper non installé | pip3 install openai-whisper |
No module named 'faster_whisper' | faster-whisper non installé | pip3 install faster-whisper |
CUDA out of memory | Modèle trop grand pour la VRAM | Passez à un modèle plus petit |
RuntimeError: MPS backend | Problème MPS sur macOS ancien | Mettez à jour macOS, ou revenez au CPU avec PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0 |
torch not found | Dépendances Python manquantes | Installez torch selon le tableau de plateforme ci-dessus |
| Transcription incohérente | Mauvaise langue ou audio de mauvaise qualité | Essayez de spécifier language="en" ou utilisez un modèle plus grand |
| Transcription très lente | Exécution d'un grand modèle sur CPU | Passez au modèle base ou small |