Ottimizzare la qualità della trascrizione
In questa pagina
Aggiornamento 2 novembre 2026 — Modelli audio. Diversi modelli in questo corso sono deprecati:
tts-1,tts-1-hdegpt-4o-mini-ttssmetteranno di funzionare il 6 gennaio 2027 (il sostituto indicato ègpt-realtime-2.1-mini, che la guida OpenAI TTS definisce non supportato da/v1/audio/speech: la migrazione della sintesi vocale passa alle Realtime API);gpt-realtime,gpt-4o-realtimee i modelli audio legacy il 20 gennaio 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribee/v1/audio/translationsil 26 febbraio 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Per il voice full-duplex, GPT-Live 1 è disponibile nelle API dal 10 settembre 2026. Lezione aggiornata il 3 novembre 2026: esempi passati agpt-transcribe(prompt,keywords,languages), il modello raccomandato da OpenAI; la temperatura 0 non è una scelta “sempre la più probabile”: secondo il riferimento API, il modello regola allora autonomamente la temperatura a gradini. Fonti: Trascrizione file · Crea trascrizione.
Ottimizzare la qualità della trascrizione
Whisper produce trascrizioni eccellenti di default, ma diverse tecniche possono migliorare significativamente la qualità, specialmente nei casi difficili: rumore di fondo, accenti regionali, vocabolario tecnico e nomi propri. Questa lezione copre parametri avanzati e strategie di post-elaborazione.
Il parametro prompt
Il contesto è la tua leva principale per migliorare la qualità. Con gpt-transcribe, il modello raccomandato da OpenAI, il contesto passa attraverso tre parametri: prompt (una frase di contesto nella lingua dell’audio), keywords (termini da riconoscere) e languages (lingue attese).
# Senza contesto, i nomi dei prodotti rischiano di essere trascritti male
result = client.audio.transcriptions.create(
model="gpt-transcribe",
file=audio_file,
languages=["fr"],
)
# Con contesto e parole chiave
result = client.audio.transcriptions.create(
model="gpt-transcribe",
file=audio_file,
languages=["fr"],
prompt="Riunione tecnica Corsen AI sugli agenti vocali.",
keywords=["GPT-6.1 Sol", "Responses API", "Realtime API", "Corsen AI", "Mordehai Attia"],
)
Best practice per il prompt
- Elenca i nomi propri: persone, aziende, prodotti
- Includi il gergo tecnico: acronimi, termini specifici del dominio
- Specifica lo stile atteso: punteggiatura, maiuscole/minuscole
- Con
whisper-1, tutto passa attraverso l’unicoprompt, limitato a 224 token: la guida specifica che Whisper non segue istruzioni come un modello testuale, da qui il beneficio di elencare semplicemente le grafie corrette - Con
gpt-transcribe, inserisci i termini inkeywords, uno per voce, senza<,>o interruzioni di riga, altrimenti l’API rifiuta la richiesta
def build_transcription_prompt(context: dict) -> str:
"""Costruisce un prompt di contesto per la trascrizione."""
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": "Riunione tecnica sugli agenti vocali"
})
Il parametro temperature
L’endpoint accetta un valore temperature tra 0 e 1, con default a 0. Contrariamente a un errore comune, il valore 0 non significa “sempre la parola più probabile”: secondo il riferimento API, il modello si basa allora sulle sue probabilità di token per alzare autonomamente la temperatura a gradini, fino a certe soglie.
In pratica, lascia il valore di default. La documentazione di gpt-transcribe enfatizza il contesto (prompt, keywords, languages), non la temperatura; su whisper-1, una temperatura leggermente più alta (0.2, ad esempio) può essere testata su audio degradato caso per caso.
Pre-elaborazione dell’audio
La qualità dell’audio in ingresso è il fattore più decisivo. Investi nella pre-elaborazione:
from pydub import AudioSegment
from pydub.effects import normalize, compress_dynamic_range
def preprocess_audio(input_path: str, output_path: str) -> str:
"""Pre-elabora l'audio per una trascrizione ottimale."""
audio = AudioSegment.from_file(input_path)
# 1. Converti in mono (lo stereo non aggiunge nulla per la voce)
audio = audio.set_channels(1)
# 2. Ricampiona a 16 kHz (sufficiente per Whisper)
audio = audio.set_frame_rate(16000)
# 3. Normalizza il volume
audio = normalize(audio)
# 4. Comprimi il dynamic range (riduce il gap forte/piano)
audio = compress_dynamic_range(audio)
# 5. Esporta come MP3 a 64 kbps
audio.export(output_path, format="mp3", bitrate="64k")
return output_path
Riduzione del rumore
Per registrazioni rumorose, la pre-elaborazione con noisereduce migliora significativamente i risultati:
import noisereduce as nr
import soundfile as sf
import numpy as np
def reduce_noise(input_path: str, output_path: str) -> str:
"""Riduce il rumore di fondo prima della trascrizione."""
data, rate = sf.read(input_path)
# Riduzione adattiva del rumore
reduced = nr.reduce_noise(
y=data,
sr=rate,
prop_decrease=0.8, # 80% di riduzione del rumore
stationary=False # Rumore non stazionario (es. caffè)
)
sf.write(output_path, reduced, rate)
return output_path
Post-elaborazione della trascrizione
Anche con una buona pre-elaborazione, la trascrizione grezza può richiedere correzioni. Usa GPT per la post-elaborazione:
async def post_process_transcription(raw_text: str, context: str) -> str:
"""Corregge e formatta una trascrizione di Whisper."""
response = client.responses.create(
model="gpt-5.6-luna",
input=[
{"role": "system", "content": (
"Sei un correttore di trascrizioni. "
"Correggi gli errori evidenti di Whisper senza cambiarne il significato. "
"Aggiungi la punteggiatura mancante. "
"Correggi maiuscole/minuscole per nomi propri e acronimi. "
"Non riassumere né riformulare."
)},
{"role": "user", "content": (
f"Contesto: {context}\n\n"
f"Trascrizione grezza:\n{raw_text}"
)}
]
)
return response.output_text
Pipeline di trascrizione completa
Assembla tutti i passaggi in una pipeline robusta:
async def transcribe_high_quality(
file_path: str,
language: str = "fr",
speakers: list[str] = None,
technical_terms: list[str] = None
) -> dict:
"""Pipeline completa di trascrizione ad alta qualità."""
# 1. Pre-elaborazione
processed_path = preprocess_audio(file_path, "/tmp/processed.mp3")
# 2. Costruisci il contesto: solo parametri popolati
options = {}
terms = (speakers or []) + (technical_terms or [])
if terms:
options["keywords"] = terms
# 3. Trascrivi
with open(processed_path, "rb") as f:
result = client.audio.transcriptions.create(
model="gpt-transcribe",
file=f,
languages=[language],
**options,
)
# 4. Post-elaborazione
context = f"Lingua: {language}, Relatori: {speakers}"
corrected = await post_process_transcription(result.text, context)
return {
"raw_text": result.text,
"corrected_text": corrected,
"languages": result.languages,
}
Punti chiave
- Il contesto è la leva più efficace:
prompt,keywordselanguagescongpt-transcribe; l’unicoprompt, limitato a 224 token, conwhisper-1 temperatureha default 0, e a 0 il modello regola autonomamente la temperatura se necessario: lascia il valore di default- La pre-elaborazione audio (mono, 16 kHz, normalizzazione, denoising) migliora la qualità più di qualsiasi parametro API
- La post-elaborazione con GPT corregge punteggiatura, maiuscole/minuscole ed errori residui
- Una pipeline completa combina pre-elaborazione, prompting contestuale e post-elaborazione per la massima qualità