Trascrizione vocale in batch con Whisper

Apri la versione notebook di questa pagina

Usa OpenAI Whisper large-v3-turbo per trascrivere un gruppo di registrazioni audio in inglese su un A10 AI Runtime collegato. Questo quaderno mostra come:

  • Carica il modello Whisper con grande turbo v3 con la pipeline Transformers.
  • Costruisci un lotto di campioni audio dal set di test LibriSpeech.
  • Visualizza la forma d'onda e lo spettrogramma di ogni campione.
  • Esegui la trascrizione in batch e confronta il suo throughput rispetto all'inferenza sequenziale.

Note

Questo esempio richiede l'ambiente di IA Databricks versione 6 o superiore.

Connessione alla computazione GPU senza server

  1. Dal selezionatore di calcolo del notebook, seleziona GPU serverless.
  2. Nel pannello Ambiente , seleziona l'acceleratore A10 e l'ambiente AI v6 .
  3. Clicca su Applica, poi conferma l'ambiente.

Il modello Whisper e il dataset campione LibriSpeech sono pubblici e non richiedono l'autenticazione con Hugging Face.

Importare librerie

L'ambiente AI include i pacchetti PyTorch, Transformers e Hugging Face Datasets utilizzati in questo notebook, quindi non è necessaria l'installazione di un pacchetto. Questa cella li importa e conferma che una GPU è collegata.

import torch
import transformers
import datasets

print(f"Environment")
print(f"   PyTorch:      {torch.__version__}")
print(f"   Transformers: {transformers.__version__}")
print(f"   Datasets:     {datasets.__version__}")
print(f"\nGPU")
print(f"   Available:    {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"   Device:       {torch.cuda.get_device_name(0)}")
    mem_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
    print(f"   Memory:       {mem_gb:.1f} GB")

Environment
   PyTorch:      2.11.0+cu130
   Transformers: 5.8.1
   Datasets:     4.8.5

GPU
   Available:    True
   Device:       NVIDIA A10G
   Memory:       23.7 GB

Carica il modello Whisper

Load openai/whisper-large-v3-turbo, un modello distillato da 809 milioni di parametri che offre un'accuratezza vicina allo stato dell'arte con una velocità di inferenza superiore. La pipeline Transformers gestisce l'estrazione delle caratteristiche, la tokenizzazione e la decodifica in un'unica chiamata.

from transformers import pipeline
import torch

whisper_pipe = pipeline(
    "automatic-speech-recognition",
    model="openai/whisper-large-v3-turbo",
    torch_dtype=torch.float16,
    device="cuda",
)
print(f"Model loaded on {whisper_pipe.device}")

Model loaded on cuda

Carica ed esplora i campioni audio

Carica il set di test LibriSpeech ASR, una raccolta di registrazioni audio pulite di parlato in inglese con trascrizioni di riferimento, e riproduci il primo campione.

from datasets import load_dataset, Audio as AudioFeature
from IPython.display import display, Audio
import numpy as np
import soundfile as sf
import io

# Load the LibriSpeech test samples (decode=False to avoid torchcodec/FFmpeg dependency)
ds = load_dataset(
    "hf-internal-testing/librispeech_asr_dummy", "clean", split="validation"
)
ds = ds.cast_column("audio", AudioFeature(decode=False))
print(f"Loaded {len(ds)} audio samples\n")

def decode_audio(raw):
    """Decode raw audio bytes with soundfile."""
    arr, sr = sf.read(io.BytesIO(raw["bytes"]))
    return {"array": arr, "sampling_rate": sr}

# Show metadata for first few samples
for i in range(5):
    audio = decode_audio(ds[i]["audio"])
    duration = len(audio["array"]) / audio["sampling_rate"]
    text_preview = ds[i]["text"][:80]
    print(f"  Sample {i+1}:  {duration:.2f}s  |  {audio['sampling_rate']} Hz  |  \"{text_preview}...\"")

# Play the first sample inline
print("\n>> Playing Sample 1:")
audio_0 = decode_audio(ds[0]["audio"])
display(Audio(audio_0["array"], rate=audio_0["sampling_rate"]))

Loaded 73 audio samples

  Sample 1:  5.86s  |  16000 Hz  |  "MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME H..."
  Sample 2:  4.82s  |  16000 Hz  |  "NOR IS MISTER QUILTER'S MANNER LESS INTERESTING THAN HIS MATTER..."
  Sample 3:  12.48s  |  16000 Hz  |  "HE TELLS US THAT AT THIS FESTIVE SEASON OF THE YEAR WITH CHRISTMAS AND ROAST BEE..."
  Sample 4:  9.90s  |  16000 Hz  |  "HE HAS GRAVE DOUBTS WHETHER SIR FREDERICK LEIGHTON'S WORK IS REALLY GREEK AFTER ..."
  Sample 5:  29.40s  |  16000 Hz  |  "LINNELL'S PICTURES ARE A SORT OF UP GUARDS AND AT EM PAINTINGS AND MASON'S EXQUI..."

>> Playing Sample 1:

Visualizza le forme d'onda audio

Visualizza la forma d'onda e lo spettrogramma di ciascun campione affiancati. La forma d'onda mostra l'ampiezza nel tempo, e lo spettrogramma mostra il contenuto di frequenza, dove l'energia vocale si concentra nella banda del parlato da 100 a 4.000 Hz.

import matplotlib.pyplot as plt
import numpy as np

NUM_SAMPLES = 4
fig, axes = plt.subplots(NUM_SAMPLES, 2, figsize=(16, 3 * NUM_SAMPLES))
fig.suptitle(
    "Waveform & Spectrogram Profiles", fontsize=16, fontweight="bold", y=1.01
)

for i in range(NUM_SAMPLES):
    audio = decode_audio(ds[i]["audio"])
    samples = audio["array"]
    sr = audio["sampling_rate"]
    t = np.arange(len(samples)) / sr

    # --- Waveform ---
    ax_wave = axes[i, 0]
    ax_wave.plot(t, samples, linewidth=0.4, color="#1f77b4", alpha=0.8)
    ax_wave.fill_between(t, samples, alpha=0.15, color="#1f77b4")
    ax_wave.set_ylabel("Amplitude", fontsize=9)
    ax_wave.set_title(f"Sample {i+1} — Waveform ({len(samples)/sr:.1f}s)", fontsize=10)
    ax_wave.set_xlim(0, t[-1])
    ax_wave.grid(True, alpha=0.3)
    if i == NUM_SAMPLES - 1:
        ax_wave.set_xlabel("Time (seconds)", fontsize=9)

    # --- Spectrogram ---
    ax_spec = axes[i, 1]
    ax_spec.specgram(samples, Fs=sr, NFFT=1024, noverlap=512, cmap="magma")
    ax_spec.set_ylabel("Frequency (Hz)", fontsize=9)
    ax_spec.set_title(f"Sample {i+1} — Spectrogram", fontsize=10)
    ax_spec.set_ylim(0, 8000)  # Focus on speech frequencies
    if i == NUM_SAMPLES - 1:
        ax_spec.set_xlabel("Time (seconds)", fontsize=9)

plt.tight_layout()
plt.show()

Trascrivi un singolo campione

Trascrivi un campione per verificare la pipeline, poi confronta la previsione con il testo di riferimento.

import time

audio_input = decode_audio(ds[0]["audio"])

start = time.perf_counter()
result = whisper_pipe(
    audio_input["array"],
    generate_kwargs={"language": "en"},
)
elapsed = time.perf_counter() - start

duration = len(audio_input["array"]) / audio_input["sampling_rate"]

print(f"Inference time:   {elapsed:.2f}s for {duration:.1f}s audio ({duration/elapsed:.1f}x realtime)")
print(f"\nPredicted:  {result['text'].strip()}")
print(f"Reference:  {ds[0]['text']}")

Inference time:   12.23s for 5.9s audio (0.5x realtime)

Predicted:  Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.
Reference:  MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL

Esecuzione dell'inferenza in batch

Trascrivi tutti gli esempi con un batch_size configurabile. Il batching permette alla GPU di elaborare più clip audio in parallelo, migliorando la velocità rispetto all'inferenza sequenziale. Questa cella misura anche il tempo di una baseline sequenziale a scopo di confronto.

import time
import pandas as pd

_decoded = [decode_audio(ds[i]["audio"]) for i in range(len(ds))]
audio_inputs = [d["array"] for d in _decoded]
_sr = _decoded[0]["sampling_rate"]

# --- Sequential baseline ---
start = time.perf_counter()
seq_results = [
    whisper_pipe(a, generate_kwargs={"language": "en"}) for a in audio_inputs
]
seq_time = time.perf_counter() - start

# --- Batched inference ---
start = time.perf_counter()
batch_results = whisper_pipe(
    audio_inputs, batch_size=8, generate_kwargs={"language": "en"}
)
batch_time = time.perf_counter() - start

total_audio_sec = sum(
    len(a) / _sr for a in audio_inputs
)

print(f"Performance Comparison ({len(audio_inputs)} samples, {total_audio_sec:.1f}s total audio)")
print(f"   Sequential:  {seq_time:.2f}s  ({total_audio_sec/seq_time:.1f}x realtime)")
print(f"   Batched (8): {batch_time:.2f}s  ({total_audio_sec/batch_time:.1f}x realtime)")
print(f"   Speedup:     {seq_time/batch_time:.2f}x\n")

# --- Results table ---
rows = []
for i, res in enumerate(batch_results):
    duration = len(audio_inputs[i]) / _sr
    rows.append({
        "Sample": i + 1,
        "Duration (s)": round(duration, 1),
        "Transcription": res["text"].strip(),
        "Reference": ds[i]["text"],
    })

df = pd.DataFrame(rows)
display(df)

Performance Comparison (73 samples, 481.0s total audio)
   Sequential:  16.02s  (30.0x realtime)
   Batched (8): 9.56s  (50.3x realtime)
   Speedup:     1.68x

Sommario

Questo quaderno dimostrava:

  • Inferenza GPU senza configurazione: l'ambiente di runtime AI include torch, transformers e datasets già preinstallati; senza necessità di %pip install
  • Riproduzione audio in linea: ascolta i clip audio direttamente nel notebook con IPython.display.Audio
  • Visualizzazione di forma d'onda e spettrogramma: renderizzata con matplotlib, anch'essa preinstallata
  • Inferenza efficiente in batch: utilizzo del parametro batch_size per la trascrizione parallela su GPU
  • Whisper large-v3-turbo: un modello veloce e accurato per la trascrizione vocale pronto per la produzione

Per adattare questo ai tuoi dati, sostituisci il dataset HuggingFace con file audio provenienti da un Unity Catalog Volume o da un percorso di archiviazione cloud.

Notebook di esempio

Conversione del parlato in testo in batch con Whisper

Ottieni il notebook

  • Ultimo aggiornamento: