Optimiser la qualité de la transcription
Šiame puslapyje
Mise à jour du 2 novembre 2026 — Modèles audio. Plusieurs modèles de ce cours sont dépréciés :
tts-1,tts-1-hdetgpt-4o-mini-ttscesseront de fonctionner le 6 janvier 2027 (le remplacement indiqué estgpt-realtime-2.1-mini, que le guide TTS d’OpenAI précise comme non pris en charge par/v1/audio/speech: la migration de la synthèse vocale passe vers l’API Realtime) ;gpt-realtime,gpt-4o-realtimeet 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-transcribeet/v1/audio/translationsle 26 février 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pour la voix en full-duplex, GPT-Live 1 est disponible dans l’API depuis le 10 septembre 2026. Leçon mise à jour le 3 novembre 2026 : les exemples passent àgpt-transcribe(prompt,keywords,languages), le modèle recommandé par OpenAI ; la température 0 n’est pas un choix « toujours le plus probable » : selon la référence de l’API, le modèle ajuste alors lui-même la température par paliers. Sources : Transcription de fichier · Créer une transcription.
Optimiser la qualité de la transcription
Whisper produit d’excellentes transcriptions par défaut, mais plusieurs techniques peuvent améliorer significativement la qualité, surtout dans les cas difficiles : bruit de fond, accents régionaux, vocabulaire technique et 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 ton levier principal pour améliorer la qualité. Avec gpt-transcribe, le modèle recommandé par OpenAI, le contexte passe par trois paramètres : prompt (une phrase de contexte dans la langue de l’audio), keywords (termes à reconnaître) et languages (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 Corsen AI sur les agents vocaux.",
keywords=["GPT-6.1 Sol", "Responses API", "Realtime API", "Corsen AI", "Mordehai Attia"],
)
Bonnes pratiques pour le prompt
- Liste les noms propres : personnes, entreprises, produits
- Inclus le jargon technique : acronymes, termes spécifiques au domaine
- Précise le style attendu : ponctuation, casse
- Avec
whisper-1, tout passe par le seulprompt, limité à 224 tokens : le guide précise que Whisper ne suit pas les instructions comme un modèle de texte, d’où l’intérêt d’y lister simplement les orthographes correctes - Avec
gpt-transcribe, place les termes danskeywords, un par entrée, sans<,>ni sauts de 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
Le point de terminaison accepte une temperature entre 0 et 1, avec 0 par défaut. Contrairement à une idée reçue, la valeur 0 ne signifie pas « toujours le mot le plus probable » : selon la référence de l’API, le modèle s’appuie alors sur ses probabilités de tokens pour élever lui-même la température par paliers, jusqu’à certains seuils.
En pratique, laisse 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 élevée (0,2 par exemple) peut être testée 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écisif. Investis 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 du bruit
Pour les enregistrements bruyants, un prétraitement avec noisereduce améliore significativement 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 la transcription."""
data, rate = sf.read(input_path)
# Réduction adaptative du bruit
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. Utilise 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": (
"Tu es un correcteur de transcription. "
"Corrige les erreurs évidentes de Whisper sans changer le sens. "
"Ajoute la ponctuation manquante. "
"Corrige la casse des noms propres et des acronymes. "
"Ne résume pas et ne reformule pas."
)},
{"role": "user", "content": (
f"Contexte : {context}\n\n"
f"Transcription brute :\n{raw_text}"
)}
]
)
return response.output_text
Pipeline de transcription complet
Assemble 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 de transcription complet de haute qualité."""
# 1. Prétraitement
processed_path = preprocess_audio(file_path, "/tmp/processed.mp3")
# 2. Construire le contexte : uniquement les paramètres remplis
options = {}
terms = (speakers or []) + (technical_terms or [])
if terms:
options["keywords"] = terms
# 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,
}
Svarbiausi punktai
- Le contexte est le levier le plus efficace :
prompt,keywordsetlanguagesavecgpt-transcribe; le seulprompt, limité à 224 tokens, avecwhisper-1 temperaturevaut 0 par défaut, et à 0 le modèle ajuste lui-même la température si besoin : laisse la valeur par défaut- Le prétraitement audio (mono, 16 kHz, normalisation, débruitage) améliore la qualité plus que n’importe quel paramètre d’API
- Le post-traitement par GPT corrige la ponctuation, la casse et les erreurs résiduelles
- Un pipeline complet combine prétraitement, prompting contextuel et post-traitement pour une qualité maximale