Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Ottimizzare la qualità della trascrizione

Lezione 9 di 18 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Ottimizzare la qualità della trascrizione
  2. Il parametro prompt
  3. Il parametro temperature
  4. Pre-elaborazione dell’audio
  5. Post-elaborazione della trascrizione
  6. Pipeline di trascrizione completa
  7. Punti chiave

Aggiornamento 2 novembre 2026 — Modelli audio. Diversi modelli in questo corso sono deprecati: tts-1, tts-1-hd e gpt-4o-mini-tts smetteranno 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-realtime e 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-transcribe e /v1/audio/translations il 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 a gpt-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’unico prompt, 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 in keywords, 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, keywords e languages con gpt-transcribe; l’unico prompt, limitato a 224 token, con whisper-1
  • temperature ha 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à