L’IA et sa régulation t’intéressent ?
Lois, cadres et décisions qui façonnent l’IA, décryptés en français. Gratuit.
Inclus dès l'inscription : notre sélection des meilleurs guides & comparatifs IA.
Choisis ton rythme
Gratuit · Pas de spam · Désabonnement en 1 clic
Transcrire de l'audio en texte est une tâche essentielle pour les développeurs, qu'il s'agisse de créer des applications de reconnaissance vocale, d'analyser des enregistrements de réunions ou d'ajouter des sous-titres à des vidéos. Réaliser cette transcription localement sur sa propre machine présente des avantages significatifs en termes de protection de la vie privée et de réduction des coûts récurrents liés aux services cloud.
Dans cet article, nous allons explorer comment configurer un système de transcription audio local rapide en utilisant Whisper et sa version optimisée, Faster-Whisper. Nous aborderons les étapes de prétraitement audio, telles que la conversion de fichiers MP3 en WAV, l'écriture d'un script Python, et nous discuterons de l'exécution sur CPU et GPU.
Qu'est-ce que Whisper ? Et pourquoi utiliser une variante locale ?
Whisper, développé par OpenAI, est un modèle de reconnaissance automatique de la parole (ASR) qui a été entraîné sur une vaste quantité d'audio multilingue. Ce modèle est capable de fonctionner efficacement même en présence de bruit de fond ou avec différents accents. Cependant, l'utilisation de Whisper dans sa forme originale peut s'avérer lente sur un CPU et consommer une quantité significative de mémoire.
Pour surmonter ces limitations, des variantes optimisées ont été développées. whisper.cpp est une version écrite en C++ qui ne nécessite pas de dépendances lourdes. Elle est très rapide sur CPU, mais requiert une compilation et est moins conviviale pour les utilisateurs de Python. En revanche, Faster-Whisper est une réimplémentation utilisant CTranslate2, qui fonctionne jusqu'à quatre fois plus vite que le modèle original de Whisper, utilise moins de RAM et s'intègre parfaitement avec Python. Dans ce tutoriel, nous utiliserons Faster-Whisper.
Les deux variantes fonctionnent 100 % localement, ce qui signifie qu'aucune donnée ne quitte votre ordinateur, garantissant ainsi la confidentialité des informations traitées.
Configuration de votre environnement (multi-plateforme)
La configuration décrite ici est compatible avec Windows, macOS et Linux, à condition d'utiliser Python 3.8 ou une version ultérieure. Il est conseillé de créer et d'activer un environnement virtuel pour isoler les dépendances nécessaires :
python -m venv whisper_env
Pour activer l'environnement virtuel sur macOS et Linux, utilisez la commande suivante :
source whisper_env/bin/activate
Sur Windows, la commande est légèrement différente :
whisper_env\Scripts\activate
Une fois l'environnement activé, installez Faster-Whisper avec la commande suivante :
pip install faster-whisper
Installation des outils de prétraitement audio
Whisper nécessite que l'audio soit au format WAV mono à 16 kHz. Pour convertir des formats audio courants tels que MP3, M4A ou OGG, il est nécessaire d'utiliser FFmpeg et la bibliothèque Python pydub.
- Sur Windows, téléchargez FFmpeg depuis FFmpeg.org et ajoutez-le au PATH, ou utilisez
winget install ffmpeg. - Sur macOS, la commande est :
brew install ffmpeg - Sur Linux (Ubuntu/Debian), utilisez :
sudo apt install ffmpeg
Ensuite, installez pydub avec la commande suivante :
pip install pydub
Support GPU optionnel
Pour ceux qui disposent d'un GPU NVIDIA et souhaitent accélérer encore davantage la transcription, il est possible d'installer cuBLAS et cuDNN en suivant le guide GPU de Faster-Whisper. En l'absence de ces installations, le code s'exécutera par défaut sur le CPU.
Prétraitement audio : conversion des fichiers non-WAV
La majorité des fichiers audio que vous rencontrerez ne sont pas des fichiers WAV bruts. Ils utilisent souvent une compression (comme MP3) ou des formats conteneurs (tels que M4A). Il est donc nécessaire de les convertir en WAV PCM mono à 16 kHz avant de les fournir à Whisper.
Voici une fonction Python qui utilise pydub (qui appelle FFmpeg en arrière-plan) pour effectuer cette conversion :
from pydub import AudioSegment
def convert_to_wav(input_path, output_path=None):
"""Convertir n'importe quel fichier audio (MP3, M4A, OGG, etc.) en WAV (16 kHz, mono)."""
if output_path is None:
base, _ = os.path.splitext(input_path)
output_path = base + ".wav"
# Charger l'audio (pydub utilise ffmpeg)
audio = AudioSegment.from_file(input_path)
# Convertir en mono et définir la fréquence d'échantillonnage à 16000 Hz
audio = audio.set_channels(1).set_frame_rate(16000)
audio.export(output_path, format="wav")
return output_path
wav_file = convert_to_wav("meeting.mp3") print(f"Converti en : {wav_file}")
## Script de transcription de base avec Faster-Whisper
Écrivons maintenant un script Python complet qui charge un modèle Whisper, transcrit un fichier WAV et imprime le résultat :
```python
from faster_whisper import WhisperModel
def transcribe_audio(wav_path, model_size="base", device="cpu"):
"""Transcrire un fichier WAV (16 kHz mono) en utilisant Faster-Whisper."""
model = WhisperModel(model_size, device=device, compute_type="int8")
# Exécuter la transcription
segments, info = model.transcribe(wav_path, beam_size=5, language="en")
print(f"Langue détectée : {info.language} (probabilité : {info.language_probability:.2f})")
print("\nTranscription :")
for segment in segments:
print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")
# Retourner le texte complet si nécessaire
full_text = " ".join([seg.text for seg in segments])
return full_text
if __name__ == "__main__":
text = transcribe_audio("my_recording.wav", model_size="small", device="cpu")
Que se passe-t-il dans le code ci-dessus ?
WhisperModel télécharge le modèle choisi (par exemple, small) dans ~/.cache/huggingface/hub lors de la première exécution.
beam_size=5équilibre précision et vitesse. Des valeurs plus élevées (par exemple, 10) sont plus lentes mais plus précises.compute_type="int8"utilise des mathématiques en entier 8 bits pour une inférence plus rapide. Pour le GPU, vous pouvez essayer "float16".
Complexité de configuration
- Lent (mais acceptable pour des fichiers de moins de 10 minutes)
- Aucune (juste installer)
- Débutants, ordinateurs portables, petits projets
- Nécessite des pilotes NVIDIA, cuBLAS, cuDNN
- Fichiers longs, transcription par lots
Pour utiliser un GPU, changez device="cuda" dans le code. Faster-Whisper détecte automatiquement CUDA si installé correctement.
Astuce : Même sur CPU, Faster-Whisper est beaucoup plus rapide que l'original Whisper. Pour un MP3 de 10 minutes, le modèle de base sur un CPU moderne prend environ 2 minutes.
Conversion de MP3 en transcription : un exemple complet
Voici un script complet qui convertit n'importe quel fichier audio en WAV, puis le transcrit :
from pydub import AudioSegment
from faster_whisper import WhisperModel
def convert_to_wav(input_path):
"""Convertir tout audio en WAV mono à 16 kHz."""
audio = AudioSegment.from_file(input_path)
audio = audio.set_channels(1).set_frame_rate(16000)
wav_path = os.path.splitext(input_path)[0] + ".wav"
audio.export(wav_path, format="wav")
def transcribe_file(audio_path, model_size="base", device="cpu"):
# Étape 1 : Convertir si ce n'est pas déjà un WAV
if not audio_path.lower().endswith(".wav"):
print(f"Conversion de {audio_path} en WAV...")
audio_path = convert_to_wav(audio_path)
# Étape 2 : Transcrire
print(f"Chargement du modèle '{model_size}' sur {device.upper()}...")
model = WhisperModel(model_size, device=device, compute_type="int8")
segments, info = model.transcribe(audio_path, beam_size=5)
print(f"\nLangue : {info.language} (probabilité : {info.language_probability:.2f})")
print("\nTranscription :")
for seg in segments:
print(seg.text, end=" ", flush=True)
print() # nouvelle ligne finale
if __name__ == "__main__":
# Exemple : transcrire un fichier MP3
transcribe_file("interview.mp3", model_size="small", device="cpu")
Enregistrez cela sous le nom transcribe.py et exécutez :
python transcribe.py
Le script téléchargera le modèle une fois, convertira le fichier et affichera la transcription.
Vous disposez maintenant d'un système de transcription audio local, rapide et respectueux de la vie privée. Quelques points clés à retenir :
- Faster-Whisper vous offre une transcription quasi en temps réel sur un CPU et une excellente vitesse sur un GPU.
- Toujours prétraiter l'audio à 16 kHz mono WAV en utilisant pydub et FFmpeg.
- Le paramètre model_size échange précision contre vitesse — commencez par "base" ou "small".
- Exécuter localement signifie pas de clés API, pas de partage de données et pas de frais mensuels.
- Essayez différentes tailles de modèles Whisper pour une meilleure précision. Ajoutez la diarisation des locuteurs (identifier qui a parlé quand) en utilisant des bibliothèques comme pyannote.audio. Créez une interface web simple avec Gradio ou Streamlit.
