SAM Audio lokaal draaien: zo doe je dat

Je kent beeld- en videosegmentatie misschien al, maar audiosignalering is een veel minder verkend idee. Het verwijst naar het vermogen om geluiden binnen een audiostream te scheiden en te isoleren, zoals het extraheren van een sprekende stem uit achtergrondmuziek of het isoleren van iemands stem in een groepsvergadering. Tot voor kort vereisten deze taken gespecialiseerde, taakspecifieke tools en behoorlijk wat handmatig werk.

In deze tutorial verkennen we SAM Audio, de audio-extensie van het Segment Anything Model. We zetten een lokale omgeving op, installeren de vereiste afhankelijkheden, laden het model en voeren inferentie uit op een RTX 3090-GPU. 

Onderweg visualiseren we hoe SAM Audio specifieke delen van een audiosignaal nauwkeurig kan segmenteren op een manier die veel intuïtiever en klinisch preciezer aanvoelt dan traditionele audiobewerking.

Wat is SAM Audio?

SAM Audio is een baanbrekend, uniform multimodaal model dat audioscheiding zo intuïtief wil maken als met geluid zelf interacteren. Geïnspireerd door het succes van het Segment Anything Model voor visie, stelt SAM Audio gebruikers in staat om elk geluid uit complexe audiomixen te isoleren met natuurlijke prompts, via tekst, visuele aanwijzingen in video of door tijdspannes te markeren. Deze uniforme aanpak vervangt gefragmenteerde, enkelvoudige audiotools door één systeem dat betrouwbaar werkt voor spraak, muziek en algemene geluiden, zelfs in echte, ongestructureerde situaties.

Bron: facebookresearch/sam-audio

De kern van SAM Audio is Perception Encoder Audiovisual (PE-AV), een krachtige engine die wat je ziet uitlijnt met wat je hoort door audio- en visuele signalen in de tijd gezamenlijk te encoderen. 

Gebouwd op Meta’s open-source Perception Encoder, levert PE-AV rijke, temporeel precieze representaties die state-of-the-art prestaties mogelijk maken in multimodale audioscheiding. 

Samen openen SAM Audio en PE-AV nieuwe mogelijkheden voor creatieve media, toegankelijkheid en audiobegrip, waardoor professionele audiosignalering sneller, toegankelijker en beter stuurbaar wordt dan ooit.

SAM Audio-tutorial 

Ik laat je nu zien hoe je SAM Audio lokaal aan de praat krijgt. 

1. Omgevingsinstelling

SAM Audio is een afgeschermd model, wat betekent dat je toegang moet aanvragen voordat je het lokaal kunt downloaden en gebruiken. Begin op de Hugging Face-modelpagina facebook/sam-audio-large en vul het toegangsformulier in. Goedkeuring duurt doorgaans ongeveer 10 minuten, maar in sommige gevallen kan toegang worden geweigerd, afhankelijk van je locatie of andere door Meta gehanteerde beleidsregels.

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

Zodra je toegang hebt, start je lokaal een Jupyter Notebook en installeer je de SAM Audio-bibliotheek rechtstreeks vanuit de officiële repository:

!pip install -q git+https://github.com/facebookresearch/sam-audio.gitMogelijk gemaakt door

Een veelvoorkomend probleem bij SAM Audio is dat de Jupyter-kernel crasht of onverwacht opnieuw start. Dit wordt meestal veroorzaakt door een incompatibele versie van torchcodec. Los dit op door de bestaande versie te verwijderen en expliciet de aanbevolen versie te installeren:

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

Voor snellere downloads van model en afhankelijkheden gebruiken we hf_transfer: 

!pip install hf_transferMogelijk gemaakt door

Log ten slotte in op de Hugging Face Hub met een toegangstoken. Zorg dat je een API-token hebt gegenereerd in je Hugging Face-account en dit hebt opgeslagen als omgevingsvariabele (HF_TOKEN):

import os
from huggingface_hub import login

login(token=os.environ["HF_TOKEN"])Mogelijk gemaakt door

2. Laad het SAM Audio-model (FP16 op CUDA)

In deze stap downloaden en laden we het SAM Audio-basismodel. Hoewel SAM Audio ook een large-variant biedt, levert het basismodel vrijwel dezelfde scheidingskwaliteit terwijl het aanzienlijk lichter is op het GPU-geheugen. 

Dat maakt het veel geschikter voor lokale experimenten, vooral op consumentengpu’s zoals de RTX 3090.

Om out-of-memory (OOM)-fouten te voorkomen, is het belangrijk om het model te laden in FP16 (half precision) in plaats van FP32. 

De RTX 3090 heeft uitstekende FP16-ondersteuning, en overschakelen naar half precision halveert de VRAM-voetafdruk bijna zonder merkbaar kwaliteitsverlies bij inferentie.

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)Mogelijk gemaakt door

De eerste keer kan het downloaden even duren. SAM Audio haalt meerdere componenten en checkpoints op die samen de volledige audiosignalering-pijplijn vormen, inclusief de perception encoder en generatieve scheidingsmodules. Dit is verwacht gedrag en gebeurt slechts één keer, omdat de bestanden lokaal worden gecachet voor toekomstige runs.

Nadat het model is geladen, is het goed om het GPU-geheugengebruik te controleren om zeker te zijn dat alles binnen de perken draait:

!nvidia-smiMogelijk gemaakt door

Je zou moeten zien dat het SAM Audio-basismodel ongeveer 14 GB VRAM gebruikt, wat ruim past op een RTX 3090. Dit laat genoeg ruimte over voor inferentie en experimenten zonder geheugenproblemen, waardoor de setup stabiel en betrouwbaar is voor lokale audiosignaleringstaken.

3. Laad een voorbeeldaudio uit AudioCaps

Om SAM Audio te testen hebben we een realistisch audiovoorbeeld nodig met meerdere overlappende geluidsbronnen. Voor deze tutorial gebruiken we een voorbeeld uit AudioCaps, een veelgebruikte benchmarkdataset voor audiobegrip en -beschrijving. 

AudioCaps bevat korte, diverse audioclips uit realistische omgevingen, ideaal om audioscheidingsmodellen te evalueren.

We laden de dataset rechtstreeks vanaf Hugging Face met de datasets-bibliotheek. De sampleaudio staat in Parquet-formaat en bevat zowel golfvormdata als metadata zoals de samplerate.

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)Mogelijk gemaakt door

Deze code downloadt één shard van de AudioCaps-testset en haalt één audioclip op ter demonstratie. De Audio-widget laat je de ruwe mix direct in het notebook beluisteren, handig om te begrijpen hoe complex de originele audio is vóór segmentatie. Zo klinkt het:

4. De audiotrack visualiseren

Luisteren is de snelste manier om een audiomix te begrijpen, maar de golfvorm visualiseren helpt je te zien waar dingen gebeuren. 

Een golfvormplot maakt het makkelijker om momenten met veel energie te spotten (zoals een claxon, klap of schreeuw), stillere stukken (pauzes of ruis op de achtergrond) en plotselinge pieken die vaak overeenkomen met korte geluidsgebeurtenissen. 

Dit is vooral handig zodra we geluiden gaan scheiden, omdat je de oorspronkelijke mix kunt vergelijken met de gesegmenteerde output en snel kunt valideren of SAM Audio daadwerkelijk de juiste regio heeft geëxtraheerd.

Hieronder staat een eenvoudige helperfunctie die de golfvorm plot tot een vaste duur (zodat de plot leesbaar blijft). Ondersteunt zowel mono als stereo en verplaatst tensors automatisch naar de CPU, zodat het soepel werkt in een 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")Mogelijk gemaakt door

In dit voorbeeld zie je meestal een drukke, dichte golfvorm die continue achtergrondruis (verkeer) weergeeft, en scherpere pieken die vaak overeenkomen met korte, luidere gebeurtenissen (zoals een claxon). 

5. Audio voorbereiden voor inferentie

Voordat we SAM Audio kunnen draaien, moeten we zorgen dat de invoergolfvorm overeenkomt met wat het model verwacht. In de praktijk kan ruwe audio uit datasets variëren in vorm, dtype, aantal kanalen en samplerate. Als we deze stap overslaan, loop je vaak tegen fouten aan (verkeerde dimensies), krijg je matige resultaten (verkeerde samplerate) of verspil je GPU-geheugen (verkeerde dtype).

Dit gaan we standaardiseren:

• Vorm: SAM Audio verwacht audio in [C, T]-formaat (channels first).
• Precisie: Converteer eerst naar float32 voor veilige verwerking, en match daarna de model-dtype (FP16 op CUDA).
• Samplerate: Resample naar de vereiste samplerate van het model (afkomstig van de processor).
• Kanalen: Converteer naar mono om scheiding te vereenvoudigen en inferentie consistent te houden.
• Apparaat + dtype: Verplaats de golfvorm naar de GPU en naar dezelfde dtype als de modelgewichten om impliciet casten en extra geheugenkosten te vermijden.

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")Mogelijk gemaakt door

Als alles goed is ingesteld, zie je een output als:

Resampled duration: 10.00s @ 48000 HzMogelijk gemaakt door

Dat bevestigt (1) dat de audiolengte is wat we verwachten, en (2) dat de golfvorm nu de voorkeurs-samplerate van het model gebruikt.

6. Audioscheiding uitvoeren met SAM Audio

Nu komt het leuke gedeelte: we gaan daadwerkelijk een doelluid scheiden van de oorspronkelijke audiomix. Met SAM Audio kan dit met natuurlijke prompts en in dit voorbeeld extraheren we “een claxon die toetert” uit een clip met verkeersruis en claxongebeurtenissen.

We gebruiken twee soorten sturing tegelijk:

• Tekstprompt (description): vertelt het model wat we willen (“A horn honking”).
• Span-ankers (anchors): vertellen het model waar in de tijd het doelgeluid zich bevindt (in seconden).

Dit maakt scheiding veel robuuster, vooral wanneer de audiomix druk is of wanneer het doelluid kort is.

In het anchor-formaat:

• + betekent neem deze tijdsregio op als positief bewijs voor het doelluid
• [6.3, 7.0] is het tijdsvenster (start, einde) in seconden

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)Mogelijk gemaakt door

Als dit goed werkt, is de output echt indrukwekkend: de doelaudio zou moeten klinken als een schone claxontrack met het meeste achtergrondgeluid verwijderd. Dit is de kern van SAM Audio: je hebt geen perfecte stems of handmatige editing nodig, je stuurt het model met intuïtieve prompts en het isoleert het geluid voor je. Zo klinkt het hieronder:

Luisteren is het beste bewijs, maar de golfvorm laat snel zien wat er gebeurde. 

plot_waveform(target_np, processor.audio_sampling_rate, title="Cleand Audio with only Horn")Mogelijk gemaakt door

In de gescheiden output zie je doorgaans duidelijke pieken waar de claxon voorkomt, terwijl de rest van de golfvorm relatief stil blijft.

SAM Audio geeft ook een residu-track terug, feitelijk “de rest van de audio” nadat het doel is verwijderd. 

plot_waveform(resid_np, processor.audio_sampling_rate, title="Residual Audio with no Horn")Mogelijk gemaakt door

Hier horen we alleen verkeer/achtergrondgeluid en geen claxon. 

7. Nog een sample uit de dataset laden

Laten we een moeilijker, realistischer voorbeeld proberen. Deze keer kiezen we een clip waarin een niet-Engelssprekende persoon telefoneert terwijl er veel achtergrondlawaai is (straatlawaai, ambiance, overlappende geluiden). 

Dit is precies het soort situatie waarin audioscheiding echt nuttig wordt: de spraak is aanwezig, maar lastig te verstaan omdat de mix rommelig is.

Laad eerst een nieuwe sample en luister naar de ruwe audiomix:

samples_2 = dset["train"][45]["audio"].get_all_samples()
Audio(samples_2.data, rate=samples_2.sample_rate)Mogelijk gemaakt door

Visualiseer nu de golfvorm. 

plot_waveform(samples_2.data, samples_2.sample_rate, title="Background Noise and a Man Talking")Mogelijk gemaakt door

Je ziet een dichte, energievolle signalering door het grootste deel van de clip, wat meestal wijst op sterk achtergrondlawaai en overlappende audio:

We voeren dezelfde preprocessingstappen uit als eerder: zorg voor [C, T]-vorm, resample naar de doelsamplerate van de processor, converteer naar mono en verplaats naar de 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")
Mogelijk gemaakt door

Je ziet iets als:

Duration: 10.00s @ 48000 HzMogelijk gemaakt door

In het vorige voorbeeld hielpen we het model met een tijdsanker en tekstprompt. Hier doen we alleen een tekstprompt, een prima manier om te testen hoe goed het model generaliseert zonder extra sturing.

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")Mogelijk gemaakt door

Plot ten slotte de golfvorm van de gescheiden spraak. Vergeleken met de oorspronkelijke mix zou de golfvorm schoner en minder “druk” moeten ogen, vooral in stukken waar achtergrondgeluid eerder overheerste:

Als je problemen tegenkomt bij het uitvoeren van de bovenstaande code, raadpleeg dan de DataLab-notebook via onderstaande link voor een complete, werkende referentie en extra begeleiding: SAM-Audio lokaal gebruiken — DataLab.

Use-cases van SAM Audio

SAM Audio is ontworpen voor realistische audiobegrip en -bewerking. In plaats van te leunen op taakspecifieke tools, gebruikt het natuurlijke prompts om geluiden te scheiden en te isoleren in spraak, muziek en alledaagse omgevingen. 

Deze eigenschappen maken het nuttig in creatieve, professionele en onderzoeksworkflows waar schone en stuurbare audio belangrijk is.

• Opschonen van podcasts en stemopnames: Verbeter de verstaanbaarheid van spraak in podcasts, interviews en stemopnames door de spreker te scheiden van achtergrondruis en omgevingsgeluiden.
• Muziekproductie en stemextractie: Isoleer vocals of individuele instrumenten uit gemixte muziektracks voor remixen, sampling, mastering of creatieve sounddesign.
• Film- en videopostproductie: Verwijder ongewenste achtergrondgeluiden zoals verkeer, wind of publiek, terwijl dialoog en belangrijke geluidseffecten intact blijven.
• Toegankelijkheid en gehoorondersteuning: Versterk spraak in rumoerige omgevingen ter ondersteuning van gehoorhulpmiddelen en applicaties gericht op toegankelijkheid en helderdere communicatie.
• Audio-onderzoek en geluidsanalyse: Segmenteer complexe, realistische audio-opnames voor onderzoekstaken zoals akoestische gebeurtenisdetectie, audioforensica en soundscape-analyse.

Tot slot

Eerlijk gezegd is er niet veel informatie beschikbaar over hoe je SAM Audio lokaal daadwerkelijk draait. Ik probeerde het op Kaggle met T4-GPU’s en dat mislukte. Ik probeerde ook UV en een virtuele Python-omgeving op te zetten, maar ook dat faalde. 

Het belangrijkste probleem waar ik telkens tegenaan liep, waren afhankelijkheidsconflicten. Installeren van SAM Audio rechtstreeks vanuit de GitHub-repository overschrijft vaak bestaande audio- en PyTorch-bibliotheken, waardoor de Jupyter-kernel crasht. 

Daarom raad ik sterk aan te beginnen met een schone setup met Conda of een verse virtuele Python-omgeving, eerst PyTorch en CUDA te installeren en daarna de vereiste libraries toe te voegen. In deze tutorial werd de setup stabiel zodra ik de crash oploste door de juiste versie van torchcodec opnieuw te installeren.

In deze tutorial hebben we het SAM Audio-basismodel succesvol gedraaid op een RTX 3090 met ongeveer 14 GB VRAM, wat heel redelijk is voor lokale inferentie. De inferentiesnelheid is hoog en de kwaliteit van audioscheiding is echt indrukwekkend. Je kunt deze setup ook uitbreiden naar videogeoriënteerde prompts, waarbij SAM Audio samenwerkt met SAM 3 om audio te isoleren op basis van visuele aanwijzingen.

Wil je meer weten over SAM 3? Bekijk dan onze SAM 3-tutorial.