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

---

Cos’è Faster-whisper?

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

• 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

Caratteristica	OpenAI Whisper	Faster-whisper
Velocità	Riferimento	2-4× più veloce
Memoria	Maggiore	Minore (con quantizzazione)
Accuratezza	Alta	Uguale (modelli identici)
Supporto GPU	Sì	Sì (ottimizzato)
Supporto CPU	Sì	Sì (ottimizzato)
Quantizzazione	Limitata	Completa (INT8, FP16)
Elaborazione batch	Manuale	Integrata
Installazione	Semplice	Semplice (include CTranslate2)

Quando usare Faster-whisper

• 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

• 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

pip install faster-whisper

• il pacchetto faster-whisper
• ctranslate2 (motore di inferenza CTranslate2)
• pyav (decodifica audio, sostituisce la dipendenza FFmpeg)

Installazione GPU (NVIDIA CUDA)

pip install nvidia-cublas-cu12 nvidia-cudnn-cu12==9.*

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__))')

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

Tipo di calcolo	Velocità	Memoria	Accuratezza	Caso d’uso
int8	Più veloce	Minima	Leggermente inferiore	CPU, risorse limitate
int8_float16	Molto veloce	Bassa	Alta	GPU con VRAM limitata
float16	Veloce	Media	Alta	GPU (consigliato)
float32	Più lenta	Massima	Massima	Massima accuratezza

Esempi per hardware

# Best for CPU: INT8
model = WhisperModel("base", device="cpu", compute_type="int8")

# Best for GPU: FP16
model = WhisperModel("large-v2", device="cuda", compute_type="float16")

# Use INT8_FLOAT16 for large models
model = WhisperModel("large-v2", device="cuda", compute_type="int8_float16")

# Use FP32 (slower but most accurate)
model = WhisperModel("large-v2", device="cuda", compute_type="float32")

---

Funzionalità avanzate

1. Elaborazione in batch

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)

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

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

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)

Configurazione	Tempo	Uso VRAM	Speedup
OpenAI Whisper (FP16, beam=5)	~2m 23s	~4708 MB	Riferimento
Faster-whisper (FP16, beam=5)	~1m 03s	~4525 MB	2.3× più veloce
Faster-whisper (INT8, beam=5)	~59s	~2926 MB	2.4× più veloce
Faster-whisper (FP16, batch=8)	~17s	~6090 MB	8.4× più veloce
Faster-whisper (INT8, batch=8)	~16s	~4500 MB	8.9× più veloce

Prestazioni CPU (Intel Core i7-12700K)

Configurazione	Tempo	Uso RAM	Speedup
OpenAI Whisper (FP32, beam=5)	~6m 58s	~2335 MB	Riferimento
Faster-whisper (FP32, beam=5)	~2m 37s	~2257 MB	2.7× più veloce
Faster-whisper (INT8, beam=5)	~1m 42s	~1477 MB	4.1× più veloce
Faster-whisper (FP32, batch=8)	~1m 06s	~4230 MB	6.3× più veloce
Faster-whisper (INT8, batch=8)	~51s	~3608 MB	8.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

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

model = WhisperModel("large-v2", device="cuda", compute_type="float16")

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

import whisper

model = whisper.load_model("base")
result = model.transcribe("audio.mp3")
print(result["text"])

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

# 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

# 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

# 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

# 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:

Usate OpenAI Whisper quando:

---

Conclusione

• 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

---