Whisper : Transforme n'importe quel audio en texte avec l'IA d'OpenAI (de zéro à héro)

Tu as un fichier audio ou vidéo et tu dois le retranscrire à la main ? Tu perds des heures à taper ce que dit un podcast, une réunion ou une interview ? Dans ce tutoriel, tu vas apprendre à utiliser Whisper — le modèle de reconnaissance vocale open-source d'OpenAI — pour automatiser tout ça en quelques lignes de Python. À la fin, tu auras construit ton propre outil de dictée vocale, capable de transcrire des heures d'audio en texte parfaitement formaté, avec des sous-titres prêts à être importés dans YouTube ou VLC.

Pourquoi Whisper change tout

Whisper, c'est le modèle de speech-to-text (reconnaissance vocale) qu'OpenAI a publié en open-source en septembre 2022. Contrairement aux solutions propriétaires (Google Speech-to-Text, Amazon Transcribe, etc.), Whisper tourne gratuitement sur ta propre machine. Pas de cloud, pas de limite d'heures, pas de facture surprise.

Ce qui rend Whisper exceptionnel : - 97 langues supportées (dont le français avec une précision redoutable) - Robuste au bruit de fond (conversation dans un café ? Aucun problème) - Ponctuation automatique (majuscules, virgules, points, tout y est) - Détection de langue automatique (pas besoin de lui dire que c'est du français) - Transcription avec timestamps (pour générer des sous-titres SRT/VTT) - Plusieurs tailles de modèles (de tiny à large, selon la puissance de ta machine)

Ce qu'on va construire

À la fin de ce tutoriel, tu auras : 1. Un script Python qui transcrit n'importe quel fichier audio en texte 2. Un générateur de sous-titres SRT automatique 3. Un enregistreur vocal qui retranscrit ta voix en direct

1. Installation : prépare ton environnement

Prérequis

Tu as besoin de Python 3.9 ou plus récent. Ouvre un terminal et vérifie :

bash

python3 --version

Si tu vois Python 3.9.x ou plus, c'est bon.

Créer un environnement virtuel

Toujours travailler dans un environnement isolé :

bash

mkdir whisper-projet && cd whisper-projet
python3 -m venv venv
source venv/bin/activate  # Sur Windows : venv\Scripts\activate

Tu devrais voir (venv) apparaître au début de ta ligne de commande.

Installer Whisper

Il y a deux façons d'utiliser Whisper. Pour ce tutoriel, on va utiliser faster-whisper, une réimplémentation en C++ qui est 4 fois plus rapide et consomme 2 fois moins de mémoire :

bash

pip install faster-whisper

Pour l'enregistrement vocal en direct (section bonus), on ajoute aussi :

bash

pip install sounddevice numpy

💡 Si tu es sur Linux et que l'installation de sounddevice échoue, installe d'abord les librairies système : sudo apt install libportaudio2 portaudio19-dev

2. Première transcription : ton premier fichier audio

Télécharge un fichier audio de test

Pour commencer, on va utiliser un fichier MP3 libre de droits. Si tu as déjà un fichier audio (MP3, WAV, M4A, OGG…), utilise-le directement.

bash

# Télécharge un extrait audio libre de droits en français
curl -L -o test_audio.mp3 "https://www.audio-lingua.eu/IMG/mp3/maison.mp3"

Si le lien ne fonctionne pas, prends n'importe quel fichier audio que tu as sous la main.

Écris ton premier script de transcription

Crée un fichier transcrire.py :

python

from faster_whisper import WhisperModel

# 1. Choisis la taille du modèle (tiny, base, small, medium, large)
# Commence par "base" : bon compromis vitesse/précision pour le français
modele = WhisperModel("base", device="cpu", compute_type="int8")

# 2. Transcris le fichier audio
segments, infos = modele.transcribe("test_audio.mp3")

# 3. Affiche la langue détectée et le texte
print(f"🌍 Langue détectée : {infos.language} (probabilité : {infos.language_probability:.2%})")
print("\n📝 TRANSCRIPTION :\n")

texte_complet = ""
for segment in segments:
    print(f"[{segment.start:.1f}s → {segment.end:.1f}s] {segment.text}")
    texte_complet += segment.text + " "

print("\n" + "="*50)
print("TEXTE COMPLET :")
print(texte_complet.strip())

Lance le script

bash

python3 transcrire.py

Résultat attendu :

plaintext

🌍 Langue détectée : fr (probabilité : 98.50%)

📝 TRANSCRIPTION :

[0.0s → 3.2s] Bonjour, je m'appelle Marie et je vais vous parler de...
[3.2s → 6.8s] ...ma maison dans le sud de la France.

🎉 Bravo ! Tu viens de faire ta première transcription automatique. En 10 lignes de code, tu as remplacé des heures de saisie manuelle.

Les tailles de modèle : lequel choisir ?

Modèle	Taille	VRAM/RAM	Vitesse	Usage recommandé
`tiny`	39 Mo	~1 Go	⚡⚡⚡	Tests rapides, anglais uniquement
`base`	74 Mo	~1 Go	⚡⚡	Débuter en français ← Commence ici
`small`	244 Mo	~2 Go	⚡	Bon équilibre précision/vitesse
`medium`	769 Mo	~5 Go	🐢	Usage professionnel
`large-v3`	1.5 Go	~10 Go	🐢	Meilleure précision française

💡 Passe en device="cuda" si tu as une carte graphique NVIDIA pour aller 3 à 5 fois plus vite.

3. Générer des sous-titres SRT automatiquement

C'est probablement l'usage le plus utile de Whisper : créer des sous-titres pour YouTube, VLC, Netflix, etc. Voici le script complet.

Crée un fichier sous_titres.py :

python

from faster_whisper import WhisperModel
from datetime import timedelta

def generer_srt(segments, fichier_sortie="sous_titres.srt"):
    """Convertit les segments Whisper en fichier SRT."""
    with open(fichier_sortie, "w", encoding="utf-8") as f:
        for i, segment in enumerate(segments, start=1):
            # Format timestamp SRT : HH:MM:SS,mmm
            debut = str(timedelta(seconds=segment.start))
            fin = str(timedelta(seconds=segment.end))
            
            # Assure le format avec virgule pour les millisecondes
            if "." in debut:
                debut = debut.replace(".", ",")[:11]
            else:
                debut += ",000"
            if "." in fin:
                fin = fin.replace(".", ",")[:11]
            else:
                fin += ",000"
            
            f.write(f"{i}\n")
            f.write(f"{debut} --> {fin}\n")
            f.write(f"{segment.text.strip()}\n\n")
    
    print(f"✅ Sous-titres générés : {fichier_sortie} ({i} segments)")

# Transcription
modele = WhisperModel("medium", device="cpu", compute_type="int8")
segments, infos = modele.transcribe("test_audio.mp3", language="fr")

# Génération SRT
generer_srt(segments, "sous_titres.srt")

Exécute :

bash

python3 sous_titres.py

Tu obtiens un fichier sous_titres.srt que tu peux directement : - Importer dans YouTube (Upload → Sous-titres → Importer) - Ouvrir dans VLC (Sous-titres → Ajouter un fichier de sous-titres) - Utiliser avec n'importe quel logiciel de montage (DaVinci Resolve, Premiere Pro, CapCut…)

Format VTT (sous-titres web)

Pour les sous-titres au format WebVTT (utilisé par les lecteurs HTML5), remplace la fonction generer_srt par celle-ci :

python

def generer_vtt(segments, fichier_sortie="sous_titres.vtt"):
    with open(fichier_sortie, "w", encoding="utf-8") as f:
        f.write("WEBVTT\n\n")
        for segment in segments:
            debut = str(timedelta(seconds=segment.start))
            fin = str(timedelta(seconds=segment.end))
            if "." in debut: debut = debut.replace(".", ".")[:11]
            else: debut += ".000"
            if "." in fin: fin = fin.replace(".", ".")[:11]
            else: fin += ".000"
            f.write(f"{debut} --> {fin}\n")
            f.write(f"{segment.text.strip()}\n\n")

4. Transcrire des fichiers longs (podcasts, réunions, cours)

Pour un fichier audio de plus de 10 minutes, la charge mémoire peut devenir élevée. Voici la solution : découper avant de transcrire.

python

from faster_whisper import WhisperModel
from pydub import AudioSegment
import os

def transcrire_fichier_long(fichier_audio, duree_segment_ms=300000):
    """
    Découpe un long fichier audio en segments de 5 minutes,
    transcrit chaque segment, et assemble le résultat.
    """
    # Charge l'audio avec pydub
    audio = AudioSegment.from_file(fichier_audio)
    total_ms = len(audio)
    
    modele = WhisperModel("medium", device="cpu", compute_type="int8")
    texte_complet = ""
    
    # Découpe et transcrit
    for debut in range(0, total_ms, duree_segment_ms):
        fin = min(debut + duree_segment_ms, total_ms)
        segment_audio = audio[debut:fin]
        
        # Sauvegarde le segment temporaire
        segment_path = f"/tmp/segment_{debut}.wav"
        segment_audio.export(segment_path, format="wav")
        
        # Transcription
        segments, infos = modele.transcribe(segment_path, language="fr")
        for seg in segments:
            texte_complet += seg.text + " "
        
        os.remove(segment_path)
        print(f"✅ Segment {debut//duree_segment_ms + 1} transcrit "
              f"({debut//1000}s → {fin//1000}s)")
    
    return texte_complet.strip()

# Pour l'utiliser, installe d'abord pydub :
# pip install pydub
# Sur Linux : sudo apt install ffmpeg

# texte = transcrire_fichier_long("ma_reunion_2h.mp3")
# print(texte)

💡 Astuce pro : Si tu n'as pas beaucoup de RAM, utilise WhisperModel("small", ...) pour les longs fichiers.

5. Bonus : construis ton dictaphone intelligent

Transforme ton micro en outil de dictée vocale. Cet enregistreur capture ta voix, la transcrit en direct, et sauvegarde le texte.

python

import sounddevice as sd
import numpy as np
import wave
import tempfile
import os
from faster_whisper import WhisperModel

# Paramètres d'enregistrement
FREQUENCE = 16000  # 16 kHz — idéal pour Whisper
DUREE_MAX = 60     # Durée max d'enregistrement en secondes

def enregistrer_et_transcrire():
    print("🎙️  Prêt à enregistrer. Appuie sur Entrée pour commencer...")
    input()
    
    print("🔴 ENREGISTREMENT EN COURS... Parle maintenant !")
    print("   (Appuie sur Ctrl+C pour arrêter avant la fin)")
    
    # Enregistre l'audio depuis le micro
    audio = sd.rec(
        int(DUREE_MAX * FREQUENCE),
        samplerate=FREQUENCE,
        channels=1,
        dtype='int16'
    )
    
    try:
        sd.wait()  # Attend la fin de l'enregistrement
    except KeyboardInterrupt:
        sd.stop()
        print("\n⏹️  Enregistrement arrêté.")
    
    print("✅ Enregistrement terminé. Transcription en cours...")
    
    # Sauvegarde l'audio dans un fichier temporaire WAV
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
        with wave.open(tmp.name, 'wb') as wf:
            wf.setnchannels(1)
            wf.setsampwidth(2)  # 16 bits = 2 octets
            wf.setframerate(FREQUENCE)
            wf.writeframes(audio.tobytes())
    
    # Transcription avec Whisper
    modele = WhisperModel("base", device="cpu", compute_type="int8")
    segments, infos = modele.transcribe(tmp.name, language="fr")
    
    print(f"\n🌍 Langue : {infos.language}")
    print("📝 TRANSCRIPTION :\n")
    
    texte = ""
    for seg in segments:
        print(f"  {seg.text}")
        texte += seg.text + " "
    
    # Sauvegarde dans un fichier texte
    with open("dictée.txt", "w") as f:
        f.write(texte.strip())
    
    os.unlink(tmp.name)
    print(f"\n💾 Texte sauvegardé dans dictée.txt ({len(texte.split())} mots)")

if __name__ == "__main__":
    enregistrer_et_transcrire()

Lance-le :

bash

python3 dictee.py

Parle normalement, et regarde la magie opérer.

6. Pièges classiques (et comment les éviter)

Piège n°1 : `ValueError: ffmpeg not found`

Whisper a besoin de ffmpeg pour lire les formats compressés (MP3, M4A, MP4…).

Solution : - Linux : sudo apt install ffmpeg - macOS : brew install ffmpeg - Windows : Télécharge ffmpeg depuis ffmpeg.org, ajoute-le au PATH, ou utilise pip install ffmpeg-python et configure le chemin.

Piège n°2 : Transcription lente sur CPU

Le modèle large-v3 sur CPU peut prendre 10 minutes pour transcrire 1 minute d'audio.

Solution : Commence TOUJOURS par base ou small. Passe à medium ou large uniquement si tu as une carte graphique NVIDIA. Active CUDA :

python

modele = WhisperModel("large-v3", device="cuda", compute_type="float16")

Piège n°3 : La langue est mal détectée

Whisper détecte automatiquement la langue, mais il peut se tromper sur des extraits très courts (< 3 secondes) ou avec un fort accent.

Solution : Force la langue :

python

segments, _ = modele.transcribe("audio.mp3", language="fr")

Piège n°4 : Résultats incohérents sur les noms propres

Whisper peut écorcher les noms propres, les acronymes ou le jargon technique.

Solution : Utilise le paramètre initial_prompt pour guider le modèle :

python

segments, _ = modele.transcribe(
    "interview.mp3",
    language="fr",
    initial_prompt="Interview de Jean Dupont, CEO de TechCorp, à propos de l'IA générative et du NLP."
)

Le modèle utilise ce contexte pour mieux deviner les mots ambigus. C'est particulièrement efficace pour les noms propres.

Piège n°5 : Mémoire insuffisante (Out of Memory)

Le modèle large-v3 charge ~10 Go en RAM. Si tu as 8 Go de RAM, ça va swapper et devenir extrêmement lent.

Solution : Utilise medium (5 Go) ou small (2 Go) sur les machines modestes.

7. Pour aller plus loin

1. Intégrer Whisper dans un projet web

Construis une API REST avec FastAPI pour servir ton modèle de transcription :

python

from fastapi import FastAPI, UploadFile, File
from faster_whisper import WhisperModel
import tempfile

app = FastAPI()
modele = WhisperModel("small", device="cpu", compute_type="int8")

@app.post("/transcrire/")
async def transcrire(fichier: UploadFile = File(...)):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
        tmp.write(await fichier.read())
    
    segments, infos = modele.transcribe(tmp.name, language="fr")
    texte = " ".join([seg.text for seg in segments])
    
    return {"langue": infos.language, "texte": texte}

Lance avec uvicorn main:app --reload et teste sur http://localhost:8000/docs.

2. Traduire en direct avec Whisper

Whisper ne traduit que vers l'anglais avec la tâche translate. Pour traduire vers le français, chaîne Whisper avec un LLM :

python

# Transcription avec Whisper (depuis l'anglais)
segments, _ = modele.transcribe("podcast_us.mp3", task="translate")
texte_en = " ".join([s.text for s in segments])

# Traduction FR avec GPT (via l'API OpenAI ou Ollama en local)
import openai
client = openai.OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
response = client.chat.completions.create(
    model="llama3",
    messages=[{"role": "user", "content": f"Traduis en français : {texte_en}"}]
)
print(response.choices[0].message.content)

3. Diarisation : qui a dit quoi ?

Whisper ne fait pas de diarisation (identifier qui parle). Combine-le avec pyannote.audio :

bash

pip install pyannote.audio

Et utilise le pipeline pyannote/speaker-diarization-3.1 sur Hugging Face pour obtenir les segments par locuteur avant de les envoyer à Whisper.

Résumé

En 30 minutes, tu as appris à : - ✅ Transcrire n'importe quel audio en texte avec 10 lignes de Python - ✅ Générer des sous-titres SRT et VTT automatiquement - ✅ Gérer les fichiers longs avec découpage intelligent - ✅ Construire un dictaphone qui retranscrit ta voix en direct - ✅ Éviter les 5 erreurs les plus fréquentes - ✅ Déployer une API de transcription avec FastAPI

💡 Idée d'illustration : Un split-screen montrant à gauche un fichier audio avec sa forme d'onde, et à droite le texte transcrit qui apparaît en temps réel, avec les timestamps visibles. En médaillon, les logos de Python, Whisper et ffmpeg. Style épuré, bleu nuit, code visible en arrière-plan. Le tout sur fond sombre avec des accents néon bleu/violet.

Pourquoi Whisper change tout

Ce qu'on va construire

1. Installation : prépare ton environnement

Prérequis

Créer un environnement virtuel

Installer Whisper

2. Première transcription : ton premier fichier audio

Télécharge un fichier audio de test

Écris ton premier script de transcription

Lance le script

Les tailles de modèle : lequel choisir ?

3. Générer des sous-titres SRT automatiquement

Format VTT (sous-titres web)

4. Transcrire des fichiers longs (podcasts, réunions, cours)

5. Bonus : construis ton dictaphone intelligent

6. Pièges classiques (et comment les éviter)

Piège n°1 : ValueError: ffmpeg not found

Piège n°2 : Transcription lente sur CPU

Piège n°3 : La langue est mal détectée

Piège n°4 : Résultats incohérents sur les noms propres

Piège n°5 : Mémoire insuffisante (Out of Memory)

7. Pour aller plus loin

1. Intégrer Whisper dans un projet web

2. Traduire en direct avec Whisper

3. Diarisation : qui a dit quoi ?

Résumé

Piège n°1 : `ValueError: ffmpeg not found`