Guide Faster-Whisper : reconnaissance vocale plus rapide avec CTranslate2

---

Qu’est-ce que Faster-whisper ?

Fonctionnalités clés

• Inférence 2-4× plus rapide qu’OpenAI Whisper
• Mémoire réduite grâce à la quantification
• Même précision que les modèles Whisper d’origine
• Prise en charge GPU et CPU avec backends optimisés
• Traitement par lots pour plusieurs fichiers
• Horodatage au niveau des mots
• Options de quantification (FP32, FP16, INT8, INT8_FLOAT16)
• Détection d’activité vocale (VAD) pour filtrer

Fonctionnement

• Opérations matricielles plus rapides via des bibliothèques BLAS optimisées
• Meilleure gestion mémoire avec moins de surcharge
• Quantification pour une mémoire plus faible
• Traitement par lots pour optimiser le débit

---

Faster-whisper vs OpenAI Whisper

Comparaison des performances

Fonctionnalité	OpenAI Whisper	Faster-whisper
Vitesse	Référence	2-4× plus rapide
Mémoire	Plus élevée	Plus faible (avec quantification)
Précision	Élevée	Identique (modèles identiques)
GPU	Oui	Oui (optimisé)
CPU	Oui	Oui (optimisé)
Quantification	Limitée	Complète (INT8, FP16)
Traitement par lots	Manuel	Intégré
Installation	Simple	Simple (inclut CTranslate2)

Quand utiliser Faster-whisper

• Vous avez besoin d’une transcription plus rapide pour de la charge de production
• Vous traitez plusieurs fichiers par lots
• Vous exécutez sur des systèmes à ressources limitées (utilisez INT8)
• Vous construisez des applications temps réel ou quasi temps réel
• Vous avez besoin d’une utilisation mémoire moindre en déploiement

• Vous avez besoin d’une compatibilité maximale avec le code existant
• Vous utilisez des modèles fine-tunés (faster-whisper nécessite une conversion)
• Vous préférez une API plus simple (faster-whisper reste proche)
• Vous travaillez avec des fonctionnalités expérimentales d’abord dans OpenAI Whisper

---

Installation

Prérequis

• Python 3.9+ (obligatoire)
• FFmpeg (facultatif : faster-whisper utilise PyAV, FFmpeg peut être nécessaire pour certains formats)
• GPU NVIDIA (facultatif, pour l’accélération GPU)

Installation de base

pip install faster-whisper

• le paquet faster-whisper
• ctranslate2 (moteur d’inférence CTranslate2)
• pyav (décodage audio, remplace la dépendance FFmpeg)

Installation GPU (NVIDIA CUDA)

pip install nvidia-cublas-cu12 nvidia-cudnn-cu12==9.*

export LD_LIBRARY_PATH=$(python3 -c 'import os; import nvidia.cublas.lib; import nvidia.cudnn.lib; print(os.path.dirname(nvidia.cublas.lib.__file__) + ":" + os.path.dirname(nvidia.cudnn.lib.__file__))')

pip install ctranslate2==3.24.0 faster-whisper

Vérifier l’installation

from faster_whisper import WhisperModel

# Test basic import
print("Faster-whisper installed successfully!")

---

Utilisation de base

Transcription simple

from faster_whisper import WhisperModel

# Load model (automatically downloads if not present)
model = WhisperModel("base", device="cpu", compute_type="int8")

# Transcribe audio
segments, info = model.transcribe("audio.mp3")

# Print detected language
print(f"Detected language: {info.language} (probability: {info.language_probability:.2f})")

# Print transcription
for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

Obtenir le texte complet

from faster_whisper import WhisperModel

model = WhisperModel("base")
segments, info = model.transcribe("audio.mp3")

# Collect all text
full_text = " ".join([segment.text for segment in segments])
print(full_text)

Avec horodatage des mots

from faster_whisper import WhisperModel

model = WhisperModel("base", device="cpu", compute_type="int8")

segments, info = model.transcribe(
    "audio.mp3",
    word_timestamps=True,
    beam_size=5
)

for segment in segments:
    print(f"[{segment.start:.2f}s - {segment.end:.2f}s] {segment.text}")
    
    # Word-level timestamps
    for word in segment.words:
        print(f"  {word.word} [{word.start:.2f}s - {word.end:.2f}s]")

---

Options d’appareil et de type de calcul

Options d’appareil

• device="cpu" — inférence CPU (fonctionne partout)
• device="cuda" — inférence GPU (GPU NVIDIA et CUDA requis)

Types de calcul

Type de calcul	Vitesse	Mémoire	Précision	Cas d’usage
int8	Très rapide	Minimale	Légèrement inférieure	CPU, ressources limitées
int8_float16	Très rapide	Faible	Élevée	GPU avec VRAM limitée
float16	Rapide	Moyenne	Élevée	GPU (recommandé)
float32	Plus lent	Maximale	Maximale	Précision maximale

Exemples selon le matériel

# Best for CPU: INT8
model = WhisperModel("base", device="cpu", compute_type="int8")

# Best for GPU: FP16
model = WhisperModel("large-v2", device="cuda", compute_type="float16")

# Use INT8_FLOAT16 for large models
model = WhisperModel("large-v2", device="cuda", compute_type="int8_float16")

# Use FP32 (slower but most accurate)
model = WhisperModel("large-v2", device="cuda", compute_type="float32")

---

Fonctionnalités avancées

1. Traitement par lots

from faster_whisper import WhisperModel
from pathlib import Path

model = WhisperModel("base", device="cuda", compute_type="float16")

audio_files = ["audio1.mp3", "audio2.mp3", "audio3.mp3"]

for audio_file in audio_files:
    print(f"Transcribing: {audio_file}")
    segments, info = model.transcribe(audio_file)
    
    text = " ".join([seg.text for seg in segments])
    print(f"Result: {text[:100]}...")
    print()

2. Détection d’activité vocale (VAD)

from faster_whisper import WhisperModel

model = WhisperModel("base")

segments, info = model.transcribe(
    "audio.mp3",
    vad_filter=True,  # Enable VAD filtering
    vad_parameters=dict(
        min_silence_duration_ms=500,  # Minimum silence duration
        threshold=0.5  # VAD threshold
    )
)

for segment in segments:
    print(f"[{segment.start:.2f}s] {segment.text}")

3. Spécifier la langue

from faster_whisper import WhisperModel

model = WhisperModel("base")

# Specify language (faster and more accurate)
segments, info = model.transcribe(
    "audio.mp3",
    language="en"  # English
)

# Or let it auto-detect
segments, info = model.transcribe("audio.mp3")  # Auto-detect
print(f"Detected: {info.language}")

4. Taille de faisceau et autres paramètres

from faster_whisper import WhisperModel

model = WhisperModel("base")

segments, info = model.transcribe(
    "audio.mp3",
    beam_size=5,  # Higher = more accurate but slower (default: 5)
    best_of=5,    # Number of candidates to consider
    temperature=0.0,  # Lower = more deterministic
    condition_on_previous_text=True,  # Use context from previous segments
    initial_prompt="This is a technical meeting about AI and machine learning."
)

5. Chemins de modèles personnalisés

from faster_whisper import WhisperModel

# Use local model directory
model = WhisperModel(
    "base",
    device="cpu",
    compute_type="int8",
    download_root="./models"  # Custom download directory
)

# Or specify full path to converted model
model = WhisperModel(
    "/path/to/converted/model",
    device="cuda",
    compute_type="float16"
)

---

Benchmarks de performance

Performances GPU (NVIDIA RTX 3070 Ti)

Configuration	Temps	Utilisation VRAM	Accélération
OpenAI Whisper (FP16, beam=5)	~2m 23s	~4708 MB	Référence
Faster-whisper (FP16, beam=5)	~1m 03s	~4525 MB	2.3× plus rapide
Faster-whisper (INT8, beam=5)	~59s	~2926 MB	2.4× plus rapide
Faster-whisper (FP16, batch=8)	~17s	~6090 MB	8.4× plus rapide
Faster-whisper (INT8, batch=8)	~16s	~4500 MB	8.9× plus rapide

Performances CPU (Intel Core i7-12700K)

Configuration	Temps	Utilisation RAM	Accélération
OpenAI Whisper (FP32, beam=5)	~6m 58s	~2335 MB	Référence
Faster-whisper (FP32, beam=5)	~2m 37s	~2257 MB	2.7× plus rapide
Faster-whisper (INT8, beam=5)	~1m 42s	~1477 MB	4.1× plus rapide
Faster-whisper (FP32, batch=8)	~1m 06s	~4230 MB	6.3× plus rapide
Faster-whisper (INT8, batch=8)	~51s	~3608 MB	8.2× plus rapide

Points clés

• Le traitement par lots apporte le plus grand gain (8×+ sur GPU)
• La quantification INT8 réduit la mémoire d’environ 40 % avec une perte de précision minimale
• L’accélération GPU est essentielle pour les grands modèles et le traitement par lots
• Le CPU avec INT8 reste viable pour les petits modèles et un fichier à la fois

---

Exemple complet : transcription prête pour la production

from faster_whisper import WhisperModel
from pathlib import Path
import json
from datetime import datetime

class TranscriptionService:
    """Production-ready transcription service using faster-whisper."""
    
    def __init__(self, model_size="base", device="cpu", compute_type="int8"):
        """Initialize the transcription service."""
        print(f"Loading model: {model_size} on {device} ({compute_type})")
        self.model = WhisperModel(
            model_size,
            device=device,
            compute_type=compute_type
        )
        print("Model loaded successfully!")
    
    def transcribe_file(self, audio_path, output_format="txt", **kwargs):
        """
        Transcribe an audio file.
        
        Args:
            audio_path: Path to audio file
            output_format: Output format (txt, json, srt, vtt)
            **kwargs: Additional transcription parameters
        """
        audio_path = Path(audio_path)
        if not audio_path.exists():
            raise FileNotFoundError(f"Audio file not found: {audio_path}")
        
        print(f"Transcribing: {audio_path.name}")
        
        # Transcribe
        segments, info = self.model.transcribe(
            str(audio_path),
            word_timestamps=True,
            **kwargs
        )
        
        # Collect results
        result = {
            "file": str(audio_path),
            "language": info.language,
            "language_probability": info.language_probability,
            "duration": info.duration,
            "segments": []
        }
        
        full_text_parts = []
        for segment in segments:
            segment_data = {
                "start": segment.start,
                "end": segment.end,
                "text": segment.text,
                "words": [
                    {
                        "word": word.word,
                        "start": word.start,
                        "end": word.end,
                        "probability": word.probability
                    }
                    for word in segment.words
                ]
            }
            result["segments"].append(segment_data)
            full_text_parts.append(segment.text)
        
        result["text"] = " ".join(full_text_parts)
        
        # Save based on format
        output_path = audio_path.parent / f"{audio_path.stem}_transcript"
        
        if output_format == "txt":
            self._save_txt(result, output_path.with_suffix(".txt"))
        elif output_format == "json":
            self._save_json(result, output_path.with_suffix(".json"))
        elif output_format == "srt":
            self._save_srt(result, output_path.with_suffix(".srt"))
        elif output_format == "vtt":
            self._save_vtt(result, output_path.with_suffix(".vtt"))
        
        print(f"✓ Transcription saved: {output_path}.{output_format}")
        return result
    
    def _save_txt(self, result, path):
        """Save as plain text."""
        with open(path, "w", encoding="utf-8") as f:
            f.write(result["text"])
    
    def _save_json(self, result, path):
        """Save as JSON."""
        with open(path, "w", encoding="utf-8") as f:
            json.dump(result, f, indent=2, ensure_ascii=False)
    
    def _save_srt(self, result, path):
        """Save as SRT subtitles."""
        with open(path, "w", encoding="utf-8") as f:
            for i, seg in enumerate(result["segments"], start=1):
                start = self._format_srt_time(seg["start"])
                end = self._format_srt_time(seg["end"])
                f.write(f"{i}\n{start} --> {end}\n{seg['text']}\n\n")
    
    def _save_vtt(self, result, path):
        """Save as WebVTT."""
        with open(path, "w", encoding="utf-8") as f:
            f.write("WEBVTT\n\n")
            for seg in result["segments"]:
                start = self._format_vtt_time(seg["start"])
                end = self._format_vtt_time(seg["end"])
                f.write(f"{start} --> {end}\n{seg['text']}\n\n")
    
    def _format_srt_time(self, seconds):
        """Format time for SRT."""
        hours = int(seconds // 3600)
        minutes = int((seconds % 3600) // 60)
        secs = int(seconds % 60)
        millis = int((seconds % 1) * 1000)
        return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"
    
    def _format_vtt_time(self, seconds):
        """Format time for VTT."""
        hours = int(seconds // 3600)
        minutes = int((seconds % 3600) // 60)
        secs = int(seconds % 60)
        millis = int((seconds % 1) * 1000)
        return f"{hours:02d}:{minutes:02d}:{secs:02d}.{millis:03d}"

# Usage
if __name__ == "__main__":
    # Initialize service
    service = TranscriptionService(
        model_size="base",
        device="cpu",  # Change to "cuda" for GPU
        compute_type="int8"  # Use "float16" for GPU
    )
    
    # Transcribe file
    result = service.transcribe_file(
        "meeting.mp3",
        output_format="json",
        beam_size=5,
        language="en"
    )
    
    print(f"\nLanguage: {result['language']}")
    print(f"Duration: {result['duration']:.2f}s")
    print(f"Text: {result['text'][:200]}...")

---

Bonnes pratiques

1. Choisir la taille de modèle adaptée

# For speed (CPU)
model = WhisperModel("tiny", device="cpu", compute_type="int8")

# For balance
model = WhisperModel("base", device="cpu", compute_type="int8")

# For accuracy (GPU recommended)
model = WhisperModel("large-v2", device="cuda", compute_type="float16")

2. Optimiser pour votre matériel

model = WhisperModel("base", device="cpu", compute_type="int8")

model = WhisperModel("large-v2", device="cuda", compute_type="float16")

model = WhisperModel("medium", device="cuda", compute_type="int8_float16")

3. Traitement par lots pour plusieurs fichiers

# Process multiple files efficiently
audio_files = ["file1.mp3", "file2.mp3", "file3.mp3"]
model = WhisperModel("base", device="cuda", compute_type="float16")

for audio_file in audio_files:
    segments, info = model.transcribe(audio_file)
    # Process results...

4. Activer le VAD pour l’audio bruité

segments, info = model.transcribe(
    "noisy_audio.mp3",
    vad_filter=True,
    vad_parameters=dict(
        min_silence_duration_ms=1000,
        threshold=0.5
    )
)

5. Spécifier la langue lorsqu’elle est connue

# Faster and more accurate when language is known
segments, info = model.transcribe(
    "audio.mp3",
    language="en"  # Specify instead of auto-detect
)

6. Réutiliser les instances de modèle

# Load model once, reuse for multiple files
model = WhisperModel("base")

# Process multiple files with same model
for audio_file in audio_files:
    segments, info = model.transcribe(audio_file)

---

Migration depuis OpenAI Whisper

Comparaison du code

import whisper

model = whisper.load_model("base")
result = model.transcribe("audio.mp3")
print(result["text"])

from faster_whisper import WhisperModel

model = WhisperModel("base", device="cpu", compute_type="int8")
segments, info = model.transcribe("audio.mp3")
text = " ".join([seg.text for seg in segments])
print(text)

Principales différences

1. Chargement du modèle : WhisperModel() au lieu de whisper.load_model()
2. Format de retour : tuple (segments, info) plutôt qu’un dictionnaire
3. Segments : itérateur d’objets segment plutôt qu’une liste
4. Device / type de calcul : il faut spécifier device et compute_type
5. Accès au texte : concaténer les segments pour le texte complet

Fonction utilitaire de migration

def convert_to_whisper_format(segments, info):
    """Convert faster-whisper output to OpenAI Whisper format."""
    return {
        "text": " ".join([seg.text for seg in segments]),
        "language": info.language,
        "segments": [
            {
                "id": i,
                "start": seg.start,
                "end": seg.end,
                "text": seg.text,
                "words": [
                    {
                        "word": word.word,
                        "start": word.start,
                        "end": word.end
                    }
                    for word in seg.words
                ] if hasattr(seg, 'words') else []
            }
            for i, seg in enumerate(segments)
        ]
    }

# Usage
segments, info = model.transcribe("audio.mp3", word_timestamps=True)
result = convert_to_whisper_format(segments, info)
# Now compatible with OpenAI Whisper format

---

Dépannage

Problème 1 : CUDA — mémoire insuffisante

# Use smaller model
model = WhisperModel("base", device="cuda", compute_type="float16")

# Or use INT8 quantization
model = WhisperModel("large-v2", device="cuda", compute_type="int8_float16")

# Or use CPU
model = WhisperModel("large-v2", device="cpu", compute_type="int8")

Problème 2 : performances CPU lentes

# Use INT8 quantization
model = WhisperModel("base", device="cpu", compute_type="int8")

# Use smaller model
model = WhisperModel("tiny", device="cpu", compute_type="int8")

# Reduce beam size
segments, info = model.transcribe("audio.mp3", beam_size=1)

Problème 3 : bibliothèques CUDA introuvables

# Install CUDA libraries
pip install nvidia-cublas-cu12 nvidia-cudnn-cu12==9.*

# Set library path
export LD_LIBRARY_PATH=$(python3 -c 'import os; import nvidia.cublas.lib; import nvidia.cudnn.lib; print(os.path.dirname(nvidia.cublas.lib.__file__) + ":" + os.path.dirname(nvidia.cudnn.lib.__file__))')

Problème 4 : échec du téléchargement du modèle

# Specify download directory
model = WhisperModel(
    "base",
    download_root="./models",  # Custom directory
    local_files_only=False
)

# Or download manually from Hugging Face
# Then use local path
model = WhisperModel("/path/to/local/model")

---

Quand utiliser Faster-whisper

Utiliser Faster-whisper lorsque :

Utiliser OpenAI Whisper lorsque :

---

Conclusion

• Utiliser INT8 sur CPU et systèmes contraints
• Utiliser FP16 sur GPU avec suffisamment de VRAM
• Activer le traitement par lots pour plusieurs fichiers
• Indiquer la langue si elle est connue pour de meilleures performances
• Réutiliser les instances de modèle pour plusieurs transcriptions

---