12 novembre 2026 · Team VRAMfarm

Trascrizione con Whisper su GPU: large-v3 o turbo, faster-whisper e speaker con WhisperX

Cento ore di interviste registrate sembrano settimane di battitura. Su una RTX 4090 a noleggio, Whisper large-v3 le trascrive in circa una o due ore di tempo GPU, più o meno 0,89 €, con i timestamp di ogni frase. Il modello chiede solo 3–10 GB di memoria, quindi la domanda non è tanto “quale scheda basta” quanto quale versione di Whisper usare e come tenere occupata la GPU.

Quale Whisper: large-v3, turbo o più piccolo

Whisper di OpenAI esiste in diverse taglie. Per il lavoro su GPU ne contano due, che condividono lo stesso encoder ma hanno un decoder diverso.

Turbo è large-v3 con un decoder molto più piccolo (4 layer invece di 32). Sul parlato chiaro la sua precisione è vicina a quella di large-v3 e gira parecchie volte più veloce. Sbaglia di più con accenti, voci sovrapposte e lingue rare, e non è stato addestrato per la traduzione. Una buona scelta di partenza: turbo per registrazioni pulite come podcast e lezioni, large-v3 per telefonate, stanze rumorose, accenti marcati o qualsiasi cosa che citerai.

faster-whisper è una reimplementazione di Whisper sul motore CTranslate2. Stessi modelli e praticamente la stessa precisione, fino a circa quattro volte più veloce del codice di OpenAI con meno memoria, e può quantizzare in int8 con poca perdita. WhisperX si appoggia a faster-whisper e aggiunge due cose: timestamp a livello di parola grazie a un modello di allineamento separato, ed etichette degli speaker (diarizzazione).

Ti serve davvero una GPU?

Per qualche registrazione al mese, no. Un portatile con Apple Silicon o una CPU recente fa girare turbo con whisper.cpp a un ritmo comodo, e le API di trascrizione ospitate fanno pagare al minuto senza nessuna configurazione. Le API ospitate di classe Whisper costano da pochi centesimi a circa 0,30 € per ora di audio (novembre 2026), a seconda del fornitore e del modello.

Una GPU a noleggio conviene quando:

• hai volume: decine o centinaia di ore, dove il prezzo orario dell’API si accumula e la GPU lavora ogni minuto;
• le registrazioni sono sensibili: interviste, pazienti, chiamate interne che non vuoi mandare all’API di terzi;
• ti servono le etichette degli speaker o una pipeline tua, per esempio trascrivere, etichettare gli speaker e poi riassumere con un LLM locale;
• i file sono grandi: molte API limitano la dimensione del singolo upload; al tuo server non importa.

Velocità: ore di audio per ora di GPU

La velocità di Whisper di solito si indica come multiplo del tempo reale: 50× vuol dire un’ora di audio in 72 secondi. La leva più grande non è la scheda ma il batching: la pipeline batched di faster-whisper manda nel modello molti spezzoni da 30 secondi insieme, e così tiene occupata una GPU moderna.

Leggi ogni numero come “ore di audio per ora di GPU”. Sono intervalli per pianificare, ricavati da benchmark pubblici e dalle specifiche delle schede, non misure nostre. La velocità reale dipende da quanta parte dell’audio è parlato, dal beam size, dalle impostazioni VAD e dalla CPU, che decodifica i file audio e ai livelli più alti può diventare il collo di bottiglia. La diarizzazione in WhisperX aggiunge un passaggio separato; per i file lunghi conta il 30–60% di tempo in più.

La scheda più economica per ora di audio di solito è la RTX 3090 o la RTX 4090, quella che in quel momento ha il rapporto di prezzo migliore; la pagina dei prezzi le mostra entrambe. Le schede da data center come la H100 sono ancora più veloci, ma la trascrizione non usa la loro memoria e all’ora costano parecchie volte di più.

Configurare faster-whisper su un server a noleggio

Non c’è un’app pronta per Whisper; ti basta un server vuoto PyTorch + Jupyter. Scegli una scheda da 12–24 GB, avvia e apri Jupyter → File → New → Terminal (oppure SSH, vedi la guida alla chiave SSH).

Prima carica l’audio. Convertirlo sul tuo computer in mono a 16 kHz fa risparmiare molto tempo di upload senza peggiorare la precisione, perché Whisper ricampiona comunque a 16 kHz: un’ora di MP3 a 128 kbps sono circa 58 MB, un’ora di Opus mono a 16 kHz circa 11 MB.

# sul tuo computer, una volta per file
ffmpeg -i interview.mp4 -vn -ac 1 -ar 16000 -c:a libopus -b:a 24k interview.opus

Carica uno zip da Jupyter o con scp, oppure scaricalo sul server dal tuo cloud storage. Poi sul server:

pip install faster-whisper
mkdir -p /workspace/audio /workspace/out   # metti i file audio in /workspace/audio

Salva questo come /workspace/transcribe.py:

import glob, os
from faster_whisper import WhisperModel, BatchedInferencePipeline

model = WhisperModel("large-v3", device="cuda", compute_type="float16")  # oppure "large-v3-turbo"
batched = BatchedInferencePipeline(model=model)

def ts(t):
    h, rem = divmod(t, 3600); m, s = divmod(rem, 60)
    return f"{int(h):02}:{int(m):02}:{s:06.3f}".replace(".", ",")

for path in sorted(glob.glob("/workspace/audio/*")):
    name = os.path.splitext(os.path.basename(path))[0]
    segments, info = batched.transcribe(path, batch_size=16, vad_filter=True)  # aggiungi language="it" se conosci la lingua
    with open(f"/workspace/out/{name}.srt", "w") as srt, open(f"/workspace/out/{name}.txt", "w") as txt:
        for i, seg in enumerate(segments, 1):
            srt.write(f"{i}\n{ts(seg.start)} --> {ts(seg.end)}\n{seg.text.strip()}\n\n")
            txt.write(seg.text.strip() + "\n")
    print(name, info.language, round(info.duration / 60), "min")

Lancialo con nohup python /workspace/transcribe.py > /workspace/log.txt 2>&1 & così continua anche quando chiudi il browser. Al primo avvio scarica il modello (circa 3 GB per large-v3), che conta come traffico alla tariffa della macchina.

Se faster-whisper si lamenta di non riuscire a caricare libcudnn o libcublas, le librerie CUDA che si aspetta non sono nel percorso: pip install nvidia-cublas-cu12 nvidia-cudnn-cu12 e segui la riga LD_LIBRARY_PATH nel README di faster-whisper. Driver e versione CUDA della macchina sono indicati prima dell’avvio; trovi di più in driver e CUDA non compatibili.

Impostare language quando la conosci fa risparmiare tempo ed evita qualche errore di riconoscimento quando i primi 30 secondi sono silenziosi. Con batch_size=16, large-v3 usa circa 6–10 GB di VRAM; su una scheda da 12 GB scendi a 8 se finisci la memoria.

Etichette degli speaker con WhisperX

Per interviste e riunioni di solito vuoi “Speaker 1 / Speaker 2”, non un unico blocco di testo. WhisperX lo fa con un solo comando. Fissa le sue versioni di PyTorch e di altre librerie, quindi installalo in un ambiente virtuale separato per non rompere altri strumenti (scarica il suo PyTorch, qualche GB di traffico in più):

apt-get update && apt-get install -y ffmpeg
python -m venv /workspace/wx && . /workspace/wx/bin/activate
pip install whisperx
export HF_TOKEN=<your Hugging Face read token>
whisperx /workspace/audio/meeting.opus --model large-v3 --language en \
  --diarize --hf_token $HF_TOKEN --output_format srt --output_dir /workspace/out

I modelli di diarizzazione vengono da pyannote e su Hugging Face sono ad accesso riservato: apri le loro pagine, accetta i termini e usa un token di lettura. Aggiungi --min_speakers 2 --max_speakers 4 quando sai quanti sono; la divisione migliora parecchio. Metti in conto qualche gigabyte di VRAM in più rispetto alla sola trascrizione; una scheda da 24 GB ha spazio in abbondanza.

La diarizzazione è l’anello più debole della catena. Parlato sovrapposto, voci simili e interiezioni brevi (“sì”, “giusto”) ricevono l’etichetta sbagliata più spesso di quanto Whisper sbagli le parole. Controlla gli speaker nei primi minuti prima di fidarti di una trascrizione lunga.

Sottotitoli: SRT e VTT

Lo script qui sopra scrive file SRT con un segmento di Whisper per sottotitolo. I segmenti possono essere lunghi, fino a 30 secondi di parlato, e sullo schermo si leggono male. WhisperX se la cava meglio, perché allinea ogni parola all’audio:

whisperx video.opus --model large-v3 --language en --output_format srt \
  --max_line_width 42 --max_line_count 2 --output_dir /workspace/out

Così ottieni sottotitoli di al massimo due righe da 42 caratteri, uno stile televisivo diffuso, con tempi che seguono le parole. Usa --output_format vtt per i player web. YouTube, Premiere, DaVinci Resolve e la maggior parte dei player importano direttamente gli SRT. Per sottotitoli tradotti, usa la modalità translate di Whisper verso l’inglese, oppure trascrivi nella lingua originale e traduci il testo dell’SRT con un LLM locale, che di solito suona più naturale.

Quanto costano 100 ore di audio

A metà degli intervalli indicati sopra, con faster-whisper batched:

Aggiungi 10–15 minuti per configurazione e download dei modelli. I lavori piccoli pagano il minimo di 15 minuti per avvio: un’ora di audio costa almeno 0,15 € su una RTX 4090, per quanto veloce sia. Quindi raccogli le registrazioni e trascrivile in un’unica sessione invece di un file per avvio.

Con un’API a circa 0,15–0,30 € per ora di audio (novembre 2026), le stesse 100 ore costerebbero circa 15–30 €, e con i fornitori di inferenza veloce più economici qualche euro. A volumi alti la GPU costa meno, ma la configurazione e il tempo sono tuoi; per cinque ore di audio al mese, l’API è la scelta sensata.

Quando lo script ha finito, comprimi /workspace/out, scaricalo da Jupyter e ferma il server. Se rifarai lo stesso lavoro la settimana prossima, Salva e ferma conserva gli script e l’ambiente WhisperX in /workspace (il solo ambiente occupa qualche GB di storage); prima cancella l’audio, se non deve restare archiviato. La pagina di Whisper ha la versione breve di questi comandi.