Come eseguire SAM Audio in locale

Probabilmente conosci già la segmentazione di immagini e video, ma la segmentazione audio è un’idea molto meno esplorata. Indica la capacità di separare e isolare suoni all’interno di un flusso audio, ad esempio estrarre una voce parlata dalla musica di sottofondo o isolare la voce di una singola persona in una riunione di gruppo. Fino a poco tempo fa, questi compiti richiedevano strumenti specializzati, specifici per il task, e una buona dose di lavoro manuale.

In questo tutorial esploreremo SAM Audio, l’estensione audio del Segment Anything Model. Imposteremo un ambiente locale, installeremo le dipendenze necessarie, caricheremo il modello ed eseguiremo l’inferenza su una GPU RTX 3090. 

Lungo il percorso, visualizzeremo come SAM Audio può segmentare con precisione parti specifiche di un segnale audio in modo molto più intuitivo e clinicamente preciso rispetto agli approcci tradizionali di elaborazione audio.

Che cos’è SAM Audio?

SAM Audio è un modello multimodale unificato, il primo nel suo genere, progettato per rendere la separazione audio intuitiva quanto interagire con il suono stesso. Ispirato al successo del Segment Anything Model nella visione, SAM Audio consente di isolare qualsiasi suono da mix audio complessi usando prompt naturali, tramite testo, segnali visivi in un video o marcando intervalli temporali. Questo approccio unificato sostituisce strumenti audio frammentati e monoscopo con un unico sistema che funziona in modo affidabile su parlato, musica e suoni generali, anche in scenari reali “in the wild”.

Fonte: facebookresearch/sam-audio

Al cuore di SAM Audio c’è il Perception Encoder Audiovisual (PE-AV), un potente motore che allinea ciò che si vede con ciò che si sente codificando congiuntamente segnali audio e visivi nel tempo. 

Basato sul Perception Encoder open-source di Meta, PE-AV fornisce rappresentazioni ricche e temporalmente precise che abilitano prestazioni allo stato dell’arte nella separazione audio multimodale. 

Insieme, SAM Audio e PE-AV aprono nuove possibilità per media creativi, accessibilità e comprensione dell’audio, rendendo la segmentazione audio di livello professionale più veloce, accessibile e semplice da controllare che mai.

Tutorial su SAM Audio 

Ora ti guiderò nell’avvio e nell’utilizzo di SAM Audio in locale. 

1. Configurazione dell’ambiente

SAM Audio è un modello con accesso controllato, il che significa che devi richiedere l’accesso prima di poterlo scaricare e utilizzare in locale. Inizia visitando la pagina del modello su Hugging Face all’indirizzo facebook/sam-audio-large e compila il modulo di richiesta. L’approvazione di solito richiede circa 10 minuti, ma in alcuni casi l’accesso può essere negato a seconda della tua posizione o di altre policy imposte da Meta.

Fonte: facebook/sam-audio-large · Hugging Face

Una volta ottenuto l’accesso, avvia un Jupyter Notebook locale e installa la libreria SAM Audio direttamente dal repository ufficiale:

!pip install -q git+https://github.com/facebookresearch/sam-audio.gitOfferto da

Un problema comune quando si lavora con SAM Audio è l’arresto anomalo o il riavvio inaspettato del kernel di Jupyter. Di solito è causato da una versione incompatibile di torchcodec. Per risolvere, disinstalla la versione esistente e installa esplicitamente quella consigliata:

!pip uninstall -y torchcodec
!pip install --no-cache-dir "torchcodec==0.7.0" -f https://download.pytorch.org/whl/torchcodec/Offerto da

Per scaricare modello e dipendenze più velocemente, useremo hf_transfer: 

!pip install hf_transferOfferto da

Infine, effettua il login a Hugging Face Hub usando un token di accesso. Assicurati di aver generato un token API dal tuo account Hugging Face e di averlo salvato come variabile d’ambiente (HF_TOKEN):

import os
from huggingface_hub import login

login(token=os.environ["HF_TOKEN"])Offerto da

2. Caricare il modello SAM Audio (FP16 su CUDA)

In questo passaggio scaricheremo e caricheremo il modello base di SAM Audio. Anche se SAM Audio fornisce anche una variante large, il modello base offre quasi la stessa qualità di separazione pur essendo significativamente più leggero in termini di memoria GPU. 

Questo lo rende una scelta molto migliore per esperimenti in locale, specialmente su GPU consumer come la RTX 3090.

Per evitare errori di memoria insufficiente (OOM), è importante caricare il modello in FP16 (mezza precisione) invece che in FP32. 

La RTX 3090 ha un ottimo supporto FP16 e passare alla mezza precisione dimezza quasi l’uso della VRAM senza influire in modo percepibile sulla qualità dell’inferenza.

import torch
import torchaudio
from pathlib import Path

from sam_audio import SAMAudio, SAMAudioProcessor

MODEL_ID = "facebook/sam-audio-base"  # base model
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model = SAMAudio.from_pretrained(MODEL_ID).eval()

# Use fp16 on GPU to cut VRAM roughly in half (3090 supports fp16 well)
model = model.to(device=device, dtype=torch.float16).eval()

processor = SAMAudioProcessor.from_pretrained(MODEL_ID)

print("Device:", device)
print("Sampling rate:", processor.audio_sampling_rate)Offerto da

La prima volta che lo esegui, il download può richiedere un po’. SAM Audio scarica più componenti e checkpoint che insieme formano l’intera pipeline di segmentazione audio, incluso il perception encoder e i moduli generativi di separazione. È un comportamento previsto e accade solo una volta, perché i file vengono memorizzati in cache in locale per le esecuzioni successive.

Dopo il caricamento del modello, è buona pratica controllare l’utilizzo della memoria GPU per assicurarsi che tutto rientri nei limiti:

!nvidia-smiOfferto da

Dovresti osservare che il modello base di SAM Audio utilizza circa 14 GB di VRAM, che rientrano comodamente in una RTX 3090. Questo lascia margine sufficiente per inferenza ed esperimenti senza generare problemi di memoria, rendendo la configurazione stabile e affidabile per i task di segmentazione audio in locale.

3. Caricare un campione audio di esempio da AudioCaps

Per testare SAM Audio, ci serve un campione audio realistico che contenga più sorgenti sonore sovrapposte. Per questo tutorial useremo un esempio da AudioCaps, un dataset di riferimento ampiamente usato per la comprensione e la didascalizzazione dell’audio. 

AudioCaps contiene clip audio brevi e variegati raccolti da ambienti reali, ed è ideale per valutare modelli di separazione audio.

Carichiamo il dataset direttamente da Hugging Face usando la libreria datasets. Il campione audio è archiviato in formato Parquet e include sia i dati della forma d’onda sia metadati come la frequenza di campionamento.

from datasets import load_dataset
from IPython.display import Audio

# Get an example audio from AudioCaps
dset = load_dataset(
    "parquet",
    data_files="hf://datasets/OpenSound/AudioCaps/data/test-00000-of-00041.parquet",
)

samples = dset["train"][8]["audio"].get_all_samples()
Audio(samples.data, rate=samples.sample_rate)Offerto da

Questo codice scarica una singola shard del set di test di AudioCaps ed estrae una clip audio per la dimostrazione. Il widget Audio ti permette di ascoltare il mix grezzo direttamente nel notebook, utile per capire quanto sia complesso l’audio originale prima della segmentazione. Ecco come suona:

4. Visualizzare la traccia audio

Ascoltare è il modo più rapido per capire un mix audio, ma visualizzare la forma d’onda ti aiuta a vedere dove succedono le cose. 

Un grafico della forma d’onda rende più facile individuare momenti con forte energia (come un clacson, un applauso o un urlo), zone più silenziose (pause o rumore di fondo) e picchi improvvisi che spesso corrispondono a eventi sonori brevi. 

Questo diventa particolarmente utile quando iniziamo a separare i suoni, perché puoi confrontare il mix originale con l’output segmentato e verificare velocemente se SAM Audio ha davvero estratto la regione giusta.

Qui sotto trovi una semplice funzione di supporto che traccia la forma d’onda fino a una durata fissa (così il grafico resta leggibile). Supporta audio mono e stereo e sposta automaticamente i tensori su CPU per funzionare senza intoppi in un notebook.

import matplotlib.pyplot as plt
import torch

def plot_waveform(wav, sr, title="Waveform", max_seconds=15):
    """
    wav: Tensor [C, T] or [T]
    sr: sample rate (int)
    """
    if isinstance(wav, torch.Tensor):
        w = wav.detach().cpu()
    else:
        w = torch.tensor(wav)

    if w.ndim == 1:
        w = w.unsqueeze(0)

    # limit duration for readability
    max_samples = int(sr * max_seconds)
    w = w[:, :max_samples]

    t = torch.arange(w.shape[1]) / sr

    plt.figure(figsize=(14, 3))
    for c in range(w.shape[0]):
        plt.plot(t, w[c].numpy(), label=f"ch{c}")
    plt.title(title)
    plt.xlabel("Time (s)")
    plt.ylabel("Amplitude")
    if w.shape[0] > 1:
        plt.legend()
    plt.tight_layout()
    plt.show()
plot_waveform(samples.data, samples.sample_rate, title="Traffic noise + Horn")Offerto da

In questo esempio, noterai tipicamente una forma d’onda fitta e ricca che rappresenta rumore di fondo continuo (traffico), e picchi più netti che spesso corrispondono a eventi sonori brevi e più forti (come un clacson). 

5. Preparare l’audio per l’inferenza

Prima di eseguire SAM Audio, dobbiamo assicurarci che la forma d’onda in input corrisponda a ciò che il modello si aspetta. In pratica, l’audio grezzo dei dataset può variare per forma, dtype, numero di canali e frequenza di campionamento. Se saltiamo questo passaggio, spesso incapperai in errori (dimensioni sbagliate), risultati scarsi (frequenza sbagliata) o spreco di memoria GPU (dtype errato).

Ecco cosa standardizzeremo:

• Forma: SAM Audio si aspetta audio nel formato [C, T] (canali per primi).
• Precisione: converti prima in float32 per un’elaborazione sicura, poi allinea il dtype del modello (FP16 su CUDA).
• Frequenza di campionamento: ricampiona alla frequenza richiesta dal modello (dal processor).
• Canali: converti in mono per semplificare la separazione e mantenere l’inferenza coerente.
• Device + dtype: sposta la forma d’onda su GPU e allo stesso dtype dei pesi del modello per evitare cast impliciti e overhead di memoria extra.

wav = torch.tensor(samples.data)

# Ensure [C, T]
if wav.ndim == 1:
    wav = wav.unsqueeze(0)  # [1, T]
elif wav.ndim == 2 and wav.shape[0] > wav.shape[1]:
    wav = wav.transpose(0, 1)  # [T, C] -> [C, T]

wav = wav.float()

orig_sr = int(samples.sample_rate)
target_sr = int(processor.audio_sampling_rate)

if orig_sr != target_sr:
    wav = torchaudio.functional.resample(wav, orig_sr, target_sr)

# Mono
wav = wav.mean(0, keepdim=True)  # [1, T]

# Move to device + match model dtype (FP16 on CUDA)
wav = wav.to(device=device, dtype=next(model.parameters()).dtype)

duration_s = wav.shape[-1] / target_sr
print(f"Resampled duration: {duration_s:.2f}s @ {target_sr} Hz")Offerto da

Se è tutto configurato correttamente, dovresti vedere un output simile a:

Resampled duration: 10.00s @ 48000 HzOfferto da

Conferma che (1) la lunghezza dell’audio è quella attesa e (2) la forma d’onda ora usa la frequenza di campionamento preferita dal modello.

6. Eseguire la separazione audio con SAM Audio

Ora arriva la parte divertente: separeremo un suono target dal mix audio originale. SAM Audio ti permette di farlo usando prompt naturali; in questo esempio estrarremo “un clacson che suona” da una clip che contiene rumore di traffico ed eventi di clacson.

Useremo due tipi di guida contemporaneamente:

• Prompt testuale (description): dice al modello cosa vogliamo (“A horn honking”).
• Ancori temporali (anchors): dicono al modello dove nel tempo si verifica il target (in secondi).

Questo rende la separazione molto più affidabile, soprattutto quando il mix è affollato o quando il suono target è breve.

Nel formato degli anchor:

• + significa includi questa regione temporale come evidenza positiva del suono target
• [6.3, 7.0] è la finestra temporale (inizio, fine) in secondi

description = "A horn honking"
anchors = [[["+", 6.3, 7.0]]]  # batch -> one sample -> one anchor

# (Optional) sanity-check anchors
assert 0 <= anchors[0][0][1] < anchors[0][0][2] <= duration_s + 1e-6, "Anchor out of range!"
inputs = processor(
    audios=[wav],
    descriptions=[description],
    anchors=anchors,
).to(device)

with torch.inference_mode():
    result = model.separate(inputs)
target_np = result.target[0].detach().float().cpu().numpy()
resid_np = result.residual[0].detach().float().cpu().numpy()
Audio(target_np, rate=processor.audio_sampling_rate)Offerto da

Quando funziona correttamente, l’output è davvero notevole: il target dovrebbe suonare come una traccia di clacson pulita con gran parte dello sfondo rimossa. Questa è l’idea chiave di SAM Audio: non ti servono stem perfette o editing manuale, guidi il modello con prompt intuitivi e lui isola il suono per te. Qui sotto puoi sentire come suona:

Ascoltare è la prova migliore, ma la forma d’onda rende facile vedere cosa è successo. 

plot_waveform(target_np, processor.audio_sampling_rate, title="Cleand Audio with only Horn")Offerto da

Nell’output separato, noterai tipicamente picchi distinti dove avviene il clacson, mentre il resto della forma d’onda rimane relativamente silenzioso.

SAM Audio restituisce anche una traccia residua, che è essenzialmente “il resto dell’audio” dopo la rimozione del target. 

plot_waveform(resid_np, processor.audio_sampling_rate, title="Residual Audio with no Horn")Offerto da

Qui vediamo solo rumore di traffico/sfondo, e nessun suono di clacson. 

7. Caricare un altro campione dal dataset

Proviamo un esempio più difficile e realistico. Questa volta sceglieremo una clip in cui una persona non anglofona parla al telefono mentre c’è un forte rumore di fondo (rumore di strada, ambiente, suoni sovrapposti). 

È proprio il tipo di situazione in cui la separazione audio diventa davvero utile: il parlato c’è, ma è difficile da comprendere perché il mix è confuso.

Per prima cosa, carica un nuovo campione e ascolta il mix grezzo:

samples_2 = dset["train"][45]["audio"].get_all_samples()
Audio(samples_2.data, rate=samples_2.sample_rate)Offerto da

Ora visualizza la forma d’onda. 

plot_waveform(samples_2.data, samples_2.sample_rate, title="Background Noise and a Man Talking")Offerto da

Vedrai un segnale denso e ad alta energia per gran parte della clip, che di solito indica forte rumore di fondo e audio sovrapposto:

Eseguiremo gli stessi passaggi di preprocessing visti prima: assicurare la forma [C, T], ricampionare alla frequenza richiesta dal processor, convertire in mono e spostare su GPU in FP16.

# Convert numpy → torch
wav = torch.tensor(samples_2.data)

# Ensure [C, T]
if wav.ndim == 1:
    wav = wav.unsqueeze(0)
elif wav.ndim == 2 and wav.shape[0] > wav.shape[1]:
    wav = wav.transpose(0, 1)

wav = wav.float()

orig_sr = int(samples.sample_rate)
target_sr = int(processor.audio_sampling_rate)

# Resample if needed
if orig_sr != target_sr:
    wav = torchaudio.functional.resample(wav, orig_sr, target_sr)

# Mono
wav = wav.mean(0, keepdim=True)

# Move to GPU + FP16
wav = wav.to(device=device, dtype=next(model.parameters()).dtype)

duration_s = wav.shape[-1] / target_sr
print(f"Duration: {duration_s:.2f}s @ {target_sr} Hz")
Offerto da

Dovresti vedere qualcosa del genere:

Duration: 10.00s @ 48000 HzOfferto da

Nel precedente esempio abbiamo aiutato il modello con un’ancora temporale e un prompt testuale. Qui useremo solo il prompt testuale, un ottimo modo per testare quanto bene il modello sappia generalizzare senza guida extra.

description = "A man speaking"

inputs = processor(
    audios=[wav],
    descriptions=[description],
).to(device)

with torch.inference_mode():
    result = model.separate(inputs)
target_np = result.target[0].detach().float().cpu().numpy()

plot_waveform(target_np, processor.audio_sampling_rate, title="Clean Audio with a Man Talking")Offerto da

Infine, traccia la forma d’onda del parlato separato. Rispetto al mix originale, la forma d’onda dovrebbe apparire più pulita e meno “affollata”, soprattutto nelle regioni dove prima dominava il rumore di fondo:

Se riscontri problemi nell’eseguire il codice sopra, fai riferimento al notebook DataLab linkato di seguito per un riferimento completo e funzionante e ulteriori indicazioni: Using SAM-Audio Locally — DataLab.

Casi d’uso di SAM Audio

SAM Audio è progettato per la comprensione e l’editing dell’audio nel mondo reale. Invece di affidarsi a strumenti specifici per il singolo task, utilizza prompt naturali per separare e isolare suoni tra parlato, musica e ambienti quotidiani. 

Queste funzionalità lo rendono utile in flussi di lavoro creativi, professionali e di ricerca in cui audio pulito e controllabile è importante.

• Pulizia di podcast e registrazioni vocali: migliora la chiarezza del parlato in podcast, interviste e registrazioni vocali separando lo speaker dal rumore di fondo e dai suoni ambientali.
• Produzione musicale ed estrazione degli stem: isola voci o singoli strumenti da tracce musicali mixate per remix, campionamento, mastering o sound design creativo.
• Post-produzione per film e video: rimuovi suoni di fondo indesiderati come traffico, vento o rumore della folla mantenendo intatti dialoghi ed effetti sonori importanti.
• Accessibilità e miglioramento dell’ascolto: potenzia il parlato in ambienti rumorosi per supportare strumenti di assistenza all’ascolto e applicazioni focalizzate su accessibilità e comunicazione più chiara.
• Ricerca audio e analisi del suono: segmenta registrazioni audio complesse del mondo reale per task di ricerca come rilevamento di eventi acustici, analisi forense e analisi delle scene sonore.

Considerazioni finali

A dire il vero, non c’è molta documentazione su come eseguire davvero SAM Audio in locale. Ho provato a farlo girare su Kaggle con GPU T4 ed è fallito. Ho anche provato con UV e a creare un ambiente virtuale Python, ma anche quello è fallito. 

Il problema principale che ho riscontrato di continuo erano i conflitti di dipendenze. Installare SAM Audio direttamente dal repository GitHub spesso sovrascrive librerie audio e PyTorch esistenti, causando il crash del kernel di Jupyter. 

Per questo consiglio vivamente di partire da un setup pulito usando Conda o un nuovo ambiente virtuale Python, installare prima PyTorch e CUDA, e poi aggiungere le librerie richieste. In questo tutorial, la configurazione è diventata stabile dopo aver risolto il crash reinstallando la versione corretta di torchcodec.

In questo tutorial, abbiamo eseguito con successo il modello base di SAM Audio su una RTX 3090 usando circa 14 GB di VRAM, un valore molto ragionevole per l’inferenza in locale. La velocità d’inferenza è elevata e la qualità della separazione audio è davvero impressionante. Puoi estendere questa configurazione anche al prompting basato su video, dove SAM Audio lavora insieme a SAM 3 per isolare l’audio in base a segnali visivi.

Per saperne di più su SAM 3, ti consiglio di dare un’occhiata al nostro tutorial su SAM 3.