Vérifié juillet 2026
WhisperX — Whisper avec Timestamps par Mot + Diarisation
WhisperX est un pipeline open-source qui combine faster-whisper (transcription rapide via CTranslate2), un modèle wav2vec2 (alignment forcé au niveau du mot), et pyannote 3.x (diarisation des locuteurs) dans un seul outil. Publié par Bain et al. à Interspeech 2023, il est aujourd'hui la solution la plus complète pour obtenir Whisper avec timestamps par mot ET étiquettes de locuteurs.
Architecture — pipeline à 3 étages
WhisperX n'est pas un nouveau modèle — c'est un orchestrateur qui enchaîne trois modèles existants. C'est le premier point à comprendre.
- 1
Transcription — faster-whisper
WhisperX exécute d'abord faster-whisper (implémentation CTranslate2 de Whisper) pour transcrire l'audio en segments avec timestamps de segment. C'est la même sortie que Whisper Large-v3 vanilla, juste plus rapide grâce au backend optimisé CTranslate2.
- 2
Alignment forcé — wav2vec2
Un modèle wav2vec2 pré-entraîné par langue (facebook/wav2vec2-large-xlsr-53-french pour le français) prend l'audio et la transcription, puis calcule précisément où chaque mot commence et se termine. Résultat : timestamps par mot (word-level) au lieu de par segment.
- 3
Diarisation — pyannote 3.x
pyannote.audio segmente l'audio par locuteur (qui parle quand) et attribue chaque mot à un locuteur (SPEAKER_00, SPEAKER_01, …). Étape optionnelle activée par --diarize et nécessitant un token Hugging Face pour accéder aux modèles gated.
Publication de référence : Bain, M., Huh, J., Han, T., & Zisserman, A. (2023). WhisperX: Time-Accurate Speech Transcription of Long-Form Audio. Interspeech 2023 (arXiv:2303.00747). Dépôt : github.com/m-bain/whisperX.
WhisperX vs faster-whisper vs whisper.cpp
Les trois outils vivent dans le même écosystème (tous basés sur Whisper), mais chacun a un job différent. Voici la comparaison honnête sur 8 attributs.
| Attribut | WhisperX | faster-whisper | whisper.cpp |
|---|---|---|---|
| Timestamps par mot | Oui (wav2vec2 forced alignment) | Non (par segment uniquement) | Partiel (word_timestamps flag, moins précis) |
| Diarisation locuteurs | Oui (pyannote 3.x intégré) | Non — à ajouter séparément | Non — à ajouter séparément |
| Vitesse (GPU CUDA) | Rapide (utilise faster-whisper) | Le plus rapide (aucune surcouche) | Non applicable (CPU-first) |
| VRAM (Large-v3) | ~4-6 GB (transcription + alignment + diarisation) | ~2-4 GB (transcription seule) | 0 (CPU) — RAM ~4 GB |
| Support CPU | Techniquement oui, lent | Oui avec int8 quantization | Optimisé CPU (SIMD, Metal, CoreML) |
| Support mobile / edge | Non (Python + CUDA) | Non (Python) | Oui (iOS, Android, Raspberry Pi) |
| Token Hugging Face requis | Oui (pyannote gated) si --diarize | Non | Non |
| Cas d'usage idéal | Verbatim entretien, sous-titres précis, podcasts multi-intervenants | Batch transcription serveur, pipelines API | Apps mobile, on-device, edge, hors ligne |
Résumé : WhisperX ajoute une valeur claire quand vous avez besoin de timestamps par mot ou de diarisation. Sinon, faster-whisper suffit et est plus léger. Pour tout ce qui est mobile/edge/CPU, whisper.cpp gagne.
Installation
Prérequis : Python 3.9+, PyTorch avec CUDA (recommandé pour usage sérieux), un compte Hugging Face si vous voulez la diarisation.
1. Installation pip
pip install whisperxInstalle faster-whisper, torch, transformers, pyannote.audio et wav2vec2. Total ~2 GB.
2. Token Hugging Face (pour diarisation)
Créer un compte sur huggingface.co, puis accepter les conditions sur ces deux pages :
- pyannote/segmentation-3.0
- pyannote/speaker-diarization-3.1
Ensuite, créer un token utilisateur dans huggingface.co/settings/tokens et l'exporter :
export HF_TOKEN=hf_xxxxxxxxxxxxxxx3. Utilisation en ligne de commande
whisperx audio.mp3 \
--model large-v3 \
--language fr \
--diarize \
--hf_token $HF_TOKEN \
--output_format srt4. API Python — sortie avec timestamps par mot
import whisperx
device = "cuda"
audio_file = "entretien.mp3"
# 1. Transcription
model = whisperx.load_model("large-v3", device, language="fr")
audio = whisperx.load_audio(audio_file)
result = model.transcribe(audio, batch_size=16)
# 2. Alignment mot à mot
model_a, metadata = whisperx.load_align_model(
language_code="fr", device=device
)
result = whisperx.align(
result["segments"], model_a, metadata, audio, device
)
# 3. Diarisation
diarize_model = whisperx.DiarizationPipeline(
use_auth_token="hf_xxxxx", device=device
)
diarize_segments = diarize_model(audio)
result = whisperx.assign_word_speakers(diarize_segments, result)
# result["segments"] contient maintenant :
# [{ "start": 0.32, "end": 2.15, "text": "Bonjour, aujourd'hui...",
# "words": [{"word": "Bonjour", "start": 0.32, "end": 0.71, "speaker": "SPEAKER_00"}, ...],
# "speaker": "SPEAKER_00" }, ...]Timestamps par mot — pourquoi c'est utile
Whisper vanilla donne des timestamps par segment (typiquement 5-30 secondes). WhisperX descend à la précision par mot grâce à l'alignment wav2vec2. Comparaison concrète :
Whisper vanilla (par segment)
{
"start": 4.20,
"end": 9.85,
"text": "Aujourd'hui nous allons parler de transcription"
}WhisperX (par mot)
"words": [
{"word": "Aujourd'hui", "start": 4.20, "end": 4.62},
{"word": "nous", "start": 4.68, "end": 4.85},
{"word": "allons", "start": 4.89, "end": 5.21},
{"word": "parler", "start": 5.28, "end": 5.62},
{"word": "de", "start": 5.68, "end": 5.79},
{"word": "transcription", "start": 5.85, "end": 6.42}
]Utilité concrète : sous-titres SRT à 2-3 mots par cue au lieu de blocs de 15 mots ; verbatim entretien avec timestamps par mot pour NVivo/Atlas.ti ; karaoké ou effet mot-par-mot en montage vidéo ; découpage précis pour clips courts.
Précision en français
Point important : WhisperX n'améliore pas la précision de transcription. Il hérite de faster-whisper (donc de Whisper Large-v3). Sur audio français propre, cela signifie 93-95 % de précision au mot selon le benchmark FLEURS. Ce que WhisperX améliore : la précision temporelle (timestamps par mot) et l'ajout de la diarisation.
Pour la diarisation FR, pyannote 3.x fonctionne mais est moins précis qu'en anglais — le français a moins de données d'entraînement dans les corpus pyannote. Attendez-vous à un DER (Diarization Error Rate) plus élevé sur audio FR, particulièrement avec chevauchements de parole ou plus de 3 locuteurs.
Voir notre benchmark comparatif de précision pour les chiffres détaillés par outil, et la page diarisation pour le fonctionnement de pyannote.
Limites honnêtes
Token Hugging Face obligatoire pour la diarisation
Les modèles pyannote (segmentation-3.0, speaker-diarization-3.1) sont gated. Il faut créer un compte HF, accepter les conditions sur chaque page de modèle, puis obtenir un token. Étape frictionnelle mais légitime — pyannote impose ces conditions pour tracer l'usage.
VRAM importante pour Large-v3
~4-6 GB nécessaires sur GPU pour Large-v3 avec diarisation activée. RTX 3060 (12 GB) est le minimum confortable ; RTX 3060 8 GB suffit avec batch_size réduit. Sur GPU 4 GB, utilisez le modèle medium ou small.
Dépendances Python lourdes
L'installation totale (torch + faster-whisper + pyannote + transformers + wav2vec2) fait environ 2 GB. Pas idéal pour un container léger. Docker Compose recommandé pour isoler.
Pas de version mobile / edge
WhisperX est Python + CUDA. Pour iOS, Android, Raspberry Pi ou edge, utilisez whisper.cpp — WhisperX est incompatible.
Alignment échoue sur audio très bruité
wav2vec2 forced alignment suppose que le texte transcrit correspond à l'audio. Sur audio très dégradé (bruit fort, multiples voix chevauchantes), l'alignment peut être erroné même si la transcription semble correcte.
Diarisation FR moins précise qu'EN
pyannote a plus de données d'entraînement en anglais qu'en français. Attendez-vous à un DER (Diarization Error Rate) plus élevé sur audio FR, surtout avec chevauchements de parole. Voir /fr/diarisation pour le détail.
Quel outil choisir selon votre job ?
Arbre de décision honnête entre WhisperX, faster-whisper, whisper.cpp et service managé.
| Job | Outil recommandé | Pourquoi |
|---|---|---|
| Verbatim d'entretien qualitatif (recherche NVivo, Atlas.ti) avec locuteurs identifiés | WhisperX | Timestamps par mot + diarisation intégrée — sortie prête pour analyse qualitative |
| Sous-titres SRT précis pour montage vidéo (Premiere, DaVinci, CapCut) | WhisperX | Timestamps par mot évitent les segments trop longs dans les sous-titres |
| Podcast multi-intervenants avec attribution de qui parle | WhisperX | Diarisation pyannote intégrée sans code supplémentaire |
| Transcription batch serveur, un seul locuteur, timestamps segment OK | faster-whisper | Plus léger, pas de token HF, plus rapide au démarrage — WhisperX serait sur-dimensionné |
| App mobile (iOS/Android) avec transcription on-device | whisper.cpp | WhisperX exige Python + CUDA — impossible sur mobile. whisper.cpp compile en binaire natif |
| Raspberry Pi, edge, ou serveur CPU-only | whisper.cpp | Optimisation CPU (SIMD, quantization GGUF, Metal sur Mac) — WhisperX inutilisable sans GPU |
| API de production avec SLA (uptime, latence garantie, monitoring) | Service managé | WhisperX / faster-whisper / whisper.cpp sont des outils DIY. Pour SLA, utilisez un service — voir /fr/transcription-ia |
Questions fréquentes
Qu'est-ce que WhisperX ?
WhisperX est un pipeline open-source qui combine trois composants : (1) faster-whisper pour la transcription rapide via CTranslate2, (2) un modèle wav2vec2 pour l'alignement forcé au niveau du mot (word-level forced alignment) qui remplace les timestamps par segment de Whisper par des timestamps par mot précis, et (3) pyannote.audio 3.x pour la diarisation des locuteurs. Publié par Max Bain et al. (Interspeech 2023, arXiv:2303.00747), maintenu sur github.com/m-bain/whisperX. C'est la solution la plus complète pour obtenir une transcription Whisper avec timestamps par mot ET étiquettes de locuteurs dans un seul outil.
WhisperX vs faster-whisper — lequel choisir ?
faster-whisper si vous voulez uniquement la transcription rapide sans diarisation ni timestamps par mot. C'est plus léger (pas de dépendance pyannote, pas de token Hugging Face), plus rapide au démarrage, et suffit pour la plupart des workflows batch. WhisperX si vous avez besoin de timestamps précis au mot près (montage sous-titres, karaoké, alignement lyrics) ou de diarisation intégrée (podcasts multi-intervenants, entretiens, réunions). WhisperX utilise faster-whisper en interne pour la transcription, donc vous n'avez pas à choisir entre les deux — WhisperX ajoute juste des étapes au-dessus.
WhisperX vs whisper.cpp — lequel choisir ?
whisper.cpp si vous ciblez CPU pur, mobile (iOS, Android), edge, ou Raspberry Pi. Aucune dépendance Python, un seul binaire C++, compatible Metal (macOS) et CoreML. WhisperX si vous avez un GPU (Nvidia CUDA), utilisez Python, et voulez timestamps par mot + diarisation. WhisperX exige un GPU pour être vraiment utilisable en production (les modèles Large-v3 sur CPU sont trop lents), tandis que whisper.cpp est optimisé CPU. Les deux ont leur place : un projet mobile utilise whisper.cpp, un pipeline serveur Python utilise WhisperX.
Comment installer WhisperX ?
Trois commandes : (1) pip install whisperx — installe faster-whisper, torch, transformers, pyannote et les dépendances (~2 GB au total). (2) Créer un compte Hugging Face et accepter les conditions des modèles pyannote/segmentation-3.0 et pyannote/speaker-diarization-3.1 (pages gated) — obtenir un token utilisateur. (3) Exporter HF_TOKEN dans l'environnement ou le passer via l'API Python. Ensuite : whisperx audio.mp3 --model large-v3 --diarize --hf_token YOUR_TOKEN. Prérequis : Python 3.9+, PyTorch avec CUDA si GPU (recommandé). Consommation VRAM : Large-v3 ~4-6 GB.
Qu'est-ce que l'alignement forcé (forced alignment) ?
L'alignement forcé prend un texte connu (la transcription Whisper) et un audio, puis calcule précisément où chaque mot commence et se termine dans l'audio. WhisperX utilise un modèle wav2vec2 pré-entraîné par langue (facebook/wav2vec2-large-xlsr-53-french pour le français) pour cette étape. C'est différent de la transcription : le modèle wav2vec2 ne devine pas ce qui est dit — il aligne le texte déjà transcrit avec précision milliseconde. Résultat : timestamps par mot précis pour montage sous-titres, karaoké, ou verbatim entretien qualitatif.
Précision de WhisperX en français ?
WhisperX n'améliore pas la précision de transcription — il hérite de faster-whisper (donc de Whisper Large-v3 : 93-95 % en français propre selon FLEURS). Ce que WhisperX améliore : la précision temporelle des timestamps (au mot près au lieu du segment) et l'ajout de la diarisation. Pour la diarisation FR, pyannote 3.x fonctionne mais est moins précis qu'en anglais — le français n'a pas autant de données d'entraînement dans pyannote que l'anglais. Attendez-vous à un DER (Diarization Error Rate) plus élevé sur audio français que sur audio anglais, surtout avec chevauchements de parole.
WhisperX fonctionne-t-il sur CPU ?
Techniquement oui, mais pas en pratique pour la production. Les modèles Large-v3 sur CPU prennent 5-10× la durée du fichier audio (30 min d'audio = 3-5 h de traitement), ce qui est inutilisable pour un usage sérieux. Les modèles plus petits (base, small) sont utilisables sur CPU mais avec précision réduite. Pour du CPU pur, whisper.cpp est le bon choix (optimisation SIMD, quantization GGUF, latence bien meilleure). Pour WhisperX en production, un GPU Nvidia avec au moins 6 GB VRAM (RTX 3060 ou mieux) est recommandé.
Le token Hugging Face est-il obligatoire ?
Oui, si vous voulez la diarisation. Les modèles pyannote (segmentation-3.0 et speaker-diarization-3.1) sont gated sur Hugging Face — vous devez créer un compte, accepter les conditions d'utilisation sur la page de chaque modèle, et obtenir un token utilisateur. Si vous n'utilisez pas --diarize, le token n'est pas nécessaire — WhisperX fonctionne alors avec juste faster-whisper + alignement wav2vec2. Le token est une étape frictionnelle mais légitime : pyannote impose ces conditions pour tracer l'usage académique vs commercial. C'est gratuit.