L'auto-hosting di Whisper consente di mantenere le trascrizioni su hardware sotto il proprio controllo, ma "locale" non significa automaticamente "privato". Una configurazione affidabile si compone di quattro parti: un'implementazione di Whisper adeguata, i file del modello scaricati, una pipeline audio ripetibile e un perimetro di sicurezza che copra file temporanei, log, backup e qualsiasi API locale esposta.
Questa guida presenta tre percorsi attuali: il pacchetto Python di riferimento di OpenAI, faster-whisper per un'inferenza Python ottimizzata e whisper.cpp per una distribuzione leggera in C/C++. I comandi e le indicazioni sui modelli riportati di seguito sono stati verificati rispetto alla documentazione ufficiale dei progetti in data 28 agosto 2026.
Raccomandazione rapida
- Inizia con OpenAI Whisper se desideri l'implementazione di riferimento e la CLI ufficiale più semplice.
- Scegli faster-whisper se hai bisogno di un servizio Python, batching, quantizzazione o rilevamento dell'attività vocale integrato.
- Scegli whisper.cpp se desideri una build nativa compatta, supporto per Apple Silicon, una distribuzione focalizzata sulla CPU, un'immagine Docker ufficiale o un piccolo server HTTP locale.
Cosa comporta—e cosa non comporta—l'auto-hosting di Whisper
Whisper è un modello di riconoscimento vocale e una codebase open source. Quando esegui un'implementazione sul proprio computer, la fase di inferenza può avvenire senza inviare la registrazione a un'API di trascrizione ospitata. Una volta presenti i pacchetti e le risorse del modello richiesti, la trascrizione può essere eseguita anche senza una connessione internet attiva.
Questo è un utile perimetro di privacy, non un programma di sicurezza completo. L'inferenza locale non protegge automaticamente file temporanei, cronologia dei comandi, log dell'applicazione, trascrizioni esportate, backup del sistema operativo, cartelle condivise o un servizio in ascolto su una porta di rete. Gli installer dei modelli potrebbero anche scaricare i pesi la prima volta che viene richiesto un nome di modello.
Prima di definire un flusso di lavoro "offline", testalo con la rete disattivata e conferma che:
- l'applicazione si avvia senza tentare di recuperare un pacchetto o un modello;
- il modello selezionato viene caricato da un percorso locale noto;
- audio in ingresso e testo generato rimangono in directory approvate;
- i file temporanei vengono eliminati secondo la tua politica di conservazione; e
- nessun server HTTP è raggiungibile oltre l'interfaccia prevista.
Scegli l'implementazione prima di scegliere un modello
Tutti e tre i percorsi eseguono modelli della famiglia Whisper, ma non hanno dipendenze, nomi di comandi, formati di modello o caratteristiche prestazionali identici. Scegli l'ambiente di runtime che corrisponde al tuo ambiente operativo anziché copiare un comando scritto per un'altra implementazione.
| Implementazione | Migliore utilizzo | Modello di dipendenza principale | Perimetro importante |
|---|---|---|---|
| OpenAI Whisper | CLI di riferimento e API Python | Python, PyTorch, FFmpeg | Scegli la build PyTorch CPU/CUDA corretta |
| faster-whisper | Servizi Python ottimizzati, batching, INT8, VAD | Python e CTranslate2 | I requisiti della libreria GPU variano a seconda della release installata |
| whisper.cpp | Build native CPU/Apple, quantizzazione, Docker, server locale | CMake e compilatore supportato | Utilizza file di modello GGML convertiti e nomi di CLI diversi |
Scegli un modello e dimensiona l'hardware
OpenAI elenca attualmente sei dimensioni di modello. Il suo README fornisce i requisiti approssimativi di VRAM e la velocità relativa misurata su una specifica GPU di riferimento. Questi dati sono utili per una valutazione preliminare, non sono garanzie: la memoria e la velocità effettive dipendono dall'implementazione, dalla precisione, dalla dimensione del batch, dalla dimensione del beam, dalla lingua, dalla durata dell'audio e dall'hardware.
| Nome ufficiale del modello | Parametri | VRAM approssimativa nella tabella di OpenAI | Punto di partenza pratico |
|---|---|---|---|
| tiny | 39 M | ~1 GB | Prova rapida o dispositivo con risorse limitate |
| base | 74 M | ~1 GB | Trascrizione leggera in inglese o multilingue |
| small | 244 M | ~2 GB | Prova bilanciata su CPU o GPU di fascia media |
| medium | 769 M | ~5 GB | Lavoro multilingue ad alta precisione |
| large | 1.550 M | ~10 GB | Capacità massima del modello di riferimento quando l'hardware lo consente |
| turbo | 809 M | ~6 GB | Trascrizione rapida, ma non traduzione |
La tabella di OpenAI descrive turbo come circa otto volte la velocità di riferimento di large nel suo confronto di test. Non trasformare questo in una promessa di "otto volte più veloce su ogni computer". Turbo non è addestrato per la traduzione. Se l'obiettivo è tradurre un parlato non inglese in inglese, OpenAI consiglia invece un modello multilingue come medium o large.
Per registrazioni esclusivamente in inglese, potrebbe valere la pena testare le varianti .en di tiny, base, small e medium. Per dimensionare la produzione, esegui lo stesso file rappresentativo su due modelli candidati e registra la memoria di picco, il tempo effettivo, gli errori di trascrizione e il tempo di correzione.
Prepara il sistema e un file di test pulito
Crea una directory di progetto e un ambiente virtuale dedicati, in modo che le versioni dei pacchetti siano visibili e reversibili. Se utilizzi l'implementazione Python di OpenAI con una GPU, seleziona il comando PyTorch attuale per il tuo sistema operativo e la configurazione CUDA dall'installer ufficiale di PyTorch. Evita di copiare un vecchio URL di una wheel CUDA da un tutorial.
OpenAI Whisper richiede lo strumento a riga di comando FFmpeg. Installalo tramite un gestore di pacchetti supportato o dalla pagina di download ufficiale di FFmpeg, quindi verifica:
ffmpeg -version
python --versionFFmpeg non è una dipendenza obbligatoria universale per ogni implementazione di Whisper. Ad esempio, whisper.cpp può decodificare gli input supportati attraverso i propri strumenti di esempio, mentre l'integrazione opzionale di FFmpeg amplia il supporto ai formati. Per creare un file di test WAV mono a 16 kHz e 16 bit prevedibile per whisper.cpp, usa:
ffmpeg -i input.mp3 -ar 16000 -ac 1 -c:a pcm_s16le output.wavUsa un campione breve e autorizzato contenente un nome, un numero, due relatori, una pausa silenziosa e un termine specifico del settore. Quel singolo file di prova rivelerà più problemi di distribuzione rispetto a un clip demo perfettamente pulito.
Percorso 1: Installa OpenAI Whisper
Apri un terminale all'interno della directory del tuo progetto, crea un ambiente virtuale, attivalo e installa il pacchetto attuale:
python -m venv .venv
# Windows PowerShell
.\.venv\Scripts\Activate.ps1
# macOS o Linux
source .venv/bin/activate
pip install -U openai-whisperEsegui la prima trascrizione con la CLI ufficiale:
whisper audio.mp3 --model turboLa prima esecuzione potrebbe scaricare il modello selezionato. Al termine, verifica che siano stati creati i file di output previsti e confronta diversi timestamp con l'audio sorgente. Per la trascrizione in lingua non inglese dello stesso idioma, specifica la lingua se il rilevamento automatico non è affidabile:
whisper japanese.wav --language Japanese --model turboPer la traduzione in inglese, non usare turbo:
whisper japanese.wav --model medium --language Japanese --task translateUna chiamata Python minima è altrettanto diretta:
import whisper
model = whisper.load_model("turbo")
result = model.transcribe("audio.mp3")
print(result["text"])Percorso 2: Installa faster-whisper
faster-whisper esegue i modelli Whisper tramite CTranslate2. È utile quando desideri un'integrazione Python con precisione configurabile, batching, timestamp delle parole o filtraggio VAD integrato.
python -m venv .venv
source .venv/bin/activate # Windows: .\.venv\Scripts\Activate.ps1
pip install faster-whisperInizia con un dispositivo e un tipo di calcolo espliciti anziché presumere un percorso GPU:
from faster_whisper import WhisperModel
model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe(
"audio.mp3",
beam_size=5,
vad_filter=True,
)
print("Lingua rilevata:", info.language)
for segment in segments:
print(f"[{segment.start:.2f} - {segment.end:.2f}] {segment.text}")I segmenti restituiti sono generati in modo pigro, quindi iterali per eseguire la trascrizione. In una distribuzione NVIDIA, segui i requisiti della libreria GPU del repository attuale di faster-whisper e verifica le versioni installate anziché fare affidamento su una combinazione CUDA/CUDNN più vecchia da un post di un blog.
I benchmark hanno bisogno delle loro condizioni. Il progetto faster-whisper riporta attualmente un esempio in cui large-v2 con INT8 ha utilizzato 2.926 MB su una RTX 3070 Ti 8GB, con beam size 5 e lo stack software dichiarato del repository. Quel risultato dimostra una configurazione testata; non è una promessa che ogni modello, GPU, dimensione del batch o file audio utilizzerà la stessa memoria.
Percorso 3: Compila whisper.cpp
Il progetto attuale si trova sotto ggml-org/whisper.cpp e utilizza CMake nella sua guida rapida documentata. Clona il repository, scarica un modello convertito e compila la CLI:
git clone https://github.com/ggml-org/whisper.cpp.git
cd whisper.cpp
sh ./models/download-ggml-model.sh base.en
cmake -B build
cmake --build build -j --config ReleaseEsegui una trascrizione con un percorso del modello esplicito:
./build/bin/whisper-cli \
--model models/ggml-base.en.bin \
--file output.wavSu Windows, l'eseguibile potrebbe trovarsi all'interno di una cartella specifica per la configurazione come build\bin\Release. Usa whisper-cli --help dall'output di build effettivo per confermare le flag per la tua versione.
whisper.cpp supporta anche modelli GGML quantizzati, che possono ridurre l'utilizzo di memoria e spazio su disco. La quantizzazione può cambiare la qualità e la velocità, quindi confronta un candidato quantizzato con il suo equivalente non quantizzato sul tuo file di prova prima di standardizzarlo.
Prepara una distribuzione air-gapped
Un sistema air-gapped non può recuperare wheel Python mancanti, librerie GPU, pesi del modello, risorse VAD o layer del container. Crea prima un manifesto completo su una macchina di staging connessa.
- Registra il sistema operativo, l'architettura CPU, il modello GPU, la versione del driver e la versione di Python.
- Scarica i pacchetti esatti, i file del modello, il modello VAD opzionale e le loro checksum.
- Trasferisci le risorse attraverso il processo approvato dalla tua organizzazione.
- Installa da percorsi locali e configura una directory locale esplicita per i modelli.
- Scollega la rete prima del test di accettazione.
- Trascrivi il file di prova, conferma gli output e monitora i tentativi di connessione falliti.
Non presumere che un primo avvio online riuscito dimostri una distribuzione offline. Potrebbe aver riempito una cache specifica dell'utente che non esisterà sotto un account di servizio o in un nuovo container. Testa usando la stessa identità, directory e metodo di avvio che utilizzerà la produzione.
Esegui un'API locale o un servizio Docker in modo sicuro
whisper.cpp include whisper-server, un server HTTP con un endpoint di trascrizione simile a OpenAI. Compila prima il progetto, quindi ispeziona le opzioni attuali del server:
./build/bin/whisper-server --help
./build/bin/whisper-server \
--host 127.0.0.1 \
--port 8080 \
--model models/ggml-base.en.binVincola il servizio a localhost a meno che un altro computer non ne abbia genuinamente bisogno. La documentazione di Docker avverte che le porte pubblicate possono essere raggiungibili al di fuori dell'host quando sono vincolate in modo ampio. Se esponi intenzionalmente la trascrizione su una LAN, aggiungi autenticazione, TLS, limiti di dimensione delle richieste, timeout, isolamento dell'upload e una politica di conservazione; un processo locale non è uno strato di controllo degli accessi.
Il progetto whisper.cpp pubblica anche immagini Docker del progetto. Persisti la directory del modello in modo che un container ricreato non scarichi nuovamente le risorse:
docker run --rm \
-v /absolute/path/models:/models \
-v /absolute/path/audio:/audios \
ghcr.io/ggml-org/whisper.cpp:main \
"whisper-cli -m /models/ggml-base.en.bin -f /audios/output.wav"Fissa un digest di immagine o una release testata per la produzione. Tratta i wrapper della community come progetti separati: verifica il loro repository, lo schema dell'API, l'editore dell'immagine, la licenza, la frequenza degli aggiornamenti e le impostazioni di rete predefinite, anziché presentarli come servizi ufficiali di OpenAI.
Usa VAD senza nascondere il parlato reale
Le lunghe sezioni non vocali possono produrre output indesiderati nella trascrizione automatica. Il rilevamento dell'attività vocale può saltare le regioni classificate come silenzio o non vocali prima della decodifica, riducendo il lavoro sprecato e alcuni errori legati al silenzio. Non può garantire che ogni allucinazione scompaia, e le soglie aggressive possono rimuovere parole deboli.
faster-whisper espone Silero VAD tramite vad_filter=True. Inizia con le impostazioni predefinite del progetto, quindi testa pause, voci deboli, musica e registrazioni rumorose prima di modificare i parametri.
La documentazione attuale di whisper.cpp fornisce un modello Silero scaricabile e flag VAD esplicite:
./models/download-vad-model.sh silero-v6.2.0
./build/bin/whisper-cli \
--file output.wav \
--model models/ggml-base.en.bin \
--vad \
--vad-model models/ggml-silero-v6.2.0.binControlla i punti di taglio rispetto alla forma d'onda. Se la prima sillaba dopo una pausa scompare, riduci l'aggressività o aggiungi un margine attorno al parlato rilevato anziché accettare una trascrizione dall'aspetto più pulito ma incompleta.
Valida output, timestamp e qualità
Un comando che termina con successo non è sufficiente. Conserva l'audio sorgente grezzo e rivedi la trascrizione con una piccola checklist di accettazione:
- Completezza: Le prime e le ultime parole sono presenti? Frasi deboli sono state tagliate?
- Nomi e numeri: Controlla persone, prodotti, date, misurazioni e quantità.
- Lingua: Conferma la lingua rilevata e se il compito era trascrivere o tradurre.
- Timestamp: Cerca diversi confini di segmento e verifica l'allineamento.
- Comportamento del silenzio: Ispeziona le pause lunghe per frasi ripetute o inventate.
- Riproducibilità: Registra la versione dell'implementazione, il modello, la precisione, le flag, l'hardware e il runtime.
Per i sottotitoli, imposta una politica di lunghezza della riga e ispeziona il file SRT o VTT finale in un player. Per le note ricercabili, conserva i timestamp o gli ID dei segmenti in modo che un revisore possa tornare all'audio. Per materiale sensibile, separa la registrazione sorgente immutabile dal testo generato e applica un periodo di conservazione definito a entrambi.
Se stai creando un workflow offline di acquisizione alla trascrizione, vedi anche come funziona l'elaborazione AI edge offline e il confronto tra registratori vocali AI offline.
Risoluzione dei problemi comuni
| Sintomo | Controllo probabile | Azione successiva |
|---|---|---|
| FFmpeg non trovato | L'eseguibile è mancante o non è nel PATH | Esegui ffmpeg -version nello stesso shell e correggi il PATH |
| CUDA non disponibile | PyTorch solo CPU o librerie GPU incompatibili | Usa il selettore PyTorch live e i requisiti GPU specifici del progetto |
| Errore di memoria insufficiente | Modello, precisione, batch o lavori concorrenti superano la memoria | Prova un modello più piccolo, una dimensione batch inferiore o un tipo di calcolo quantizzato supportato |
| whisper.cpp rifiuta l'audio | Formato non supportato per l'esempio compilato | Converti in WAV mono a 16 kHz a 16 bit o compila un supporto di decodifica più ampio |
| Testo ripetuto nel silenzio | Il non vocale ha raggiunto il decodificatore | Testa VAD, rivedi i punti di taglio e confronta le impostazioni del modello/decodifica |
| La traduzione restituisce la lingua sorgente | Turbo è stato usato per un compito di traduzione | Usa un modello multilingue come medium o large con --task translate
|
| L'avvio offline prova a scaricare | Un modello, wheel, asset VAD o layer del container è mancante | Completa il manifesto degli asset e testa sotto l'identità di produzione |
Domande frequenti
Whisper può girare completamente offline?
Sì, l'inferenza può girare senza una connessione internet dopo che i software e gli asset del modello richiesti sono memorizzati localmente. Prova il confine testando con la rete disabilitata e controllando per download mancanti, file temporanei, log e servizi esposti.
Quale implementazione di Whisper dovrei ospitare autonomamente?
Usa OpenAI Whisper per la CLI Python di riferimento, faster-whisper per un servizio Python ottimizzato con quantizzazione o VAD, e whisper.cpp per una build nativa, modelli GGML quantizzati, deployment Apple/CPU, Docker, o il suo server locale incluso.
Whisper richiede FFmpeg?
L'implementazione Python di OpenAI richiede lo strumento da riga di comando FFmpeg. Questo non rende FFmpeg obbligatorio per ogni implementazione: whisper.cpp ha il suo percorso di decodifica supportato e integrazione FFmpeg opzionale per formati più ampi.
Quanta VRAM serve al modello turbo?
La tabella dei modelli di OpenAI elenca circa 6 GB per turbo. Tratta questo come una stima di pianificazione per l'implementazione di riferimento; l'uso effettivo cambia con runtime, precisione, dimensione batch, hardware e carichi di lavoro concorrenti.
Il modello turbo può tradurre il parlato in inglese?
No. OpenAI afferma che turbo non è addestrato per la traduzione. Usa un modello multilingue come medium o large quando traduci parlato non inglese in inglese.
VAD previene ogni allucinazione di Whisper?
No. VAD può ridurre il non vocale inviato al modello e può ridurre l'output legato al silenzio, ma può anche rimuovere parlato debole se configurato troppo aggressivamente. Valida le soglie e i confini dei segmenti su audio rappresentativo.
Un'API Whisper locale è privata per impostazione predefinita?
No. L'elaborazione locale evita un'API di trascrizione ospitata, ma il servizio ha ancora bisogno di binding dell'interfaccia, autenticazione quando condiviso, trasporto crittografato dove appropriato, isolamento dell'upload, controlli di logging e una politica di conservazione.
Fonti ufficiali controllate il 28 agosto 2026
0 commenti