Optimiser la qualité de transcription

Mise à jour du 2 novembre 2026 — modèles audio. Plusieurs modèles de ce cours sont dépréciés : tts-1, tts-1-hd et gpt-4o-mini-tts s’arrêtent le 6 janvier 2027 (remplaçant indiqué : gpt-realtime-2.1-mini, que le guide TTS d’OpenAI déclare non pris en charge par /v1/audio/speech : la migration de la synthèse vocale passe par l’API Realtime) ; gpt-realtime, gpt-4o-realtime et les anciens modèles audio le 20 janvier 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5) ; whisper-1, gpt-4o-transcribe et /v1/audio/translations le 26 février 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pour la voix full-duplex, GPT-Live 1 est disponible dans l’API depuis le 10 septembre 2026. Leçon corrigée le 3 novembre 2026 : exemples passés à gpt-transcribe (prompt, keywords, languages), modèle recommandé par OpenAI ; la température à 0 n’est pas un choix « toujours le plus probable » : d’après la référence de l’API, le modèle relève alors lui-même la température par paliers. Sources : File transcription · Create 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 contexte est votre levier principal pour améliorer la qualité. Avec gpt-transcribe, le modèle que recommande OpenAI, il passe par trois paramètres : prompt (une phrase de contexte, dans la langue de l’audio), keywords (les termes à reconnaître) et languages (les langues attendues).

# Sans contexte, les noms de produits risquent d'être mal transcrits
result = client.audio.transcriptions.create(
    model="gpt-transcribe",
    file=audio_file,
    languages=["fr"],
)

# Avec contexte et mots-clés
result = client.audio.transcriptions.create(
    model="gpt-transcribe",
    file=audio_file,
    languages=["fr"],
    prompt="Réunion technique de Corsen AI sur les agents vocaux.",
    keywords=["GPT-6.1 Sol", "Responses API", "Realtime API", "Corsen AI", "Mordehai Attia"],
)

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
Avec whisper-1, tout passe par le seul prompt, limité à 224 tokens : le guide précise que Whisper ne suit pas des consignes comme un modèle de texte, d’où l’intérêt d’y lister simplement les orthographes correctes
Avec gpt-transcribe, mettez les termes dans keywords, un par entrée, sans <, > ni retour à la ligne, sinon l’API rejette la requête

def build_transcription_prompt(context: dict) -> str:
    """Construit un prompt de contexte pour la transcription."""
    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

L’endpoint accepte une temperature entre 0 et 1, à 0 par défaut. Contrairement à une idée répandue, la valeur 0 ne signifie pas « toujours le mot le plus probable » : d’après la référence de l’API, le modèle s’appuie alors sur les probabilités de ses tokens pour relever lui-même la température par paliers, jusqu’à certains seuils.

En pratique, laissez la valeur par défaut. La documentation de gpt-transcribe met l’accent sur le contexte (prompt, keywords, languages), pas sur la température ; sur whisper-1, une température légèrement plus haute (0,2 par exemple) peut se tester sur un audio dégradé, au cas par cas.

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-5.6-luna",
        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 contexte : seulement les paramètres renseignés
    options = {}
    termes = (speakers or []) + (technical_terms or [])
    if termes:
        options["keywords"] = termes

    # 3. Transcrire
    with open(processed_path, "rb") as f:
        result = client.audio.transcriptions.create(
            model="gpt-transcribe",
            file=f,
            languages=[language],
            **options,
        )

    # 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,
        "languages": result.languages,
    }

Points clés à retenir

Le contexte est le levier le plus efficace : prompt, keywords et languages avec gpt-transcribe ; le seul prompt, limité à 224 tokens, avec whisper-1
temperature vaut 0 par défaut, et à 0 le modèle relève lui-même la température si besoin : laissez la valeur par défaut
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