Intelligence Artificielle

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

9 min de lecture

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 modèle open-source d’OpenAI, qui tourne entièrement sur votre PC sans envoyer aucune donnée dans le cloud. Cas concrets pour les PME sénégalaises : retranscrire les réunions du conseil d’administration, sous-titrer une video commerciale en wolof et français, indexer 200 heures d’enregistrements call-center, transformer un message vocal WhatsApp d’un client en bon de commande. Coût : 0 FCFA en électricité par minute traitée. Confidentialite : 100 pour cent garantie, rien ne sort de votre machine.

Étape 1 : Choisir la bonne taille de modèle

Whisper existe en 5 tailles. Pour le français et le wolof :

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

Pour la majorité des PME, le modèle small suffit largement.

Étape 2 : Installer Python et FFmpeg

Whisper a besoin de FFmpeg pour decoder les audios. Sur Windows, téléchargez 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

Whisper exige Python 3.9+ et FFmpeg pour décoder les fichiers audio. Sur Ubuntu 22.04 ou Debian 12, installez via sudo apt update && sudo apt install python3 python3-pip ffmpeg -y. Sur macOS, utilisez Homebrew : brew install python ffmpeg. Sur Windows, téléchargez Python depuis python.org et FFmpeg depuis ffmpeg.org puis ajoutez-le au PATH. Vérifiez avec ffmpeg -version et python3 --version. Sans FFmpeg, Whisper échoue avec une erreur cryptique ‘No such file or directory’.

Étape 3 : Créer 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.

Créez un environnement virtuel pour isoler les dépendances : python3 -m venv whisper-env && source whisper-env/bin/activate. Installez OpenAI Whisper : pip install openai-whisper. Cette commande télécharge ~5-10 Mo de package + ~140 Mo de poids du modèle base au premier appel. Pour des transcriptions de meilleure qualité, optez pour le modèle medium (~1,4 Go) ou large-v3 (~3 Go). Adaptez selon RAM disponible et précision visée.

Étape 4 : Première transcription en 3 lignes

Placez un fichier réunion.mp3 dans le dossier puis :

import whisper

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

Premier lancement : téléchargement du modèle (500 Mo, environ 5 minutes selon votre connexion). Ensuite tout est en cache local dans ~/.cache/whisper/.

Le code minimum pour transcrire : import whisper; model = whisper.load_model('base'); result = model.transcribe('interview.mp3'); print(result['text']). Sur un CPU moderne (Intel i5 8 cores), comptez 1x temps réel pour le modèle base (1 minute audio = 1 minute traitement). Avec une RTX 3060 GPU, on tombe à 8-10x temps réel. Pour une journaliste à Plateau qui traite 10 interviews/semaine de 30 minutes, le modèle medium offre le meilleur ratio qualité/vitesse en français.

Étape 5 : Tester avec un audio en wolof

Whisper supporte 99 langues, dont le wolof partiellement. Pour de meilleurs résultats sur du wolof, forcez la langue français et il transcrira phonetiquement :

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

Whisper supporte officiellement 99 langues incluant l’arabe, le swahili, le yoruba. Le wolof n’est pas dans la liste mais Whisper a appris des bribes via les corpus multilingues web. Les résultats sont médiocres (50-70 % de précision contre 90-95 % en français). Pour des projets sérieux en wolof, fine-tunez Whisper sur un corpus annoté ou utilisez des alternatives spécialisées comme MMS de Meta ou les modèles de Lelapa AI orientés langues africaines.

Étape 6 : Activer la détection automatique de langue

Pour des audios mixtes français et anglais frequents en milieu professionnel africain :

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

Whisper détecte automatiquement la langue dominante des 30 premières secondes. Pour forcer une langue spécifique : model.transcribe('audio.mp3', language='fr'). Pour les interviews multilingues (locuteur qui passe du français au wolof), Whisper transcrit la langue dominante mais peut basculer dynamiquement. Pour des résultats consistants en français nuancé africain, ajoutez le paramètre initial_prompt avec un texte exemple en français qui guide le modèle stylistiquement.

Étape 7 : Générer des sous-titres avec timecodes

Pour sous-titrer une video commerciale destinée 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.

Étape 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}"

Pour générer des sous-titres SRT, vous avez besoin de formater les timestamps en HH:MM:SS,mmm. Une fonction helper : def format_temps(secondes): h = int(secondes//3600); m = int((secondes%3600)//60); s = int(secondes%60); ms = int((secondes%1)*1000); return f'{h:02d}:{m:02d}:{s:02d},{ms:03d}'. Itérez sur result[‘segments’] qui contient start, end et text de chaque segment. Concaténez en format SRT standard reconnu par tous les players vidéo.

Étape 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"])

Étape 10 : Accelerer avec un GPU NVIDIA

Si vous avez un GPU NVIDIA (même 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.

Étape 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)

Faster-whisper est une réimplémentation optimisée par SYSTRAN (open-source) qui tourne 4x plus vite que Whisper officiel sur CPU et 2x plus vite sur GPU. L’API est très similaire : from faster_whisper import WhisperModel; model = WhisperModel('medium', device='cpu', compute_type='int8'); segments, info = model.transcribe('audio.mp3'). Le compute_type int8 quantifie les poids et divise la mémoire par 4. Pour une équipe à Bamako qui traite 50 heures d’audio par semaine, faster-whisper économise 80 % du temps de calcul.

Étape 12 : Diariser – identifier qui parle

Whisper seul ne dit pas qui parle. Ajoutez pyannote.audio pour séparer les intervenants d’une réunion :

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 : … ».

Étape 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)

Étape 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 modèle. Le modèle small fonctionne sur 4 Go de RAM.

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

Erreur 4 : Forcer la mauvaise langue. Si vous mettez language= »en » sur du français, Whisper invente n’importe quoi. Utilisez la détection auto en cas de doute.

Erreur 5 : Modèle recharge a chaque appel. Chargez whisper.load_model une seule fois au démarrage 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. Modèle Whisper telecharge et mis en cache local
  4. Test sur un fichier court (30 secondes) réussi
  5. Langue forcee en français ou détection auto selon les cas
  6. Génération SRT testée pour les videos a sous-titrer
  7. Traitement par lot d’un dossier complet opérationnel
  8. GPU active si disponible pour gains de vitesse
  9. faster-whisper installe en alternative pour CPU
  10. Diarisation pyannote configurée si réunions multi-locuteurs
  11. Nettoyage du verbatim par Claude pour comptes-rendus
  12. Interface Streamlit déployée pour usage par non-techniciens
  13. Politique de confidentialite rédigée (données restent en local)
  14. Procédure de sauvegarde des transcriptions sur disque ou cloud souverain
Partager
#api-rest #python

Articles Similaires