Le dimensioni dei modelli Whisper spiegate: Tiny vs Base vs Small vs Medium vs Large
Tutti i modelli Whisper, a confronto. Parametri, velocità, accuratezza e quale dovresti davvero usare.
OpenWhispr
Ingegneria
Sommario
Whisper di OpenAI è disponibile in 9 varianti di modello suddivise in 5 categorie di dimensione: tiny (39M di parametri), base (74M), small (244M), medium (769M) e large (1.55B). Ogni dimensione ha una versione multilingue e una versione solo inglese (tranne large e turbo, che sono solo multilingue). Esiste anche un modello turbo (809M) — una versione distillata di large-v3 quasi altrettanto accurata ma drasticamente più veloce. I modelli più grandi sono più accurati ma più lenti e richiedono più memoria.
Per il formato quantizzato (GGML) di whisper.cpp usato dalla maggior parte delle app di trascrizione locale, i file dei modelli vanno da 75 MB (tiny) a 2,9 GB (large). L'utilizzo di memoria a runtime varia da circa 273 MB per tiny fino a 3,9 GB per large. Il modello giusto dipende dal tuo hardware, dalla tua lingua e da quanta accuratezza ti serve.
Ultimo aggiornamento: 17 febbraio 2026. Le affermazioni su parametri, memoria e benchmark sono verificate incrociando almeno due fonti primarie.
Riepilogo Fact-Check (doppia fonte)
- Famiglie di modelli ufficiali e numero di parametri: tiny/base/small/medium/large più turbo sono documentati da OpenAI. README di OpenAI Whisper · Model card di Whisper
- Contesto su spazio su disco GGML/GGUF e memoria a runtime: i requisiti di deployment locale provengono dalla documentazione di conversione/runtime di whisper.cpp. whisper.cpp · Note sulla memoria di whisper.cpp
- Avvertenza sui benchmark: il WER varia molto in base al dataset e alla lingua; i dati di LibriSpeech non sono un punteggio di qualità universale. Paper di Whisper · Model card di large-v2
- Posizionamento del modello turbo: turbo è una variante orientata alla velocità con compromessi di accuratezza documentati nelle note di rilascio e nelle model card. Model card di turbo · Discussione sul rilascio di turbo
- Contesto d'uso di OpenWhispr: OpenWhispr espone più dimensioni di Whisper così che gli utenti possano regolare velocità e accuratezza direttamente sul dispositivo. OpenWhispr · Backend whisper.cpp
Whisper Dimensioni del modello: velocità vs precisione
La dimensione della bolla riflette il conteggio dei parametri relativi
Tasso di errore di parole: Whisper rispetto ai concorrenti open source
LibriSpeech test-clean (discorso letto in inglese) — più basso è meglio
Fonti: schede modello Hugging Face, schede modello NVIDIA, Open ASR Leaderboard (Feb 2026). Solo lettura vocale in inglese pulito: la precisione nel mondo reale varia in base alla qualità audio, all'accento e al dominio. API commerciali omessi in quanto non pubblicano benchmark LibriSpeech.
Il confronto completo dei modelli
Questa tabella copre ogni modello Whisper ufficiale. La "Velocità relativa" è riferita a large (baseline 1x). I valori di VRAM sono per l'inferenza PyTorch su GPU. Le colonne GGML mostrano le dimensioni dei file e l'utilizzo di RAM per whisper.cpp, che è ciò che usa la maggior parte delle app desktop.
| Modello | Parametri | Solo inglese | VRAM (GPU) | Disco GGML | RAM (whisper.cpp) | Velocità | WER inglese | WER multilingue |
|---|---|---|---|---|---|---|---|---|
| tiny | 39 M | tiny.en | ~1 GB | 75 MiB | ~273 MB | ~10x | ~7.6% | ~12% |
| base | 74 M | base.en | ~1 GB | 142 MiB | ~388 MB | ~7x | ~5.0% | ~10% |
| small | 244 M | small.en | ~2 GB | 466 MiB | ~852 MB | ~4x | ~3.4% | ~7% |
| medium | 769 M | medium.en | ~5 GB | 1.5 GiB | ~2.1 GB | ~2x | ~2.9% | ~5% |
| large-v2 | 1,550 M | N/D | ~10 GB | 2.9 GiB | ~3.9 GB | 1x | ~2.7% | ~4% |
| large-v3 | 1,550 M | N/D | ~10 GB | 2.9 GiB | ~3.9 GB | 1x | ~2.4% | ~3.5% |
| turbo | 809 M | N/D | ~6 GB | 1.6 GiB | ~2.3 GB | ~8x | ~2.5% | ~3.7% |
Note: I valori di WER (Word Error Rate, tasso di errore sulle parole) sono medie approssimative tratte dal paper di Whisper, dalle model card di HuggingFace (test set LibriSpeech per l'inglese) e dai benchmark pubblicati da OpenAI. Il WER esatto varia in modo significativo in base a dataset, lingua, qualità audio e metodologia di valutazione. Più basso è, meglio è. La velocità è relativa a large (1x = la più lenta).
Tiny (39M di parametri)
Il modello tiny è la variante di Whisper più piccola e veloce. Con appena 39 milioni di parametri e una dimensione del file GGML di 75 MB, può girare senza problemi su quasi qualsiasi hardware — inclusi Raspberry Pi, laptop datati e dispositivi mobili di fascia bassa. Trascrive a circa 10 volte la velocità in tempo reale rispetto al modello large, rendendolo la scelta migliore quando la latenza conta più dell'accuratezza perfetta.
- GGML: 75 MiB su disco
- RAM: ~273 MB a runtime
- VRAM: ~1 GB (modalità GPU)
- ~10x più veloce di large
- Quasi istantaneo su Apple Silicon
- In tempo reale sulla maggior parte delle CPU
- WER inglese: ~7,6%
- WER multilingue: ~12%
- Fatica con accenti/rumore
Sulla variante tiny.en (solo inglese), il WER su LibriSpeech test-clean è intorno al 5,6%, salendo a ~14,9% su test-other (audio rumoroso/con accenti). Il modello tiny multilingue ha prestazioni leggermente peggiori sull'inglese ma supporta tutte e 99 le lingue di Whisper.
Tiny è ideale per appunti veloci, dettatura a basso rischio, prototipi di sottotitolazione in tempo reale e dispositivi embedded o edge dove la potenza di calcolo è limitata. È il modello di partenza predefinito per molti strumenti basati su whisper.cpp perché si scarica in pochi secondi e gira istantaneamente.
Base (74M di parametri)
Il modello base raddoppia il numero di parametri di tiny (74M contro 39M) pur rimanendo molto leggero. Con 142 MiB (GGML) e ~388 MB di RAM a runtime, sta comunque comodamente su praticamente qualsiasi dispositivo moderno. Il miglioramento di accuratezza rispetto a tiny è evidente — soprattutto su audio rumoroso e parlato con accenti.
- GGML: 142 MiB su disco
- RAM: ~388 MB a runtime
- VRAM: ~1 GB (modalità GPU)
- ~7x più veloce di large
- Ancora molto veloce su CPU
- Sotto il secondo su Apple Silicon
- WER inglese: ~5,0%
- WER multilingue: ~10%
- Migliore di tiny su audio rumoroso
La variante base.en raggiunge circa il 4,3% di WER su LibriSpeech test-clean e ~12,8% su test-other. È un miglioramento significativo rispetto a tiny.en (rispettivamente 5,6% e 14,9%), in particolare su audio impegnativo.
Base è un'ottima scelta per dispositivi a basso consumo dove tiny non è abbastanza accurato. È inoltre molto usato per pipeline di trascrizione in tempo reale dove serve un equilibrio tra velocità e qualità senza superare i 500 MB di RAM.
Small (244M di parametri)
Small è il punto in cui Whisper inizia a risultare davvero accurato. Con 244M di parametri, rappresenta un salto di 3,3x rispetto a base e offre un miglioramento di accuratezza significativo — soprattutto per le lingue diverse dall'inglese e le registrazioni rumorose. Il file GGML è di 466 MiB e l'utilizzo di RAM a runtime è di circa 852 MB. Gira a circa 4 volte la velocità di large.
- GGML: 466 MiB su disco
- RAM: ~852 MB a runtime
- VRAM: ~2 GB (modalità GPU)
- ~4x più veloce di large
- Veloce sui laptop moderni
- In tempo reale su Apple Silicon
- WER inglese: ~3,4%
- WER multilingue: ~7%
- Gestisce bene gli accenti
La variante small.en raggiunge circa il 3,0% di WER su LibriSpeech test-clean — un risultato notevole per un modello che sta in meno di 500 MB. Per molti casi d'uso solo inglese, small.en offre un'accuratezza vicina a medium a una frazione del costo in risorse.
Small è spesso consigliato come modello predefinito per la maggior parte degli utenti. Gira bene su qualsiasi laptop moderno (incluso un MacBook Air M1 con 8 GB di RAM), offre una buona accuratezza tra le lingue e trascrive abbastanza velocemente per flussi di dettatura in tempo reale.
Il nostro consiglio: Se non sei sicuro da quale modello iniziare, parti da small. È il miglior equilibrio tra velocità, accuratezza e utilizzo di risorse per la maggior parte degli hardware e dei casi d'uso.
Medium (769M di parametri)
Medium è il punto in cui iniziano a manifestarsi i rendimenti decrescenti — ma i guadagni di accuratezza rispetto a small restano significativi, soprattutto per la trascrizione multilingue, il vocabolario tecnico e le condizioni audio difficili. Con 769M di parametri, richiede 1,5 GiB di spazio su disco (GGML) e circa 2,1 GB di RAM a runtime.
- GGML: 1,5 GiB su disco
- RAM: ~2,1 GB a runtime
- VRAM: ~5 GB (modalità GPU)
- ~2x più veloce di large
- Comodo su macchine da 8 GB+
- Richiede hardware discreto
- WER inglese: ~2,9%
- WER multilingue: ~5%
- Forte sui contenuti tecnici
Il modello medium.en raggiunge circa il 3,0% di WER su LibriSpeech test-clean e circa il 7,5% su test-other. Tuttavia, su benchmark più ampi — in particolare quelli con accenti diversi, rumore di fondo e vocabolario specifico di dominio — medium supera costantemente small.
Medium è un'ottima scelta per flussi di trascrizione professionali in cui l'accuratezza conta ma non hai l'hardware (o la pazienza) per large. Gira bene su macchine con 8 GB o più di RAM e beneficia notevolmente dell'accelerazione GPU.
Large (1.550M di parametri)
Il modello large è la variante di Whisper più accurata, con 1,55 miliardi di parametri. Esistono tre versioni: large-v1 (il rilascio originale), large-v2 (addestrato per 2,5 volte più epoche con regolarizzazione aggiuntiva) e large-v3 (addestrato su più dati con 128 bin di frequenza Mel invece di 80). Large-v3 è la versione attualmente consigliata per la massima accuratezza.
- GGML: 2,9 GiB su disco
- RAM: ~3,9 GB a runtime
- VRAM: ~10 GB (modalità GPU)
- 1x (baseline — la più lenta)
- GPU fortemente consigliata
- CPU: potrebbe essere più lenta del tempo reale
- WER inglese: ~2,4% (v3)
- WER multilingue: ~3,5% (v3)
- Migliore su tutte le lingue
large-v2 vs large-v3
large-v2
- Addestrato per 2,5 volte più epoche rispetto a large-v1
- Regolarizzazione aggiuntiva per una migliore generalizzazione
- WER su LibriSpeech test-clean: ~3,0%
- Più stabile su alcuni tipi di audio
large-v3
- 128 bin Mel (contro 80) — risoluzione di frequenza più fine
- Addestrato su 1M di ore etichettate + 4M di ore con pseudo-etichette
- Riduzione dell'errore del 10-20% rispetto a large-v2 tra le lingue
- Aggiunto il supporto per la lingua cantonese
Quale modello large usare: Per i nuovi progetti, usa large-v3. È in media nettamente migliore di large-v2 tra le lingue. Tuttavia, alcuni utenti hanno segnalato che large-v2 produce meno allucinazioni (generando testo non presente nell'audio) in casi limite specifici con segmenti audio molto silenziosi o privi di parlato. Se riscontri problemi di allucinazioni con large-v3, prova large-v2 come alternativa.
Turbo (809M di parametri)
Il modello turbo è una versione distillata di large-v3 che riduce drasticamente il tempo di inferenza mantenendo gran parte dell'accuratezza. OpenAI ci è riuscita riducendo il decoder da 32 livelli a soli 4 — abbassando il numero di parametri da 1.550M a 809M. L'encoder (che svolge il lavoro più impegnativo) rimane identico a large-v3.
- GGML: ~1,6 GiB su disco
- RAM: ~2,3 GB a runtime
- VRAM: ~6 GB (modalità GPU)
- ~8x più veloce di large
- Accuratezza quasi-large, velocità quasi-tiny
- Ottimo su GPU con torch.compile
- WER inglese: ~2,5%
- WER multilingue: ~3,7%
- Minima perdita di qualità rispetto a large-v3
Turbo è la scelta migliore quando desideri un'accuratezza vicina a quella di large-v3 ma non puoi permetterti la latenza del modello large completo. Su GPU con ottimizzazioni come torch.compile, turbo può ottenere fino a 4,5x di miglioramento di velocità rispetto all'inferenza standard, risultando estremamente veloce.
Limite importante: Il modello turbo non è stato addestrato per i compiti di traduzione. Se hai bisogno di tradurre il parlato da una lingua verso l'inglese, usa medium o large-v3.
Modelli solo inglese vs multilingue
Per le dimensioni tiny, base, small e medium, Whisper offre due varianti: un modello multilingue e un modello solo inglese ( .en ). I modelli large e turbo sono solo multilingue — non esistono versioni solo inglese.
Quando usare .en (solo inglese)
- Trascrivi solo audio in inglese
- Migliore accuratezza in inglese alle dimensioni tiny/base
- Leggermente più veloce — nessun overhead per il rilevamento della lingua
- Stessa dimensione del file dell'equivalente multilingue
Quando usare il multilingue
- Trascrivi audio non in inglese
- Il tuo audio contiene lingue miste
- Hai bisogno della traduzione del parlato (in inglese)
- Obbligatorio se usi large o turbo (non esiste una variante .en)
Il divario di prestazioni tra i modelli .en e multilingue è più marcato alle dimensioni più piccole. Per tiny e base, le varianti .en sono nettamente migliori in inglese. Quando arrivi a small e medium, la differenza si riduce notevolmente. Al livello large esiste solo un modello multilingue — e funziona comunque in modo eccellente in inglese.
Regola pratica: Se usi esclusivamente l'inglese e stai scegliendo tiny o base, opta per la variante .en. Per small o superiori, la versione multilingue funziona benissimo in inglese e ti dà flessibilità per le altre lingue.
Requisiti hardware: cosa gira e dove
L'hardware che ti serve dipende molto dalla dimensione del modello e dal fatto che tu stia usando whisper.cpp (CPU/Metal/CUDA) o l'implementazione PyTorch (orientata alla GPU). Ecco cosa aspettarti sulle classi di hardware più comuni.
MacBook Air M1 (8 GB di RAM)
- tiny/base: Istantaneo. Più veloce del tempo reale.
- small: Veloce. In tempo reale o meglio con Metal.
- medium: Utilizzabile. Potrebbe essere leggermente più lento del tempo reale su CPU. Metal aiuta in modo significativo.
- large: Possibile ma al limite della RAM. Aspettati prestazioni più lente del tempo reale.
- turbo: Buona scelta. Quasi in tempo reale con l'accelerazione Metal.
MacBook Pro M2/M3 (16-36 GB di RAM)
- tiny/base/small: Istantaneo. Tutti ampiamente entro i limiti dell'hardware.
- medium: Veloce. Comodo con Metal.
- large: Buono. In tempo reale o quasi con Metal.
- turbo: Eccellente. Trascrizione veloce in tempo reale.
Laptop Windows/Linux di fascia media (8 GB di RAM, GPU integrata)
- tiny/base: Veloce. Va bene anche solo CPU.
- small: Buono. Comodo sulla maggior parte delle CPU moderne.
- medium: Gestibile. Potrebbe essere 2-3x più lento del tempo reale su CPU.
- large: Impegnativo. Solo CPU sarà lento.
- turbo: Gestibile. Trae beneficio da Vulkan, se disponibile.
Desktop con GPU NVIDIA (RTX 3060+, 8 GB+ di VRAM)
- Tutti i modelli: Veloce. La GPU gestisce tutto comodamente.
- large: Richiede 10 GB di VRAM (RTX 3060 12GB o superiore).
- turbo: L'opzione più veloce con CUDA. Notevolmente più veloce di large.
- Usa il backend CUDA in whisper.cpp per le migliori prestazioni.
Backend di accelerazione di whisper.cpp
whisper.cpp — il port in C/C++ che usa la maggior parte delle app desktop — supporta diversi backend di accelerazione hardware che possono migliorare drasticamente le prestazioni:
Metal (Apple Silicon)
Inferenza completa su GPU su Mac M1/M2/M3/M4. Esegue l'intero modello sulla GPU senza copie di memoria. È il backend più veloce per gli utenti macOS ed è ciò che OpenWhispr usa su Mac.
Core ML (Apple)
Usa il neural engine di Apple per l'inferenza. Può essere più veloce di Metal per alcune dimensioni di modello sui chip più recenti, ed è più efficiente dal punto di vista energetico. Richiede prima la conversione dei modelli nel formato Core ML.
CUDA (NVIDIA)
Accelerazione GPU per le schede NVIDIA. Il backend più veloce per gli utenti con GPU NVIDIA dedicate. Richiede il toolkit CUDA. La scelta migliore per i modelli large e turbo su desktop.
Vulkan (GPU multi-vendor)
Funziona con GPU Intel, AMD e NVIDIA. Buona alternativa per i sistemi non NVIDIA. Disponibile su Linux e Windows. Le prestazioni variano in base al produttore della GPU e al driver.
Velocità di trascrizione approssimativa
Fattore tempo reale (RTF) per un clip audio di 60 secondi. Un RTF < 1,0 significa più veloce del tempo reale. Sono stime approssimative — le prestazioni effettive dipendono dal contenuto dell'audio, dalla quantizzazione del modello e dal carico del sistema.
| Modello | MacBook Air M1 | MacBook M3 Pro | Intel i7 (CPU) | RTX 3060 (CUDA) |
|---|---|---|---|---|
| tiny | ~0.05x | ~0.03x | ~0.1x | ~0.02x |
| base | ~0.08x | ~0.05x | ~0.15x | ~0.04x |
| small | ~0.2x | ~0.12x | ~0.4x | ~0.08x |
| medium | ~0.6x | ~0.3x | ~1.2x | ~0.15x |
| large-v3 | ~1.5x | ~0.7x | ~3.0x | ~0.3x |
| turbo | ~0.3x | ~0.15x | ~0.6x | ~0.08x |
Come leggere la tabella: 0,1x significa che trascrivere 60 secondi di audio richiede circa 6 secondi. 1,0x = tempo reale. Valori superiori a 1,0x indicano più lento del tempo reale. Tutti i dati usano whisper.cpp con le impostazioni predefinite e il backend Metal (Mac) o CUDA (NVIDIA) dove applicabile.
Quale modello dovresti usare?
Ecco alcune raccomandazioni concrete basate su scenari comuni. In caso di dubbio, parti da small e sali o scendi in base alla tua esperienza.
"Voglio la massima velocità possibile"
Usa tiny o tiny.en . Trascrive in millisecondi su hardware moderno. L'accuratezza è grezza ma utilizzabile per appunti veloci e dettatura a basso rischio.
tiny / tiny.en"Voglio una buona accuratezza su un laptop"
Usa small . Il miglior equilibrio tra velocità e accuratezza per i laptop moderni. Se la tua macchina ha 16 GB+ di RAM, medium è anch'esso un'ottima scelta.
small o medium"Voglio la migliore accuratezza"
Usa large-v3 . È il modello Whisper più accurato in assoluto. Se conta anche la velocità, turbo ti dà il 95% dell'accuratezza a 8 volte la velocità.
large-v3 o turbo"Uso solo l'inglese"
Usa la .en variante della dimensione scelta per la migliore accuratezza in inglese. Per tiny e base, i modelli .en sono nettamente migliori. Per small e superiori, la differenza è minima.
small.en o medium.en"Uso più lingue"
Usa la variante multilingue. small o medium per prestazioni bilanciate. large-v3 per la migliore accuratezza multilingue.
small, medium o large-v3"Ho hardware molto limitato"
Usa tiny o base . Entrambi girano con 1 GB di RAM e funzionano persino su Raspberry Pi e altri computer single-board. Base offre un miglioramento di accuratezza significativo rispetto a tiny con un costo aggiuntivo minimo.
tiny o baseCome OpenWhispr gestisce la selezione del modello
OpenWhispr è un'app desktop di dettatura open-source che usa whisper.cpp sotto il cofano. Ti permette di scaricare e passare da un modello Whisper all'altro direttamente dalle impostazioni — senza riga di comando. I modelli vengono scaricati una sola volta e archiviati in locale. Puoi cambiare modello in qualsiasi momento per bilanciare velocità e accuratezza in base al tuo hardware.
Scarica qualsiasi modello
Scegli da tiny fino a large-v3 nelle impostazioni. OpenWhispr scarica automaticamente la versione GGML.
Cambia istantaneamente
Cambia modello in qualsiasi momento. Nessun riavvio necessario. Prova dimensioni diverse per trovare quella che funziona meglio sul tuo hardware.
Ottimizzato per l'hardware
Usa Metal su Apple Silicon, CUDA su NVIDIA e inferenza CPU ottimizzata altrove. Tutto in locale, tutto privato.
Il nostro suggerimento: Parti da small . Se ti sembra lento, scendi a base o tiny. Se vuoi un'accuratezza migliore e il tuo hardware regge, sali a medium o large-v3. OpenWhispr rende facile sperimentare.
Fonti
- Radford et al. "Robust Speech Recognition via Large-Scale Weak Supervision" (2022) — Il paper originale di Whisper con i risultati completi dei benchmark.
- Repository GitHub di OpenAI Whisper — Tabella ufficiale dei modelli, numero di parametri, requisiti di VRAM e dati di velocità relativa.
- Model card di OpenAI Whisper — Composizione ufficiale dei dati di addestramento e avvertenze sulla valutazione.
- Repository GitHub di whisper.cpp — Dimensioni dei modelli GGML, utilizzo di RAM e dettagli sull'accelerazione hardware.
- Model card di Whisper large-v2 (HuggingFace) — Contesto sui benchmark LibriSpeech usati in molti confronti di WER.
- Model card di Whisper large-v3 (HuggingFace) — Dettagli sull'addestramento, modifiche architetturali rispetto a large-v2 e miglioramenti multilingue.
- Model card di Whisper large-v3-turbo (HuggingFace) — Dettagli sull'architettura di turbo, specifiche sul pruning del decoder e compromessi di prestazioni.
- Annuncio di OpenAI Whisper Turbo (GitHub Discussion #2363) — Note ufficiali di rilascio di turbo e confronti di prestazioni tra le lingue.
- OpenWhispr — Contesto pratico di deployment locale per la scelta delle dimensioni dei modelli.
Prova diversi modelli Whisper in OpenWhispr
Dettatura open-source e local-first. Scarica qualsiasi modello Whisper, passa da una dimensione all'altra con un clic e trova l'equilibrio perfetto per il tuo hardware.
Nessun account richiesto · Funziona offline · Open source per sempre