Whisper API : transcription d’interviews en français africain

Ce que vous saurez faire

A la fin de ce tutoriel, vous saurez transcrire automatiquement n’importe quel fichier audio en texte ecrit grace a Whisper, le modele open-source d’OpenAI, qui tourne entierement sur votre PC sans envoyer aucune donnee dans le cloud. Cas concrets pour les PME senegalaises : retranscrire les reunions du conseil d’administration, sous-titrer une video commerciale en wolof et francais, indexer 200 heures d’enregistrements call-center, transformer un message vocal WhatsApp d’un client en bon de commande. Cout : 0 FCFA en electricite par minute traitee. Confidentialite : 100 pour cent garantie, rien ne sort de votre machine.

Etape 1 : Choisir la bonne taille de modele

Whisper existe en 5 tailles. Pour le francais et le wolof :

• tiny (75 Mo) : rapide mais imprecis, OK pour un brouillon
• base (150 Mo) : bon compromis pour PC modeste
• small (500 Mo) : qualite professionnelle, recommande
• medium (1,5 Go) : excellent, necessite 8 Go de RAM
• large-v3 (3 Go) : qualite humaine, GPU recommande

Pour la majorite des PME, le modele small suffit largement.

Etape 2 : Installer Python et FFmpeg

Whisper a besoin de FFmpeg pour decoder les audios. Sur Windows, telechargez ffmpeg.org puis ajoutez le bin au PATH. Sur Ubuntu :

sudo apt update
sudo apt install ffmpeg python3.11 python3.11-venv -y

# Verifier
ffmpeg -version

Etape 3 : Creer l’environnement Python

mkdir whisper-pme
cd whisper-pme
python -m venv venv
source venv/bin/activate  # ou venv\Scripts\activate

pip install --upgrade pip
pip install openai-whisper==20231117
pip install torch==2.4.1 torchaudio==2.4.1

Sur Windows sans GPU NVIDIA, Torch s’installe en version CPU automatiquement.

Etape 4 : Premiere transcription en 3 lignes

Placez un fichier reunion.mp3 dans le dossier puis :

import whisper

modele = whisper.load_model("small")
resultat = modele.transcribe("reunion.mp3", language="fr")
print(resultat["text"])

Premier lancement : telechargement du modele (500 Mo, environ 5 minutes selon votre connexion). Ensuite tout est en cache local dans ~/.cache/whisper/.

Etape 5 : Tester avec un audio en wolof

Whisper supporte 99 langues, dont le wolof partiellement. Pour de meilleurs resultats sur du wolof, forcez la langue francais et il transcrira phonetiquement :

resultat = modele.transcribe(
    "message-wolof.opus",
    language="fr",
    initial_prompt="Conversation en wolof avec mots francais"
)
print(resultat["text"])

Etape 6 : Activer la detection automatique de langue

Pour des audios mixtes francais et anglais frequents en milieu professionnel africain :

resultat = modele.transcribe("appel-client.m4a")
print(f"Langue detectee : {resultat['language']}")
print(resultat["text"])

Etape 7 : Generer des sous-titres avec timecodes

Pour sous-titrer une video commerciale destinee a YouTube ou Facebook Ads :

resultat = modele.transcribe("pub-produit.mp4", language="fr")

with open("sous-titres.srt", "w", encoding="utf-8") as f:
    for i, seg in enumerate(resultat["segments"], start=1):
        debut = seg["start"]
        fin = seg["end"]
        texte = seg["text"].strip()
        f.write(f"{i}\n")
        f.write(f"{format_temps(debut)} --> {format_temps(fin)}\n")
        f.write(f"{texte}\n\n")

La fonction format_temps convertit 12.5 secondes en 00:00:12,500. Importez-la depuis un utilitaire ou ecrivez-la simplement.

Etape 8 : Ecrire la fonction format_temps

def format_temps(secondes):
    heures = int(secondes // 3600)
    minutes = int((secondes % 3600) // 60)
    sec = int(secondes % 60)
    millis = int((secondes - int(secondes)) * 1000)
    return f"{heures:02d}:{minutes:02d}:{sec:02d},{millis:03d}"

Etape 9 : Traiter un dossier complet en lot

Pour transcrire 100 enregistrements call-center d’un seul coup :

import os
from pathlib import Path

dossier = Path("./enregistrements")
sortie = Path("./transcriptions")
sortie.mkdir(exist_ok=True)

audios = list(dossier.glob("*.mp3")) + list(dossier.glob("*.wav")) + list(dossier.glob("*.m4a"))
print(f"{len(audios)} fichiers a traiter")

for i, audio in enumerate(audios, 1):
    print(f"[{i}/{len(audios)}] {audio.name}")
    res = modele.transcribe(str(audio), language="fr")
    with open(sortie / f"{audio.stem}.txt", "w", encoding="utf-8") as f:
        f.write(res["text"])

Etape 10 : Accelerer avec un GPU NVIDIA

Si vous avez un GPU NVIDIA (meme une GTX 1660 suffit), reinstallez Torch en version CUDA :

pip uninstall torch torchaudio
pip install torch==2.4.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu121

# Puis dans votre script
import torch
device = "cuda" if torch.cuda.is_available() else "cpu"
modele = whisper.load_model("medium", device=device)
print(f"Calcul sur {device}")

Gain typique : 10x plus rapide. Une heure d’audio en 6 minutes au lieu d’une heure.

Etape 11 : Utiliser faster-whisper pour aller 4x plus vite sur CPU

faster-whisper est une reimplementation C++ qui divise le temps par 4 sur CPU :

pip install faster-whisper==1.0.3

from faster_whisper import WhisperModel

modele = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = modele.transcribe("reunion.mp3", language="fr")
texte = " ".join([seg.text for seg in segments])
print(texte)

Etape 12 : Diariser – identifier qui parle

Whisper seul ne dit pas qui parle. Ajoutez pyannote.audio pour separer les intervenants d’une reunion :

pip install pyannote.audio==3.3.1

from pyannote.audio import Pipeline

pipeline = Pipeline.from_pretrained(
    "pyannote/speaker-diarization-3.1",
    use_auth_token="VOTRE_TOKEN_HUGGINGFACE"
)
diarisation = pipeline("reunion.wav")

for turn, _, speaker in diarisation.itertracks(yield_label=True):
    print(f"{turn.start:.1f}s - {turn.end:.1f}s : {speaker}")

Combinez avec les segments Whisper pour obtenir : « Intervenant 1 : … Intervenant 2 : … ».

Etape 13 : Nettoyer le texte avec un LLM

Whisper restitue mot a mot, donc beaucoup de « euh » et phrases mal ponctuees. Passez le texte dans Claude pour reformuler :

from anthropic import Anthropic
client = Anthropic()

reponse = client.messages.create(
    model="claude-3-haiku-20240307",
    max_tokens=2000,
    messages=[{
        "role": "user",
        "content": f"Reformule ce verbatim de reunion en compte-rendu structure (decisions, actions, dates) :\n\n{resultat['text']}"
    }]
)
print(reponse.content[0].text)

Etape 14 : Industrialiser avec une interface web Streamlit

pip install streamlit==1.38.0

# fichier app.py
import streamlit as st
import whisper
import tempfile

st.title("Transcripteur audio - PME Dakar")
fichier = st.file_uploader("Audio (mp3, wav, m4a)", type=["mp3", "wav", "m4a"])

if fichier and st.button("Transcrire"):
    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
        tmp.write(fichier.read())
        chemin = tmp.name
    with st.spinner("Transcription en cours..."):
        modele = whisper.load_model("small")
        res = modele.transcribe(chemin, language="fr")
    st.text_area("Resultat", res["text"], height=300)
    st.download_button("Telecharger TXT", res["text"], "transcription.txt")

# Lancer : streamlit run app.py

Erreurs

Erreur 1 : FFmpeg introuvable. Le message « FileNotFoundError ffmpeg » signale qu’il n’est pas dans le PATH. Ajoutez le dossier bin de FFmpeg aux variables d’environnement Windows.

Erreur 2 : RAM insuffisante avec medium ou large. Si Python crashe, descendez d’une taille de modele. Le modele small fonctionne sur 4 Go de RAM.

Erreur 3 : Audio de mauvaise qualite. Whisper ne peut pas transcrire un audio sature ou plein de bruit. Pretraitez avec Audacity (effet noise reduction et normalize).

Erreur 4 : Forcer la mauvaise langue. Si vous mettez language= »en » sur du francais, Whisper invente n’importe quoi. Utilisez la detection auto en cas de doute.

Erreur 5 : Modele recharge a chaque appel. Chargez whisper.load_model une seule fois au demarrage de votre script ou serveur web. Sinon vous attendez 30 secondes par transcription.

Checklist

1. Python 3.11+ et environnement virtuel actif
2. FFmpeg installe et accessible en ligne de commande
3. Modele Whisper telecharge et mis en cache local
4. Test sur un fichier court (30 secondes) reussi
5. Langue forcee en francais ou detection auto selon les cas
6. Generation SRT testee pour les videos a sous-titrer
7. Traitement par lot d’un dossier complet operationnel
8. GPU active si disponible pour gains de vitesse
9. faster-whisper installe en alternative pour CPU
10. Diarisation pyannote configuree si reunions multi-locuteurs
11. Nettoyage du verbatim par Claude pour comptes-rendus
12. Interface Streamlit deployee pour usage par non-techniciens
13. Politique de confidentialite redigee (donnees restent en local)
14. Procedure de sauvegarde des transcriptions sur disque ou cloud souverain