Whisper
Présentation
Transcrivez de l'audio avec Whisper d'OpenAI — le modèle de reconnaissance vocale de pointe. Ce skill couvre Whisper local (Python), faster-whisper (CTranslate2, 4x plus rapide), whisper.cpp (C++ optimisé CPU) et l'API OpenAI Whisper. Inclut la génération de sous-titres (SRT/VTT/JSON), la transcription multilingue, la traduction vers l'anglais, la diarisation des locuteurs, les horodatages au niveau du mot et des modèles de pipeline de production pour podcasts, réunions et sous-titres vidéo.
Instructions
Étape 1 : Choisissez votre environnement d'exécution
Option A — OpenAI Whisper (Python original) :
pip install openai-whisper
# Modèles : tiny (39M), base (74M), small (244M), medium (769M), large-v3 (1,5G)
Option B — faster-whisper (recommandé pour le local, 4x plus rapide) :
pip install faster-whisper
# Utilise CTranslate2 — quantification INT8, fonctionne bien sur CPU
Option C — whisper.cpp (meilleur pour CPU, dépendances minimales) :
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp && make
# Télécharger le modèle
bash models/download-ggml-model.sh base.en
Option D — API OpenAI (aucun GPU local nécessaire) :
pip install openai
export OPENAI_API_KEY="sk-..."
Étape 2 : Transcription de base
faster-whisper (recommandé) :
from faster_whisper import WhisperModel
model = WhisperModel("base", device="cpu", compute_type="int8")
# GPU : model = WhisperModel("large-v3", device="cuda", compute_type="float16")
segments, info = model.transcribe("episode.mp3", beam_size=5)
print(f"Langue : {info.language} (probabilité : {info.language_probability:.2f})")
for segment in segments:
print(f"[{segment.start:.2f}s → {segment.end:.2f}s] {segment.text}")
OpenAI Whisper (original) :
import whisper
model = whisper.load_model("base") # tiny, base, small, medium, large-v3
result = model.transcribe("episode.mp3")
print(result["text"])
for segment in result["segments"]:
print(f"[{segment['start']:.1f}s - {segment['end']:.1f}s] {segment['text']}")
whisper.cpp (CLI) :
./main -m models/ggml-base.en.bin -f episode.wav -otxt -osrt -ovtt
# Produit : episode.txt, episode.srt, episode.vtt
API OpenAI :
from openai import OpenAI
client = OpenAI()
with open("episode.mp3", "rb") as f:
transcript = client.audio.transcriptions.create(
model="whisper-1",
file=f,
response_format="verbose_json",
timestamp_granularities=["segment", "word"],
)
print(transcript.text)
for segment in transcript.segments:
print(f"[{segment.start:.1f}s] {segment.text}")
Étape 3 : Génération de sous-titres (SRT/VTT)
Générer un SRT avec faster-whisper :
from faster_whisper import WhisperModel
model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe("episode.mp3", beam_size=5)
def format_timestamp(seconds):
h = int(seconds // 3600)
m = int((seconds % 3600) // 60)
s = int(seconds % 60)
ms = int((seconds % 1) * 1000)
return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
with open("episode.srt", "w") as f:
for i, seg in enumerate(segments, 1):
f.write(f"{i}\n")
f.write(f"{format_timestamp(seg.start)} --> {format_timestamp(seg.end)}\n")
f.write(f"{seg.text.strip()}\n\n")
print("Fichier episode.srt généré")
Générer un VTT (pour vidéo HTML5) :
with open("episode.vtt", "w") as f:
f.write("WEBVTT\n\n")
for i, seg in enumerate(segments, 1):
start = format_timestamp(seg.start).replace(",", ".")
end = format_timestamp(seg.end).replace(",", ".")
f.write(f"{start} --> {end}\n")
f.write(f"{seg.text.strip()}\n\n")
Horodatages au niveau du mot (pour sous-titres style karaoké) :
segments, info = model.transcribe("episode.mp3", word_timestamps=True)
for segment in segments:
for word in segment.words:
print(f" [{word.start:.2f}s → {word.end:.2f}s] {word.word}")
Étape 4 : Détection de langue et traduction
# Détection automatique de la langue
segments, info = model.transcribe("foreign_audio.mp3")
print(f"Langue détectée : {info.language} ({info.language_probability:.0%})")
# Forcer une langue spécifique
segments, info = model.transcribe("german.mp3", language="de")
# Traduire en anglais (toute langue → anglais)
segments, info = model.transcribe("german.mp3", task="translate")
for seg in segments:
print(seg.text) # Traduction en anglais
Langues supportées : 99 langues dont en, zh, de, es, ru, ko, fr, ja, pt, tr, pl, nl, ar, sv, it, hi, et bien d'autres.
Étape 5 : Diarisation des locuteurs
Combinez Whisper avec pyannote-audio pour identifier « qui a dit quoi » :
from faster_whisper import WhisperModel
from pyannote.audio import Pipeline
import torch
# Transcrire
model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe("meeting.wav", beam_size=5)
whisper_segments = list(segments)
# Diariser (nécessite un token HuggingFace avec accès à pyannote)
diarization = Pipeline.from_pretrained(
"pyannote/speaker-diarization-3.1",
use_auth_token="hf_VOTRE_TOKEN"
)
diarization_result = diarization("meeting.wav")
# Fusionner : assigner un locuteur à chaque segment Whisper
def get_speaker(start, end, diarization_result):
"""Trouve le locuteur dominant pendant une plage temporelle."""
speakers = {}
for turn, _, speaker in diarization_result.itertracks(yield_label=True):
overlap_start = max(start, turn.start)
overlap_end = min(end, turn.end)
if overlap_start < overlap_end:
duration = overlap_end - overlap_start
speakers[speaker] = speakers.get(speaker, 0) + duration
return max(speakers, key=speakers.get) if speakers else "Inconnu"
for seg in whisper_segments:
speaker = get_speaker(seg.start, seg.end, diarization_result)
print(f"[{speaker}] [{seg.start:.1f}s → {seg.end:.1f}s] {seg.text}")
Étape 6 : Traitement par lots et pipelines
Transcrire tous les épisodes d'un répertoire :
import os
from pathlib import Path
from faster_whisper import WhisperModel
model = WhisperModel("small", device="cpu", compute_type="int8")
episodes_dir = Path("episodes")
output_dir = Path("transcriptions")
output_dir.mkdir(exist_ok=True)
for audio_file in sorted(episodes_dir.glob("*.mp3")):
print(f"Transcription en cours : {audio_file.name}")
segments, info = model.transcribe(str(audio_file), beam_size=5)
# Texte brut
txt_path = output_dir / f"{audio_file.stem}.txt"
with open(txt_path, "w") as f:
for seg in segments:
f.write(seg.text.strip() + "\n")
# SRT
srt_path = output_dir / f"{audio_file.stem}.srt"
segments2, _ = model.transcribe(str(audio_file), beam_size=5) # Ré-itérer
with open(srt_path, "w") as f:
for i, seg in enumerate(segments2, 1):
h, m = divmod(int(seg.start), 3600)
m, s = divmod(m, 60)
ms = int((seg.start % 1) * 1000)
start_ts = f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
h2, m2 = divmod(int(seg.end), 3600)
m2, s2 = divmod(m2, 60)
ms2 = int((seg.end % 1) * 1000)
end_ts = f"{h2:02d}:{m2:02d}:{s2:02d},{ms2:03d}"
f.write(f"{i}\n{start_ts} --> {end_ts}\n{seg.text.strip()}\n\n")
print(f" → {txt_path}, {srt_path}")
Étape 7 : Guide de sélection du modèle
| Modèle | Taille | VRAM | Vitesse (CPU) | Précision | Idéal pour |
|---|---|---|---|---|---|
| tiny | 39M | ~1 Go | Très rapide | Faible | Brouillons rapides, temps réel |
| base | 74M | ~1 Go | Rapide | Moyenne | Bon équilibre pour CPU |
| small | 244M | ~2 Go | Modérée | Bonne | Podcasts, audio clair |
| medium | 769M | ~5 Go | Lente | Très bonne | Audio bruité, accents |
| large-v3 | 1,5 Go | ~10 Go | Très lente | Excellente | Qualité production |
Recommandations :
- CPU uniquement, la vitesse compte :
tinyoubaseavec faster-whisper - CPU uniquement, la précision compte :
smallavec faster-whisper - GPU disponible :
large-v3avec faster-whisper (float16) - Aucun calcul local : API OpenAI (
whisper-1)
Exemples
Exemple 1 : Transcrire une saison de podcast et générer des sous-titres SRT
Invite utilisateur : « Transcrivez les 20 épisodes MP3 dans ./episodes/ et générez à la fois des transcriptions en texte brut et des fichiers de sous-titres SRT. J'ai un GPU avec 10 Go de VRAM. »
L'agent va :
- Installer faster-whisper via
pip install faster-whisper. - Charger le modèle
large-v3avecdevice="cuda"etcompute_type="float16"pour exploiter le GPU. - Créer un répertoire de sortie
./transcriptions/. - Parcourir tous les fichiers
.mp3dans./episodes/, en transcrivant chacun avecbeam_size=5. - Écrire à la fois un fichier
.txt(texte brut) et un fichier.srt(avec horodatages correctement formatés) pour chaque épisode. - Signaler la langue détectée et le temps de traitement total par épisode.
Exemple 2 : Traduire un entretien allemand en anglais avec étiquettes de locuteurs
Invite utilisateur : « J'ai un enregistrement d'entretien en allemand de 45 minutes dans meeting.wav avec deux locuteurs. Transcrivez-le en anglais et étiquetez qui a dit quoi. »
L'agent va :
- Installer faster-whisper et pyannote-audio (
pip install faster-whisper pyannote.audio). - Transcrire
meeting.wavavectask="translate"pour obtenir le texte anglais à partir de l'audio allemand. - Exécuter la diarisation des locuteurs pyannote pour identifier les segments de locuteurs (nécessite un token HuggingFace avec accès au modèle pyannote).
- Fusionner les segments Whisper avec les résultats de diarisation en faisant correspondre les plages temporelles pour attribuer des étiquettes de locuteurs.
- Produire une transcription formatée avec les étiquettes
[Locuteur 1]et[Locuteur 2]avant chaque segment.
Directives
- Utilisez faster-whisper plutôt que l'original OpenAI Whisper pour la transcription locale ; il est 4x plus rapide et utilise moins de mémoire grâce à la quantification INT8 via CTranslate2.
- Choisissez la taille du modèle en fonction de votre matériel :
tiny/basepour la vitesse sur CPU,smallpour la précision sur CPU,large-v3pour la qualité production sur GPU. - Convertissez toujours l'audio en WAV ou assurez-vous que ffmpeg est installé lorsque vous travaillez avec des entrées MP3/M4A ; Whisper dépend de ffmpeg pour le décodage des formats autres que WAV.
- Pour la diarisation des locuteurs, le pipeline pyannote nécessite un jeton d'accès HuggingFace avec les conditions d'utilisation du modèle acceptées ; configurez-le avant de tenter une transcription multi-locuteurs.
- Lors de la génération de fichiers SRT, utilisez
beam_size=5pour des limites de segments plus précises ; le décodage glouton par défaut peut produire des coupures de sous-titres mal synchronisées.