Guida a Faster-Whisper: voce in testo più veloce con CTranslate2

Guida a Faster-Whisper: voce in testo più veloce con CTranslate2

2026-01-17SpeechToTextWhisperTutorialPerformance
Eric King

Eric King

Author

Guida a Faster-Whisper: voce in testo più veloce con CTranslate2

Faster-whisper è una reimplementazione ad alte prestazioni del modello Whisper di OpenAI tramite CTranslate2, un motore di inferenza per transformer veloce. Offre una trascrizione 2-4× più veloce con accuratezza simile, ideale per la produzione e l’elaborazione in batch.
Questa guida tratta l’essenziale su faster-whisper: installazione, esempi d’uso, ottimizzazione delle prestazioni e quando preferirlo allo Whisper standard di OpenAI.

Cos’è Faster-whisper?

Faster-whisper è un’implementazione ottimizzata di OpenAI Whisper che usa CTranslate2 per un’inferenza più veloce. Mantiene la stessa accuratezza dell’originale migliorando nettamente la velocità e riducendo l’uso di memoria.

Caratteristiche principali

  • Inferenza 2-4× più veloce rispetto a OpenAI Whisper
  • Minore uso di memoria con supporto alla quantizzazione
  • Stessa accuratezza dei modelli Whisper originali
  • Supporto GPU e CPU con backend ottimizzati
  • Elaborazione in batch per più file
  • Timestamp a livello di parola
  • Opzioni di quantizzazione (FP32, FP16, INT8, INT8_FLOAT16)
  • Rilevamento dell’attività vocale (VAD) per filtrare

Come funziona

Faster-whisper converte i modelli Whisper nel formato CTranslate2, che usa codice C++ ottimizzato per l’inferenza. Ciò consente:
  • Operazioni matriciali più veloci con librerie BLAS ottimizzate
  • Gestione della memoria migliore con meno overhead
  • Quantizzazione per un minor consumo di memoria
  • Elaborazione in batch per ottimizzare il throughput

Faster-whisper vs OpenAI Whisper

Confronto delle prestazioni

CaratteristicaOpenAI WhisperFaster-whisper
VelocitàRiferimento2-4× più veloce
MemoriaMaggioreMinore (con quantizzazione)
AccuratezzaAltaUguale (modelli identici)
Supporto GPUSìSì (ottimizzato)
Supporto CPUSìSì (ottimizzato)
QuantizzazioneLimitataCompleta (INT8, FP16)
Elaborazione batchManualeIntegrata
InstallazioneSempliceSemplice (include CTranslate2)

Quando usare Faster-whisper

Scegliete faster-whisper quando:
  • Vi serve una trascrizione più veloce per carichi di produzione
  • Elaborate più file in batch
  • Eseguite su sistemi con risorse limitate (usate INT8)
  • Costruite applicazioni in tempo reale o quasi
  • Vi serve un minor uso di memoria in deployment
Restate su OpenAI Whisper quando:
  • Vi serve la massima compatibilità col codice esistente
  • Usate modelli fine-tunati (faster-whisper richiede conversione)
  • Preferite una API più semplice (faster-whisper è comunque simile)
  • Lavorate con funzioni sperimentali disponibili prima su OpenAI Whisper

Installazione

Prerequisiti

  • Python 3.9+ (obbligatorio)
  • FFmpeg (opzionale: faster-whisper usa PyAV, FFmpeg può servire per alcuni formati)
  • GPU NVIDIA (opzionale, per accelerazione GPU)

Installazione di base

Installate faster-whisper con pip:
pip install faster-whisper
Vengono installati automaticamente:
  • il pacchetto faster-whisper
  • ctranslate2 (motore di inferenza CTranslate2)
  • pyav (decodifica audio, sostituisce la dipendenza FFmpeg)

Installazione GPU (NVIDIA CUDA)

Per l’accelerazione GPU servono le librerie CUDA:
CUDA 12 (consigliato):
pip install nvidia-cublas-cu12 nvidia-cudnn-cu12==9.*
Impostate il percorso delle librerie:
export LD_LIBRARY_PATH=$(python3 -c 'import os; import nvidia.cublas.lib; import nvidia.cudnn.lib; print(os.path.dirname(nvidia.cublas.lib.__file__) + ":" + os.path.dirname(nvidia.cudnn.lib.__file__))')
CUDA 11 (legacy):
Con CUDA 11 usate una versione CTranslate2 precedente:
pip install ctranslate2==3.24.0 faster-whisper

Verificare l’installazione

from faster_whisper import WhisperModel

# Test basic import
print("Faster-whisper installed successfully!")

Utilizzo di base

Trascrizione semplice

from faster_whisper import WhisperModel

# Load model (automatically downloads if not present)
model = WhisperModel("base", device="cpu", compute_type="int8")

# Transcribe audio
segments, info = model.transcribe("audio.mp3")

# Print detected language
print(f"Detected language: {info.language} (probability: {info.language_probability:.2f})")

# Print transcription
for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

Ottenere il testo completo

from faster_whisper import WhisperModel

model = WhisperModel("base")
segments, info = model.transcribe("audio.mp3")

# Collect all text
full_text = " ".join([segment.text for segment in segments])
print(full_text)

Con timestamp per parola

from faster_whisper import WhisperModel

model = WhisperModel("base", device="cpu", compute_type="int8")

segments, info = model.transcribe(
    "audio.mp3",
    word_timestamps=True,
    beam_size=5
)

for segment in segments:
    print(f"[{segment.start:.2f}s - {segment.end:.2f}s] {segment.text}")
    
    # Word-level timestamps
    for word in segment.words:
        print(f"  {word.word} [{word.start:.2f}s - {word.end:.2f}s]")

Opzioni dispositivo e tipo di calcolo

Opzioni dispositivo

  • device="cpu" — inferenza CPU (funziona ovunque)
  • device="cuda" — inferenza GPU (servono GPU NVIDIA e CUDA)

Tipi di calcolo

Scegliete in base all’hardware e al compromesso velocità/accuratezza:
Tipo di calcoloVelocitàMemoriaAccuratezzaCaso d’uso
int8Più veloceMinimaLeggermente inferioreCPU, risorse limitate
int8_float16Molto veloceBassaAltaGPU con VRAM limitata
float16VeloceMediaAltaGPU (consigliato)
float32Più lentaMassimaMassimaMassima accuratezza

Esempi per hardware

CPU (Intel/AMD):
# Best for CPU: INT8
model = WhisperModel("base", device="cpu", compute_type="int8")
GPU (NVIDIA):
# Best for GPU: FP16
model = WhisperModel("large-v2", device="cuda", compute_type="float16")
GPU con VRAM limitata:
# Use INT8_FLOAT16 for large models
model = WhisperModel("large-v2", device="cuda", compute_type="int8_float16")
Massima accuratezza:
# Use FP32 (slower but most accurate)
model = WhisperModel("large-v2", device="cuda", compute_type="float32")

Funzionalità avanzate

1. Elaborazione in batch

Elaborate più file audio in modo efficiente:
from faster_whisper import WhisperModel
from pathlib import Path

model = WhisperModel("base", device="cuda", compute_type="float16")

audio_files = ["audio1.mp3", "audio2.mp3", "audio3.mp3"]

for audio_file in audio_files:
    print(f"Transcribing: {audio_file}")
    segments, info = model.transcribe(audio_file)
    
    text = " ".join([seg.text for seg in segments])
    print(f"Result: {text[:100]}...")
    print()

2. Rilevamento attività vocale (VAD)

Filtrate silenzio e segmenti non vocali:
from faster_whisper import WhisperModel

model = WhisperModel("base")

segments, info = model.transcribe(
    "audio.mp3",
    vad_filter=True,  # Enable VAD filtering
    vad_parameters=dict(
        min_silence_duration_ms=500,  # Minimum silence duration
        threshold=0.5  # VAD threshold
    )
)

for segment in segments:
    print(f"[{segment.start:.2f}s] {segment.text}")

3. Specificare la lingua

Indicate la lingua per migliorare accuratezza e velocità:
from faster_whisper import WhisperModel

model = WhisperModel("base")

# Specify language (faster and more accurate)
segments, info = model.transcribe(
    "audio.mp3",
    language="en"  # English
)

# Or let it auto-detect
segments, info = model.transcribe("audio.mp3")  # Auto-detect
print(f"Detected: {info.language}")

4. Beam size e altri parametri

from faster_whisper import WhisperModel

model = WhisperModel("base")

segments, info = model.transcribe(
    "audio.mp3",
    beam_size=5,  # Higher = more accurate but slower (default: 5)
    best_of=5,    # Number of candidates to consider
    temperature=0.0,  # Lower = more deterministic
    condition_on_previous_text=True,  # Use context from previous segments
    initial_prompt="This is a technical meeting about AI and machine learning."
)

5. Percorsi modello personalizzati

Usate modelli locali o convertiti personalizzati:
from faster_whisper import WhisperModel

# Use local model directory
model = WhisperModel(
    "base",
    device="cpu",
    compute_type="int8",
    download_root="./models"  # Custom download directory
)

# Or specify full path to converted model
model = WhisperModel(
    "/path/to/converted/model",
    device="cuda",
    compute_type="float16"
)

Benchmark delle prestazioni

Prestazioni GPU (NVIDIA RTX 3070 Ti)

Trascrizione di ~13 minuti di audio:
ConfigurazioneTempoUso VRAMSpeedup
OpenAI Whisper (FP16, beam=5)~2m 23s~4708 MBRiferimento
Faster-whisper (FP16, beam=5)~1m 03s~4525 MB2.3× più veloce
Faster-whisper (INT8, beam=5)~59s~2926 MB2.4× più veloce
Faster-whisper (FP16, batch=8)~17s~6090 MB8.4× più veloce
Faster-whisper (INT8, batch=8)~16s~4500 MB8.9× più veloce

Prestazioni CPU (Intel Core i7-12700K)

ConfigurazioneTempoUso RAMSpeedup
OpenAI Whisper (FP32, beam=5)~6m 58s~2335 MBRiferimento
Faster-whisper (FP32, beam=5)~2m 37s~2257 MB2.7× più veloce
Faster-whisper (INT8, beam=5)~1m 42s~1477 MB4.1× più veloce
Faster-whisper (FP32, batch=8)~1m 06s~4230 MB6.3× più veloce
Faster-whisper (INT8, batch=8)~51s~3608 MB8.2× più veloce

Spunti chiave

  • L’elaborazione in batch dà il maggior speedup (8×+ su GPU)
  • La quantizzazione INT8 riduce la memoria ~40% con perdita minima di accuratezza
  • L’accelerazione GPU è essenziale per modelli grandi e batch
  • CPU con INT8 è praticabile per modelli piccoli e singolo file

Esempio completo: trascrizione pronta per la produzione

from faster_whisper import WhisperModel
from pathlib import Path
import json
from datetime import datetime

class TranscriptionService:
    """Production-ready transcription service using faster-whisper."""
    
    def __init__(self, model_size="base", device="cpu", compute_type="int8"):
        """Initialize the transcription service."""
        print(f"Loading model: {model_size} on {device} ({compute_type})")
        self.model = WhisperModel(
            model_size,
            device=device,
            compute_type=compute_type
        )
        print("Model loaded successfully!")
    
    def transcribe_file(self, audio_path, output_format="txt", **kwargs):
        """
        Transcribe an audio file.
        
        Args:
            audio_path: Path to audio file
            output_format: Output format (txt, json, srt, vtt)
            **kwargs: Additional transcription parameters
        """
        audio_path = Path(audio_path)
        if not audio_path.exists():
            raise FileNotFoundError(f"Audio file not found: {audio_path}")
        
        print(f"Transcribing: {audio_path.name}")
        
        # Transcribe
        segments, info = self.model.transcribe(
            str(audio_path),
            word_timestamps=True,
            **kwargs
        )
        
        # Collect results
        result = {
            "file": str(audio_path),
            "language": info.language,
            "language_probability": info.language_probability,
            "duration": info.duration,
            "segments": []
        }
        
        full_text_parts = []
        for segment in segments:
            segment_data = {
                "start": segment.start,
                "end": segment.end,
                "text": segment.text,
                "words": [
                    {
                        "word": word.word,
                        "start": word.start,
                        "end": word.end,
                        "probability": word.probability
                    }
                    for word in segment.words
                ]
            }
            result["segments"].append(segment_data)
            full_text_parts.append(segment.text)
        
        result["text"] = " ".join(full_text_parts)
        
        # Save based on format
        output_path = audio_path.parent / f"{audio_path.stem}_transcript"
        
        if output_format == "txt":
            self._save_txt(result, output_path.with_suffix(".txt"))
        elif output_format == "json":
            self._save_json(result, output_path.with_suffix(".json"))
        elif output_format == "srt":
            self._save_srt(result, output_path.with_suffix(".srt"))
        elif output_format == "vtt":
            self._save_vtt(result, output_path.with_suffix(".vtt"))
        
        print(f"✓ Transcription saved: {output_path}.{output_format}")
        return result
    
    def _save_txt(self, result, path):
        """Save as plain text."""
        with open(path, "w", encoding="utf-8") as f:
            f.write(result["text"])
    
    def _save_json(self, result, path):
        """Save as JSON."""
        with open(path, "w", encoding="utf-8") as f:
            json.dump(result, f, indent=2, ensure_ascii=False)
    
    def _save_srt(self, result, path):
        """Save as SRT subtitles."""
        with open(path, "w", encoding="utf-8") as f:
            for i, seg in enumerate(result["segments"], start=1):
                start = self._format_srt_time(seg["start"])
                end = self._format_srt_time(seg["end"])
                f.write(f"{i}\n{start} --> {end}\n{seg['text']}\n\n")
    
    def _save_vtt(self, result, path):
        """Save as WebVTT."""
        with open(path, "w", encoding="utf-8") as f:
            f.write("WEBVTT\n\n")
            for seg in result["segments"]:
                start = self._format_vtt_time(seg["start"])
                end = self._format_vtt_time(seg["end"])
                f.write(f"{start} --> {end}\n{seg['text']}\n\n")
    
    def _format_srt_time(self, seconds):
        """Format time for SRT."""
        hours = int(seconds // 3600)
        minutes = int((seconds % 3600) // 60)
        secs = int(seconds % 60)
        millis = int((seconds % 1) * 1000)
        return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"
    
    def _format_vtt_time(self, seconds):
        """Format time for VTT."""
        hours = int(seconds // 3600)
        minutes = int((seconds % 3600) // 60)
        secs = int(seconds % 60)
        millis = int((seconds % 1) * 1000)
        return f"{hours:02d}:{minutes:02d}:{secs:02d}.{millis:03d}"

# Usage
if __name__ == "__main__":
    # Initialize service
    service = TranscriptionService(
        model_size="base",
        device="cpu",  # Change to "cuda" for GPU
        compute_type="int8"  # Use "float16" for GPU
    )
    
    # Transcribe file
    result = service.transcribe_file(
        "meeting.mp3",
        output_format="json",
        beam_size=5,
        language="en"
    )
    
    print(f"\nLanguage: {result['language']}")
    print(f"Duration: {result['duration']:.2f}s")
    print(f"Text: {result['text'][:200]}...")

Buone pratiche

1. Scegliere la dimensione del modello giusta

# For speed (CPU)
model = WhisperModel("tiny", device="cpu", compute_type="int8")

# For balance
model = WhisperModel("base", device="cpu", compute_type="int8")

# For accuracy (GPU recommended)
model = WhisperModel("large-v2", device="cuda", compute_type="float16")

2. Ottimizzare per il vostro hardware

Solo CPU:
model = WhisperModel("base", device="cpu", compute_type="int8")
GPU con VRAM sufficiente:
model = WhisperModel("large-v2", device="cuda", compute_type="float16")
GPU con VRAM limitata:
model = WhisperModel("medium", device="cuda", compute_type="int8_float16")

3. Elaborazione in batch per più file

# Process multiple files efficiently
audio_files = ["file1.mp3", "file2.mp3", "file3.mp3"]
model = WhisperModel("base", device="cuda", compute_type="float16")

for audio_file in audio_files:
    segments, info = model.transcribe(audio_file)
    # Process results...

4. Abilitare VAD con audio rumoroso

segments, info = model.transcribe(
    "noisy_audio.mp3",
    vad_filter=True,
    vad_parameters=dict(
        min_silence_duration_ms=1000,
        threshold=0.5
    )
)

5. Specificare la lingua se nota

# Faster and more accurate when language is known
segments, info = model.transcribe(
    "audio.mp3",
    language="en"  # Specify instead of auto-detect
)

6. Riutilizzare le istanze del modello

# Load model once, reuse for multiple files
model = WhisperModel("base")

# Process multiple files with same model
for audio_file in audio_files:
    segments, info = model.transcribe(audio_file)

Migrazione da OpenAI Whisper

Confronto del codice

OpenAI Whisper:
import whisper

model = whisper.load_model("base")
result = model.transcribe("audio.mp3")
print(result["text"])
Faster-whisper:
from faster_whisper import WhisperModel

model = WhisperModel("base", device="cpu", compute_type="int8")
segments, info = model.transcribe("audio.mp3")
text = " ".join([seg.text for seg in segments])
print(text)

Differenze principali

  1. Caricamento modello: WhisperModel() invece di whisper.load_model()
  2. Formato di ritorno: tupla (segments, info) invece di dict
  3. Segmenti: iteratore di oggetti segmento invece di lista
  4. Device/tipo di calcolo: occorre specificare device e compute_type
  5. Accesso al testo: unire i segmenti per il testo completo

Funzione di supporto alla migrazione

def convert_to_whisper_format(segments, info):
    """Convert faster-whisper output to OpenAI Whisper format."""
    return {
        "text": " ".join([seg.text for seg in segments]),
        "language": info.language,
        "segments": [
            {
                "id": i,
                "start": seg.start,
                "end": seg.end,
                "text": seg.text,
                "words": [
                    {
                        "word": word.word,
                        "start": word.start,
                        "end": word.end
                    }
                    for word in seg.words
                ] if hasattr(seg, 'words') else []
            }
            for i, seg in enumerate(segments)
        ]
    }

# Usage
segments, info = model.transcribe("audio.mp3", word_timestamps=True)
result = convert_to_whisper_format(segments, info)
# Now compatible with OpenAI Whisper format

Risoluzione dei problemi

Problema 1: CUDA out of memory

Problema: la GPU esaurisce la memoria con modelli grandi.
Soluzioni:
# Use smaller model
model = WhisperModel("base", device="cuda", compute_type="float16")

# Or use INT8 quantization
model = WhisperModel("large-v2", device="cuda", compute_type="int8_float16")

# Or use CPU
model = WhisperModel("large-v2", device="cpu", compute_type="int8")

Problema 2: prestazioni CPU lente

Problema: la trascrizione è lenta su CPU.
Soluzioni:
# Use INT8 quantization
model = WhisperModel("base", device="cpu", compute_type="int8")

# Use smaller model
model = WhisperModel("tiny", device="cpu", compute_type="int8")

# Reduce beam size
segments, info = model.transcribe("audio.mp3", beam_size=1)

Problema 3: librerie CUDA non trovate

Problema: RuntimeError: CUDA runtime not found
Soluzione:
# Install CUDA libraries
pip install nvidia-cublas-cu12 nvidia-cudnn-cu12==9.*

# Set library path
export LD_LIBRARY_PATH=$(python3 -c 'import os; import nvidia.cublas.lib; import nvidia.cudnn.lib; print(os.path.dirname(nvidia.cublas.lib.__file__) + ":" + os.path.dirname(nvidia.cudnn.lib.__file__))')

Problema 4: download del modello fallisce

Problema: il download del modello va in timeout o fallisce.
Soluzione:
# Specify download directory
model = WhisperModel(
    "base",
    download_root="./models",  # Custom directory
    local_files_only=False
)

# Or download manually from Hugging Face
# Then use local path
model = WhisperModel("/path/to/local/model")

Quando usare Faster-whisper

Usate Faster-whisper quando:

✅ Deploy in produzione che richiedono velocità
✅ Elaborazione in batch di più file
✅ Ambienti con risorse limitate (usate INT8)
✅ Applicazioni in tempo reale o quasi
✅ Accelerazione GPU disponibile
✅ Minore uso di memoria è importante

Usate OpenAI Whisper quando:

✅ Massima compatibilità col codice esistente
✅ Modelli fine-tunati (integrazione più semplice)
✅ Preferenza per API più semplice
✅ Funzioni sperimentali prima su OpenAI Whisper
✅ Apprendimento/sviluppo (più documentazione/esempi)

Conclusione

Faster-whisper offre miglioramenti significativi delle prestazioni rispetto a OpenAI Whisper mantenendo la stessa accuratezza. Con la configurazione giusta potete ottenere 2-4× più velocità su CPU e fino a 8× su GPU con elaborazione in batch.
Punti chiave:
  • Usate INT8 su CPU e sistemi limitati
  • Usate FP16 su GPU con VRAM sufficiente
  • Abilitate l’elaborazione in batch per più file
  • Specificate la lingua se nota per migliori prestazioni
  • Riutilizzate le istanze del modello per più trascrizioni
Per altre informazioni sulla trascrizione Whisper, consultate le nostre guide Esempio Whisper in Python, Suggerimenti per l’accuratezza di Whisper e Formattazione trascrizioni Whisper.
Cercate una soluzione professionale voce-testo? Visitate SayToWords per la nostra piattaforma di trascrizione IA con prestazioni ottimizzate e più formati di output.

Articoli correlati

Cos'è il riconoscimento vocale e come usarlo: guida completa per principianti

Cos'è il riconoscimento vocale e come usarlo: guida completa per principianti

2026-01-19
Come Convertire Audio in Testo Online: Metodi Gratuiti e Accurati (Guida 2026)

Come Convertire Audio in Testo Online: Metodi Gratuiti e Accurati (Guida 2026)

2026-01-19
Come rimuovere il rumore di fondo per STT: guida completa alla riduzione del rumore per speech-to-text

Come rimuovere il rumore di fondo per STT: guida completa alla riduzione del rumore per speech-to-text

2026-01-18

Provalo gratis ora

Prova subito il nostro servizio basato su IA per voce, audio e video! Non solo ottieni una trascrizione voce‑testo ad alta precisione, traduzione multilingue e identificazione intelligente dei parlanti, ma puoi anche generare automaticamente sottotitoli per i video, modificare in modo intelligente i contenuti audio‑video ed effettuare analisi sincronizzate di audio e immagine. Copri tutti gli scenari: verbali di riunioni, creazione di video brevi, produzione di podcast e molto altro. Inizia ora la tua prova gratuita!

Inizia