Trascrivere e sottotitolare gratis con Whisper in locale

Trascrivere un'intervista, sottotitolare un video, ottenere il testo di un podcast: sono compiti che oggi puoi svolgere gratis, in locale e senza inviare i tuoi file a nessun servizio online, grazie a Whisper, il modello di riconoscimento vocale reso open source da OpenAI. In questa guida vediamo come installarlo e usarlo davvero sul tuo computer, con i comandi reali, incluse le varianti piu' veloci come faster-whisper. Al termine avrai un flusso di lavoro completo per trasformare audio e video in testo e sottotitoli.

A chi serve e cosa otterrai

Questa guida e' per chiunque debba trascrivere audio con regolarita' - giornalisti, studenti, creatori di contenuti, ricercatori - e voglia farlo senza costi ricorrenti e mantenendo il controllo sui propri file. Otterrai: la trascrizione testuale di qualsiasi file audio o video, con timestamp, e la possibilita' di esportare sottotitoli nei formati SRT e VTT pronti da caricare su YouTube o in un editor video. Tutto gira sul tuo computer, offline dopo il download iniziale del modello.

Prerequisiti: un computer con Windows, macOS o Linux; Python 3.9 o superiore; qualche gigabyte di spazio libero. Una scheda grafica (GPU) NVIDIA velocizza molto il lavoro ma non e' obbligatoria: Whisper funziona anche solo con la CPU, seppur piu' lentamente.

Quale strumento scegliere: Whisper, faster-whisper o whisper.cpp

Esistono tre principali implementazioni, con pro e contro diversi:

Strumento	Pro	Contro
Whisper ufficiale (openai-whisper)	Semplice, riferimento originale	Piu' lento e piu' esigente di memoria
faster-whisper	Molto piu' veloce, meno memoria, stessa qualita'	Installazione leggermente piu' tecnica
whisper.cpp	Leggerissimo, ottimo su Mac e CPU	Serve compilare, uso da riga di comando

Prima scelta consigliata: faster-whisper. Offre la stessa accuratezza del modello originale ma e' sensibilmente piu' rapido e leggero, il che fa la differenza su file lunghi. Se hai un Mac con chip Apple o vuoi il minimo ingombro, valuta whisper.cpp.

Passo 1: installare faster-whisper e ffmpeg

Whisper ha bisogno di ffmpeg per leggere audio e video. Installalo prima. Su macOS con Homebrew:

brew install ffmpeg

Su Linux (Debian/Ubuntu):

sudo apt update && sudo apt install ffmpeg

Su Windows, scarica ffmpeg dal sito ufficiale e aggiungilo al PATH, oppure installalo con un gestore come winget. Poi installa faster-whisper (conviene farlo in un ambiente virtuale):

python -m venv venv
source venv/bin/activate    # su Windows: venv\Scripts\activate
pip install faster-whisper

Passo 2: la prima trascrizione

Crea un file trascrivi.py. Questo script trascrive un audio in italiano e stampa il testo con i tempi:

from faster_whisper import WhisperModel

# "small" e' un buon compromesso; usa "medium" o "large-v3" per piu' accuratezza
model = WhisperModel("small", device="cpu", compute_type="int8")

segments, info = model.transcribe("intervista.mp3", language="it")

print("Lingua rilevata:", info.language)
for seg in segments:
    print(f"[{seg.start:.1f}s -> {seg.end:.1f}s] {seg.text}")

Eseguilo con python trascrivi.py. Il risultato atteso e' l'elenco dei segmenti trascritti, ciascuno con l'istante di inizio e fine. Se hai una GPU NVIDIA, cambia device="cpu" in device="cuda" e compute_type="int8" in compute_type="float16" per un'accelerazione notevole.

Passo 3: generare i sottotitoli in formato SRT

Per creare un file di sottotitoli pronto per YouTube o per un editor video, converti i segmenti nel formato SRT. Aggiungi allo script:

def s_to_srt(t):
    h = int(t // 3600); m = int((t % 3600) // 60)
    s = int(t % 60); ms = int((t - int(t)) * 1000)
    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"

segments, info = model.transcribe("video.mp4", language="it")
with open("sottotitoli.srt", "w", encoding="utf-8") as f:
    for i, seg in enumerate(segments, start=1):
        f.write(f"{i}\n")
        f.write(f"{s_to_srt(seg.start)} --> {s_to_srt(seg.end)}\n")
        f.write(seg.text.strip() + "\n\n")
print("File sottotitoli.srt creato.")

Nota che puoi passare direttamente un file video (video.mp4): ffmpeg ne estrae l'audio automaticamente. Il risultato e' un file sottotitoli.srt che puoi caricare su YouTube o importare in un montaggio.

Passo 4: scegliere il modello giusto

Whisper offre modelli di dimensioni crescenti: tiny, base, small, medium, large-v3. Piu' grande e' il modello, migliore e' l'accuratezza (soprattutto su italiano, accenti e audio rumoroso), ma servono piu' memoria e piu' tempo. Regola pratica: parti da small; se le trascrizioni contengono troppi errori passa a medium; usa large-v3 solo se hai una buona GPU e ti serve la massima qualita'. Il modello viene scaricato automaticamente la prima volta e poi riutilizzato offline.

Migliorare l'accuratezza: silenzi, contesto e vocabolario

Le trascrizioni non sono mai perfette, ma alcuni accorgimenti fanno la differenza. Primo, il rilevamento del parlato (VAD): filtra i silenzi ed evita che il modello "inventi" testo durante le pause, un problema noto di Whisper. Con faster-whisper si attiva facilmente:

segments, info = model.transcribe(
    "intervista.mp3",
    language="it",
    vad_filter=True,          # salta i silenzi
    beam_size=5,              # ricerca piu' accurata
    initial_prompt="Intervista su intelligenza artificiale e startup italiane.",
)

Il parametro initial_prompt e' prezioso: gli suggerisci il contesto e i termini attesi (nomi propri, sigle, gergo tecnico), cosi' Whisper li trascrive correttamente invece di storpiarli. Se nell'audio ricorrono parole particolari - un nome aziendale, un termine specialistico - inserirle nel prompt iniziale aumenta molto la precisione.

Trascrivere piu' file in blocco

Se hai una cartella di registrazioni, puoi automatizzare il lavoro con un ciclo che processa tutti i file e salva una trascrizione per ciascuno:

import os
from faster_whisper import WhisperModel

model = WhisperModel("small", device="cpu", compute_type="int8")
cartella = "./registrazioni"

for nome in os.listdir(cartella):
    if nome.lower().endswith((".mp3", ".wav", ".m4a", ".mp4")):
        percorso = os.path.join(cartella, nome)
        segments, info = model.transcribe(percorso, language="it", vad_filter=True)
        testo = " ".join(seg.text.strip() for seg in segments)
        with open(percorso + ".txt", "w", encoding="utf-8") as f:
            f.write(testo)
        print("Trascritto:", nome)

Il modello viene caricato una sola volta e riutilizzato per tutti i file, il che rende il processo molto piu' rapido rispetto a lanciare uno script separato per ciascuno.

Errori comuni e soluzioni

• "ffmpeg not found": ffmpeg non e' installato o non e' nel PATH. Ripeti il passo 1 e riavvia il terminale.
• Trascrizione in inglese di un audio italiano: hai dimenticato language="it". Specificalo sempre se conosci la lingua, per risultati migliori e piu' veloci.
• "out of memory" con la GPU: il modello e' troppo grande per la tua scheda. Scendi di dimensione (da large a medium) o passa a compute_type="int8".
• Lentezza estrema su CPU: e' normale con i modelli grandi. Usa small o base, oppure valuta whisper.cpp che e' molto efficiente su CPU.

Alternativa leggera: whisper.cpp su Mac e CPU

Se hai un Mac con chip Apple o un computer senza GPU, whisper.cpp e' spesso la scelta piu' efficiente: e' scritto in C++, non richiede Python e sfrutta bene l'hardware. Ecco il percorso essenziale. Prima si clona e si compila il progetto:

git clone https://github.com/ggml-org/whisper.cpp
cd whisper.cpp
cmake -B build
cmake --build build --config Release

Poi si scarica un modello gia' convertito nel formato ggml (per esempio il modello "small"):

sh ./models/download-ggml-model.sh small

Infine si trascrive un file audio, chiedendo direttamente l'uscita in formato sottotitoli SRT e specificando l'italiano:

./build/bin/whisper-cli -m models/ggml-small.bin -f audio.wav -l it -osrt

Il comando produce un file audio.wav.srt pronto all'uso. Un dettaglio importante: whisper.cpp lavora con file WAV a 16 kHz; se il tuo audio e' in un altro formato, convertilo prima con ffmpeg (ffmpeg -i input.mp3 -ar 16000 -ac 1 audio.wav). Rispetto a faster-whisper rinunci alla comodita' di Python, ma guadagni leggerezza e velocita' su macchine modeste.

Varianti, casi avanzati e come proseguire

Da qui puoi spingerti oltre. Per il Mac, whisper.cpp offre prestazioni eccellenti sfruttando i chip Apple: si compila una volta e si usa da riga di comando con un comando del tipo ./main -m models/ggml-small.bin -f audio.wav -l it -osrt, che produce direttamente il file SRT. Per file molto lunghi, conviene spezzarli o usare la modalita' che riduce le allucinazioni (ripetizioni di frasi) tipiche dell'audio con lunghi silenzi. Se lavori con molte lingue, Whisper le riconosce automaticamente omettendo il parametro language. E se ti serve identificare "chi dice cosa" (diarizzazione), esistono strumenti complementari come pyannote da abbinare a Whisper.

Il vantaggio di questo approccio locale, rispetto ai servizi di trascrizione a pagamento o alle API cloud, e' triplice: e' gratuito dopo l'installazione, mantiene i file sul tuo computer (fondamentale per contenuti riservati), e non ha limiti di durata. Il prezzo da pagare e' un po' di configurazione iniziale e, senza GPU, tempi piu' lunghi. Ma una volta impostato, avrai uno strumento professionale per trascrizioni e sottotitoli sempre a portata di mano, senza abbonamenti.