Vérifié juillet 2026
faster-whisper — Whisper 2-4x Plus Rapide via CTranslate2
faster-whisper est une réimplémentation Python d'OpenAI Whisper construite sur CTranslate2 par Guillaume Klein chez SYSTRAN. Elle exécute les mêmes poids Whisper 2-4x plus rapidement sur GPU CUDA avec 30-50% de VRAM en moins, via quantification INT8/FP16. Précision identique à Whisper de référence, débit largement supérieur en production.
Résumé rapide
- ●Auteur : Guillaume Klein (SYSTRAN, également auteur d'OpenNMT). Dépôt : github.com/SYSTRAN/faster-whisper. Licence MIT.
- ●Base : construit sur CTranslate2 — moteur d'inférence C++ optimisé pour Transformer.
- ●Gains : 2-4x plus rapide que Whisper PyTorch de référence sur même GPU, 30-50% moins de VRAM via quantification INT8/FP16.
- ●Précision : identique aux poids Whisper de référence en FP16, < 1% de perte en int8_float16.
- ●Contraintes : nécessite Python et CUDA (GPU). Support CPU existe mais lent — utilisez whisper.cpp pour CPU/mobile/edge.
- ●Ce qui manque : diarisation. Voir WhisperX (bundle avec pyannote) ou combinez avec pyannote.audio.
Installation en 30 secondes
pip install faster-whisperPrérequis : Python 3.8+, PyTorch avec CUDA pour usage GPU. Puis, exemple minimum :
from faster_whisper import WhisperModel
model = WhisperModel(
"large-v3",
device="cuda",
compute_type="float16"
)
segments, info = model.transcribe("audio.wav", language="fr")
for segment in segments:
print(f"[{segment.start:.2f} → {segment.end:.2f}] {segment.text}")Temps typique installation-à-fonctionnel : 3-10 minutes selon votre setup CUDA existant.
Benchmarks — vitesse et VRAM par GPU
Temps pour transcrire 60 minutes d'audio avec Whisper large-v3, selon la carte et le mode d'inférence :
| GPU | Whisper référence | faster-whisper FP16 | faster-whisper INT8 | VRAM référence | VRAM INT8 |
|---|---|---|---|---|---|
| NVIDIA T4 (16 Go) | 5-7 min | 2-3 min | 1,5-2 min | ~ 10 Go | ~ 3 Go |
| RTX 4090 (24 Go) | 2-3 min | 1-1,5 min | 40-60 sec | ~ 10 Go | ~ 3 Go |
| A100 (40/80 Go) | 1,5-2 min | 40-60 sec | 30-45 sec | ~ 10 Go | ~ 3 Go |
| H100 (80 Go) | 1-1,5 min | 25-40 sec | 20-30 sec | ~ 10 Go | ~ 3 Go |
Sources : benchmarks du dépôt faster-whisper GitHub et benchmarks communautaires 2024-2025. Vos chiffres réels varieront selon batching, tokenizer overhead, et audio spécifique.
Quantification — quel compute_type choisir ?
| compute_type | VRAM | Perte précision | Vitesse | Quand l'utiliser |
|---|---|---|---|---|
| float16 (FP16) | ≈ 6 Go pour large-v3 | 0% perte (identique référence) | 2-3x plus rapide | Défaut sur GPU récent (RTX 30/40, A100, H100) |
| int8_float16 | ≈ 3 Go pour large-v3 | < 1% perte WER | 3-4x plus rapide | Meilleur compromis vitesse/VRAM — recommandé sur T4 |
| int8 pur | ≈ 2 Go pour large-v3 | 1-3% perte WER | 3-4x plus rapide, CPU également | VRAM minimum, ou CPU seul |
| float32 (FP32) | ≈ 10 Go pour large-v3 | 0% perte | Similaire référence | Rarement — utilisez FP16 à la place |
Recommandation : float16 sur GPU récent, int8_float16 sur T4 ou similaire pour héberger large-v3 dans 16 Go de VRAM.
faster-whisper vs whisper.cpp — quel choix ?
Deux stratégies d'optimisation du même modèle Whisper, chacune optimale pour un contexte différent :
- faster-whisper — Python + CTranslate2, optimisé pour serveurs avec GPU CUDA. Débit maximum en batch, VRAM réduite. Idéal pour service SaaS, pipeline d'entreprise, API de transcription.
- whisper.cpp — C/C++ pur, sans Python ni CUDA. Optimisé pour CPU, Apple Silicon, mobile, edge. Idéal pour déploiement on-device.
Règle simple : infrastructure serveur avec GPU CUDA et débit à maximiser ? faster-whisper. Déploiement CPU/mobile/edge sans Python ? whisper.cpp.
WhisperX — faster-whisper + diarisation + alignement
WhisperX est une enveloppe qui combine trois briques : (1) faster-whisper pour la transcription rapide, (2) pyannote.audio 3.1 pour la diarisation des locuteurs, (3) alignement forcé au mot près via wav2vec2 phoneme models.
Résultat : transcript avec timestamps au mot près ET étiquettes de locuteurs. C'est le pattern le plus utilisé en production quand vous voulez le meilleur des trois. VexaScribe utilise une architecture similaire (faster-whisper + pyannote) en service hébergé.
Questions fréquentes
Qu'est-ce que faster-whisper ?
faster-whisper est une réimplémentation Python d'OpenAI Whisper construite sur CTranslate2, une bibliothèque d'inférence optimisée pour les modèles Transformer. Créée par Guillaume Klein (auteur d'OpenNMT) chez SYSTRAN sous licence MIT. Elle exécute les mêmes poids Whisper que la référence PyTorch mais 2-4x plus rapidement sur GPU CUDA, tout en utilisant 30-50% moins de VRAM grâce à la quantification INT8/FP16. Même précision qu'OpenAI Whisper de référence, débit largement supérieur en production.
Quelle différence entre faster-whisper et OpenAI Whisper ?
Même modèle, moteur d'inférence différent. OpenAI Whisper de référence utilise PyTorch — flexible mais pas optimisé pour l'inférence en production. faster-whisper utilise CTranslate2, un moteur C++ compilé qui applique quantification INT8/FP16, batching optimisé et mémoire réduite. Résultat : 2-4x plus rapide sur le même GPU, 30-50% moins de VRAM. Précision identique (les poids sont les mêmes, seule la mathématique d'exécution est optimisée). Contrepartie : nécessite toujours Python et un GPU CUDA — pas de portage CPU-only comme whisper.cpp.
Comment installer faster-whisper ?
Installation Python en une commande : pip install faster-whisper. Prérequis : Python 3.8+, PyTorch avec CUDA (pour usage GPU) ou build CPU (nettement plus lent). Exemple minimum : from faster_whisper import WhisperModel; model = WhisperModel('large-v3', device='cuda', compute_type='float16'); segments, info = model.transcribe('audio.wav'); for seg in segments: print(seg.text). Temps typique d'installation-à-fonctionnel : 3-10 minutes selon votre setup CUDA existant.
Quels sont les gains de performance concrets vs Whisper de référence ?
Benchmarks vs Whisper PyTorch sur GPU (source : dépôt faster-whisper GitHub et benchmarks communautaires 2024-2025). Sur NVIDIA T4 avec large-v3, transcription 60 min : Whisper référence ~5-7 min, faster-whisper FP16 ~2-3 min (2-3x plus rapide), faster-whisper INT8 ~1,5-2 min (3-4x). VRAM : Whisper référence ~10 Go, faster-whisper FP16 ~6 Go, faster-whisper INT8 ~3 Go. Sur GPU plus puissants (A100, H100), les gains restent 2-3x. Les gains sont significativement plus importants sur les GPU avec Tensor Cores (T4, A100, H100).
Quels types de quantification supporte faster-whisper ?
Trois modes principaux via compute_type. (1) float16 (FP16) — précision identique à Whisper de référence, 30-50% moins de VRAM que FP32, recommandé par défaut sur GPU récents. (2) int8_float16 — quantification hybride : poids en INT8, activations en FP16. ~50% moins de VRAM que FP16, moins de 1% de perte WER. Excellent compromis. (3) int8 pur — quantification agressive INT8 partout. VRAM minimum, 1-3% de perte WER. Utile sur GPU limités (T4 16 Go) pour large-v3, ou sur CPU. Recommandation : float16 sur GPU récent (RTX 4090, A100), int8_float16 sur GPU plus modeste.
faster-whisper fait-il la diarisation des locuteurs ?
Pas nativement. Comme whisper.cpp et le Whisper de référence, faster-whisper gère uniquement la transcription. Pour l'étiquetage des locuteurs, deux options. (1) WhisperX — enveloppe qui combine faster-whisper (transcription rapide) + pyannote.audio (diarisation) + alignement forcé au mot près. C'est le pattern le plus populaire en production. (2) Faites-le vous-même : exécutez faster-whisper pour le transcript, pyannote 3.1 séparément pour la diarisation, fusionnez par timestamps. VexaScribe utilise cette approche (faster-whisper + pyannote) en service hébergé.
Quand utiliser faster-whisper vs whisper.cpp ?
Dépend de votre infrastructure. Utilisez faster-whisper quand vous avez un serveur avec GPU CUDA et voulez le débit maximum en production (traitement batch, service SaaS, pipeline d'entreprise). Utilisez whisper.cpp quand vous voulez tourner sur CPU / Apple Silicon / mobile / edge sans dépendance Python ni CUDA. Chiffres approximatifs : faster-whisper sur A100 traite 60 min en ~1-2 minutes ; whisper.cpp sur Apple M2 Pro traite les mêmes 60 min en ~8-12 minutes. Le choix dépend uniquement du contexte de déploiement — les deux préservent la précision Whisper.
Puis-je utiliser faster-whisper sans GPU (CPU seul) ?
Oui mais c'est significativement plus lent. faster-whisper supporte le mode CPU via device='cpu' et bénéficie de l'optimisation CTranslate2 (INT8 sur AVX2/AVX512), mais reste plusieurs fois plus lent que sur GPU. Ordre de grandeur : sur CPU x86 moderne (Ryzen 9, Xeon), large-v3 INT8 traite 60 min en 25-45 minutes. Pour usage CPU sérieux, whisper.cpp est généralement le meilleur choix car conçu spécifiquement pour ce contexte, avec support Apple Silicon (Metal + CoreML) natif que faster-whisper n'a pas.
Pages liées
whisper.cpp
L'alternative C/C++ pour CPU, Apple Silicon, iOS, Android — sans Python ni CUDA
Whisper transcription en ligne
Utiliser Whisper Large-v3 sans installer Python — service hébergé VexaScribe
Diarisation des locuteurs (pyannote)
L'ajout complémentaire pour identifier qui parle
Comparaison précision transcription
WER vérifié : Whisper vs Deepgram vs AssemblyAI vs Sonix — sources primaires
faster-whisper (English deep-dive)
Version anglaise avec benchmarks détaillés et exemples code additionnels
Transcription audio en texte
Guide général FR pour utilisateurs non-techniques