Optimiser la qualité de transcription

Whisper produit d’excellentes transcriptions par défaut, mais plusieurs techniques permettent d’améliorer significativement la qualité, surtout dans les cas difficiles : bruit de fond, accents régionaux, vocabulaire technique, noms propres. Cette leçon couvre les paramètres avancés et les stratégies de post-traitement.

Le paramètre prompt

Le prompt est votre levier principal pour améliorer la qualité. Il sert d’amorce contextuelle : Whisper s’en sert pour calibrer sa reconnaissance sur le vocabulaire et le style attendus.

# Sans prompt — Whisper peut mal interpréter les termes techniques
result = client.audio.transcriptions.create(
    model="whisper-1",
    file=audio_file,
    language="fr"
)
# → "Notre solution utilise le modèle gpt cinq point quatre..."

# Avec prompt — les termes sont correctement transcrits
result = client.audio.transcriptions.create(
    model="whisper-1",
    file=audio_file,
    language="fr",
    prompt="GPT-5.4, o3-pro, Responses API, Realtime API, Whisper, "
           "Corsen AI, Mordehai Attia"
)
# → "Notre solution utilise le modèle GPT-5.4..."

Bonnes pratiques pour le prompt

Listez les noms propres : personnes, entreprises, produits
Incluez le jargon technique : acronymes, termes métier
Indiquez le style attendu : ponctuation, casse
Limitez à 224 tokens : au-delà, Whisper tronque silencieusement

def build_transcription_prompt(context: dict) -> str:
    """Construit un prompt optimisé pour Whisper."""
    parts = []

    if context.get("speakers"):
        parts.append(", ".join(context["speakers"]))

    if context.get("technical_terms"):
        parts.append(", ".join(context["technical_terms"]))

    if context.get("topic"):
        parts.append(context["topic"])

    return ". ".join(parts)

prompt = build_transcription_prompt({
    "speakers": ["Mordehai Attia", "Yoram Halberstam"],
    "technical_terms": ["Realtime API", "WebSocket", "VAD", "PCM16"],
    "topic": "Réunion technique sur les agents vocaux"
})

Le paramètre temperature

La température contrôle la « créativité » de la transcription. À 0.0, Whisper choisit toujours le token le plus probable. À des valeurs plus élevées, il explore des alternatives :

# Temperature 0.0 — déterministe, recommandé pour la plupart des cas
result = client.audio.transcriptions.create(
    model="whisper-1",
    file=audio_file,
    temperature=0.0
)

# Temperature 0.2 — léger bruit, parfois utile pour l'audio dégradé
result = client.audio.transcriptions.create(
    model="whisper-1",
    file=audio_file,
    temperature=0.2
)

En pratique, temperature=0.0 est le meilleur choix dans la grande majorité des cas. Augmentez uniquement si la transcription contient beaucoup de répétitions ou de boucles (un artefact connu de Whisper).

Pré-traitement audio

La qualité de l’audio d’entrée est le facteur le plus déterminant. Investissez dans le pré-traitement :

from pydub import AudioSegment
from pydub.effects import normalize, compress_dynamic_range

def preprocess_audio(input_path: str, output_path: str) -> str:
    """Pré-traite l'audio pour une transcription optimale."""
    audio = AudioSegment.from_file(input_path)

    # 1. Convertir en mono (la stéréo n'apporte rien pour la voix)
    audio = audio.set_channels(1)

    # 2. Rééchantillonner à 16 kHz (suffisant pour Whisper)
    audio = audio.set_frame_rate(16000)

    # 3. Normaliser le volume
    audio = normalize(audio)

    # 4. Compresser la dynamique (réduit l'écart fort/faible)
    audio = compress_dynamic_range(audio)

    # 5. Exporter en MP3 64 kbps
    audio.export(output_path, format="mp3", bitrate="64k")
    return output_path

Réduction de bruit

Pour les enregistrements bruités, un pré-traitement avec noisereduce améliore considérablement les résultats :

import noisereduce as nr
import soundfile as sf
import numpy as np

def reduce_noise(input_path: str, output_path: str) -> str:
    """Réduit le bruit de fond avant transcription."""
    data, rate = sf.read(input_path)

    # Réduction de bruit adaptative
    reduced = nr.reduce_noise(
        y=data,
        sr=rate,
        prop_decrease=0.8,  # 80% de réduction du bruit
        stationary=False     # Bruit non-stationnaire (ex: café)
    )

    sf.write(output_path, reduced, rate)
    return output_path

Post-traitement de la transcription

Même avec un bon pré-traitement, la transcription brute peut nécessiter des corrections. Utilisez GPT pour le post-traitement :

async def post_process_transcription(raw_text: str, context: str) -> str:
    """Corrige et formate une transcription Whisper."""
    response = client.responses.create(
        model="gpt-4o-mini",
        input=[
            {"role": "system", "content": (
                "Vous êtes un correcteur de transcription. "
                "Corrigez les erreurs évidentes de Whisper sans modifier le sens. "
                "Ajoutez la ponctuation manquante. "
                "Corrigez la casse des noms propres et des acronymes. "
                "Ne résumez pas, ne reformulez pas."
            )},
            {"role": "user", "content": (
                f"Contexte : {context}\n\n"
                f"Transcription brute :\n{raw_text}"
            )}
        ]
    )

    return response.output_text

Pipeline complet de transcription

Assemblez toutes les étapes dans un pipeline robuste :

async def transcribe_high_quality(
    file_path: str,
    language: str = "fr",
    speakers: list[str] = None,
    technical_terms: list[str] = None
) -> dict:
    """Pipeline complet de transcription haute qualité."""
    # 1. Pré-traitement
    processed_path = preprocess_audio(file_path, "/tmp/processed.mp3")

    # 2. Construire le prompt
    prompt_parts = []
    if speakers:
        prompt_parts.extend(speakers)
    if technical_terms:
        prompt_parts.extend(technical_terms)
    prompt = ", ".join(prompt_parts) if prompt_parts else None

    # 3. Transcrire
    with open(processed_path, "rb") as f:
        result = client.audio.transcriptions.create(
            model="whisper-1",
            file=f,
            language=language,
            response_format="verbose_json",
            temperature=0.0,
            prompt=prompt
        )

    # 4. Post-traitement
    context = f"Langue: {language}, Intervenants: {speakers}"
    corrected = await post_process_transcription(result.text, context)

    return {
        "raw_text": result.text,
        "corrected_text": corrected,
        "language": result.language,
        "duration": result.duration,
        "segments": result.segments
    }

Points clés à retenir

Le prompt (max 224 tokens) est le levier le plus efficace : listez noms propres, acronymes et jargon
temperature=0.0 est le choix par défaut pour une transcription déterministe et fiable
Le pré-traitement audio (mono, 16 kHz, normalisation, débruitage) améliore plus que tout paramètre API
Le post-traitement par GPT corrige la ponctuation, la casse et les erreurs résiduelles
Un pipeline complet combine pré-traitement, prompt contextuel et post-traitement pour une qualité maximale