Cara Menjalankan SAM Audio Secara Lokal

Anda mungkin sudah akrab dengan segmentasi gambar dan video, tetapi segmentasi audio masih jauh lebih jarang dieksplorasi. Ini merujuk pada kemampuan untuk memisahkan dan mengisolasi bunyi dalam aliran audio, seperti mengekstrak suara pembicara dari musik latar atau mengisolasi suara satu orang dalam rapat kelompok. Hingga baru-baru ini, tugas-tugas ini memerlukan alat khusus yang spesifik tugas dan cukup banyak upaya manual.

Dalam tutorial ini, kita akan mengeksplorasi SAM Audio, ekstensi audio dari Segment Anything Model. Kita akan menyiapkan lingkungan lokal, memasang dependensi yang diperlukan, memuat model, dan menjalankan inferensi pada GPU RTX 3090. 

Sepanjang proses, kita akan memvisualisasikan bagaimana SAM Audio dapat secara presisi mensegmentasi bagian spesifik dari sinyal audio dengan cara yang terasa jauh lebih intuitif dan sangat presisi dibanding pendekatan pemrosesan audio tradisional.

Apa itu SAM Audio?

SAM Audio adalah model multimodal terpadu pertama di kelasnya yang dirancang untuk membuat pemisahan audio menjadi seintuitif berinteraksi dengan suara itu sendiri. Terinspirasi oleh keberhasilan Segment Anything Model pada visi komputer, SAM Audio memungkinkan pengguna mengisolasi bunyi apa pun dari campuran audio yang kompleks menggunakan prompt natural, baik melalui teks, isyarat visual pada video, maupun dengan menandai rentang waktu. Pendekatan terpadu ini menggantikan alat audio yang terfragmentasi dan satu tujuan dengan satu sistem yang bekerja andal pada ucapan, musik, dan bunyi umum, bahkan pada skenario dunia nyata di alam bebas.

Sumber: facebookresearch/sam-audio

Inti dari SAM Audio adalah Perception Encoder Audiovisual (PE-AV), mesin bertenaga yang menyelaraskan apa yang dilihat dengan apa yang didengar dengan mengenkode sinyal audio dan visual secara bersama-sama dari waktu ke waktu. 

Dibangun di atas Perception Encoder open-source dari Meta, PE-AV menyediakan representasi kaya dan presisi temporal yang memungkinkan kinerja mutakhir dalam pemisahan audio multimodal. 

Bersama-sama, SAM Audio dan PE-AV membuka kemungkinan baru untuk media kreatif, aksesibilitas, dan pemahaman audio, membuat segmentasi audio kelas profesional menjadi lebih cepat, lebih mudah diakses, dan lebih mudah dikendalikan daripada sebelumnya.

Tutorial SAM Audio 

Sekarang saya akan memandu Anda cara menyiapkan dan menjalankan SAM Audio secara lokal. 

1. Penyiapan lingkungan

SAM Audio adalah model berpintu (gated), yang berarti Anda harus meminta akses sebelum dapat mengunduh dan menggunakannya secara lokal. Mulailah dengan mengunjungi halaman model Hugging Face di facebook/sam-audio-large dan lengkapi formulir permintaan akses. Persetujuan biasanya memakan waktu sekitar 10 menit, tetapi dalam beberapa kasus, akses mungkin ditolak tergantung lokasi Anda atau kebijakan lain yang diberlakukan oleh Meta.

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

Setelah akses diberikan, jalankan Jupyter Notebook lokal dan pasang pustaka SAM Audio langsung dari repositori resmi:

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

Masalah umum saat bekerja dengan SAM Audio adalah kernel Jupyter mogok atau restart secara tak terduga. Ini biasanya disebabkan oleh versi torchcodec yang tidak kompatibel. Untuk memperbaikinya, hapus versi yang ada dan pasang versi yang direkomendasikan secara eksplisit:

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

Untuk unduhan model dan dependensi yang lebih cepat, kita akan menggunakan hf_transfer: 

!pip install hf_transferDidukung oleh

Terakhir, masuk ke Hugging Face Hub menggunakan access token. Pastikan Anda telah membuat API token dari akun Hugging Face Anda dan menyimpannya sebagai variabel lingkungan (HF_TOKEN):

import os
from huggingface_hub import login

login(token=os.environ["HF_TOKEN"])Didukung oleh

2. Memuat Model SAM Audio (FP16 di CUDA)

Pada langkah ini, kita akan mengunduh dan memuat model dasar SAM Audio. Meskipun SAM Audio juga menyediakan varian besar, model dasar menawarkan kualitas pemisahan yang hampir sama sambil jauh lebih ringan pada memori GPU. 

Ini membuatnya jauh lebih cocok untuk eksperimen lokal, terutama pada GPU konsumen seperti RTX 3090.

Untuk menghindari error kehabisan memori (OOM), penting untuk memuat model dalam FP16 (presisi setengah) alih-alih FP32. 

RTX 3090 memiliki dukungan FP16 yang sangat baik, dan beralih ke presisi setengah hampir memangkas penggunaan VRAM menjadi setengahnya tanpa memengaruhi kualitas inferensi secara berarti.

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)Didukung oleh

Pada kali pertama Anda menjalankannya, pengunduhan mungkin memakan waktu. SAM Audio menarik beberapa komponen dan checkpoint yang bersama-sama membentuk seluruh pipeline segmentasi audio, termasuk perception encoder dan modul pemisahan generatif. Ini merupakan perilaku yang diharapkan dan hanya terjadi sekali, karena berkas-berkasnya di-cache secara lokal untuk menjalankan berikutnya.

Setelah model dimuat, merupakan praktik yang baik untuk memeriksa penggunaan memori GPU guna memastikan semuanya berjalan dalam batas:

!nvidia-smiDidukung oleh

Anda akan melihat bahwa model dasar SAM Audio menggunakan sekitar 14 GB VRAM, yang pas dengan nyaman pada RTX 3090. Ini menyisakan ruang yang cukup untuk inferensi dan eksperimen tanpa memicu masalah memori, menjadikan penyiapan stabil dan andal untuk tugas segmentasi audio lokal.

3. Memuat contoh sampel audio dari AudioCaps

Untuk menguji SAM Audio, kita memerlukan sampel audio realistis yang berisi beberapa sumber bunyi yang saling tumpang tindih. Untuk tutorial ini, kita akan menggunakan contoh dari AudioCaps, dataset tolok ukur yang banyak digunakan untuk pemahaman dan pelabelan audio. 

AudioCaps berisi klip audio pendek yang beragam, dikumpulkan dari lingkungan dunia nyata, sehingga ideal untuk mengevaluasi model pemisahan audio.

Kita memuat dataset langsung dari Hugging Face menggunakan pustaka datasets. Sampel audio disimpan dalam format Parquet dan mencakup data gelombang serta metadata seperti laju sampling.

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)Didukung oleh

Kode ini mengunduh satu pecahan dari himpunan uji AudioCaps dan mengekstrak satu klip audio untuk demonstrasi. Widget Audio memungkinkan Anda mendengarkan campuran mentah langsung di dalam notebook, yang berguna untuk memahami seberapa kompleks audio asli sebelum segmentasi. Berikut bunyinya:

4. Memvisualisasikan trek audio

Mendengarkan adalah cara tercepat untuk memahami campuran audio, tetapi memvisualisasikan gelombang membantu Anda melihat di mana sesuatu terjadi. 

Plot gelombang memudahkan untuk melihat momen dengan energi kuat (seperti klakson, tepuk tangan, atau teriakan), wilayah yang lebih tenang (jeda atau kebisingan latar), dan lonjakan mendadak yang sering kali berkaitan dengan peristiwa bunyi singkat. 

Ini menjadi sangat berguna saat kita mulai memisahkan bunyi, karena Anda dapat membandingkan campuran asli dengan keluaran hasil segmentasi dan dengan cepat memvalidasi apakah SAM Audio benar-benar mengekstrak wilayah yang tepat.

Di bawah ini adalah fungsi bantu sederhana yang memplot gelombang hingga durasi tertentu (agar plot tetap mudah dibaca). Fungsi ini mendukung audio mono dan stereo, dan secara otomatis memindahkan tensor ke CPU sehingga berjalan mulus di 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")Didukung oleh

Dalam contoh ini, Anda biasanya akan melihat gelombang yang ramai dan padat yang mewakili kebisingan latar yang terus-menerus (lalu lintas), dan puncak yang lebih tajam yang sering kali selaras dengan peristiwa bunyi singkat dan lebih keras (seperti klakson). 

5. Menyiapkan audio untuk inferensi

Sebelum kita dapat menjalankan SAM Audio, kita perlu memastikan gelombang input sesuai dengan yang diharapkan model. Dalam praktiknya, audio mentah dari dataset dapat bervariasi dalam bentuk, dtype, jumlah kanal, dan laju sampling. Jika kita melewatkan langkah ini, Anda sering kali akan menemui error (dimensi salah), mendapatkan hasil buruk (laju sampling salah), atau membuang memori GPU (dtype salah).

Berikut yang akan kita standarkan:

• Bentuk: SAM Audio mengharapkan audio dalam format [C, T] (kanal di depan).
• Presisi: Ubah ke float32 terlebih dahulu untuk pemrosesan yang aman, lalu samakan dengan dtype model (FP16 di CUDA).
• Laju sampling: Resample ke laju sampling yang diperlukan model (dari processor).
• Kanal: Ubah ke mono untuk menyederhanakan pemisahan dan menjaga konsistensi inferensi.
• Perangkat + dtype: Pindahkan gelombang ke GPU dan ke dtype yang sama dengan bobot model untuk menghindari casting implisit dan beban memori ekstra.

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")Didukung oleh

Jika semuanya sudah disiapkan dengan benar, Anda akan melihat keluaran seperti:

Resampled duration: 10.00s @ 48000 HzDidukung oleh

Ini mengonfirmasi (1) panjang audio sesuai yang diharapkan, dan (2) gelombang kini menggunakan laju sampling yang disukai model.

6. Menjalankan pemisahan audio dengan SAM Audio

Sekarang bagian yang menyenangkan: kita akan benar-benar memisahkan bunyi target dari campuran audio asli. SAM Audio memungkinkan Anda melakukannya dengan prompt natural, dan pada contoh ini, kita akan mengekstrak “klakson yang dibunyikan” dari klip yang berisi kebisingan lalu lintas dan peristiwa klakson.

Kita akan menggunakan dua jenis panduan sekaligus:

• Prompt teks (description): memberi tahu model apa yang kita inginkan (“Klakson yang dibunyikan”).
• Span anchors (anchors): memberi tahu model di mana dalam waktu target terjadi (dalam detik).

Ini membuat pemisahan jauh lebih andal, terutama saat campuran audio ramai atau ketika bunyi target singkat.

Dalam format anchors:

• + berarti sertakan wilayah waktu ini sebagai bukti positif dari bunyi target
• [6.3, 7.0] adalah jendela waktu (awal, akhir) dalam detik

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)Didukung oleh

Jika ini berjalan dengan benar, keluarannya benar-benar mengesankan: audio target semestinya terdengar seperti trek klakson yang bersih dengan sebagian besar latar belakang dihilangkan. Inilah gagasan utama SAM Audio: Anda tidak memerlukan stem yang sempurna atau penyuntingan manual, Anda cukup membimbing model dengan prompt yang intuitif, dan model akan mengisolasi bunyinya untuk Anda. Berikut bunyinya:

Mendengarkan adalah bukti terbaik, tetapi gelombang memudahkan untuk melihat apa yang terjadi. 

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

Pada keluaran yang telah dipisahkan, Anda biasanya akan melihat puncak yang jelas saat klakson terjadi, sementara bagian gelombang lainnya relatif lebih tenang.

SAM Audio juga mengembalikan trek residual, yang pada dasarnya adalah “sisa audio” setelah target dihilangkan. 

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

Di sini kita hanya melihat kebisingan lalu lintas/latar, tanpa bunyi klakson. 

7. Memuat sampel lain dari dataset

Mari coba contoh yang lebih sulit dan realistis. Kali ini, kita akan memilih klip di mana penutur non-Inggris sedang berbicara di telepon sementara terdapat kebisingan latar yang berat (kebisingan jalan, ambience, bunyi yang saling tumpang tindih). 

Inilah tepatnya situasi di mana pemisahan audio menjadi sangat berguna: ucapannya ada, tetapi sulit dipahami karena campurannya berantakan.

Pertama, muat sampel baru dan dengarkan campuran audio mentahnya:

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

Sekarang visualisasikan gelombangnya. 

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

Anda akan melihat sinyal yang padat dan berenergi tinggi di sebagian besar klip, yang biasanya menunjukkan kebisingan latar yang kuat dan audio yang saling tumpang tindih:

Kita akan menjalankan langkah prapemrosesan yang sama seperti sebelumnya: pastikan bentuk [C, T], resample ke laju sampling target dari processor, ubah ke mono, dan pindahkan ke GPU dalam 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")
Didukung oleh

Anda akan melihat sesuatu seperti:

Duration: 10.00s @ 48000 HzDidukung oleh

Pada contoh sebelumnya, kita membantu model dengan anchor rentang waktu dan prompt teks. Di sini, kita akan melakukan prompting hanya dengan teks, yang merupakan cara bagus untuk menguji seberapa baik model dapat menggeneralisasi tanpa panduan tambahan.

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")Didukung oleh

Terakhir, plot gelombang dari ucapan yang telah dipisahkan. Dibandingkan dengan campuran asli, gelombang seharusnya terlihat lebih bersih dan kurang “ramai,” terutama di wilayah yang sebelumnya didominasi kebisingan latar:

Jika Anda mengalami masalah saat menjalankan kode di atas, silakan merujuk ke notebook DataLab yang ditautkan di bawah ini untuk referensi lengkap yang berfungsi dan panduan tambahan: Menggunakan SAM-Audio Secara Lokal — DataLab.

Kasus Penggunaan SAM Audio

SAM Audio dirancang untuk pemahaman dan penyuntingan audio di dunia nyata. Alih-alih mengandalkan alat spesifik tugas, ia menggunakan prompt natural untuk memisahkan dan mengisolasi bunyi di seluruh ucapan, musik, dan lingkungan sehari-hari. 

Fitur-fitur ini membuatnya berguna di berbagai alur kerja kreatif, profesional, dan riset di mana audio yang bersih dan dapat dikendalikan itu penting.

• Pembersihan podcast dan rekaman suara: Tingkatkan kejernihan ucapan dalam podcast, wawancara, dan rekaman suara dengan memisahkan pembicara dari kebisingan latar dan bunyi ambient.
• Produksi musik dan ekstraksi stem: Isolasi vokal atau instrumen individu dari trek musik campuran untuk remix, sampling, mastering, atau desain bunyi kreatif.
• Pascaproduksi film dan video: Hilangkan bunyi latar yang tidak diinginkan seperti lalu lintas, angin, atau kerumunan sambil menjaga dialog dan efek suara penting tetap utuh.
• Aksesibilitas dan peningkatan pendengaran: Tingkatkan ucapan di lingkungan bising untuk mendukung alat bantu dengar dan aplikasi yang berfokus pada aksesibilitas dan komunikasi yang lebih jelas.
• Riset audio dan analisis bunyi: Segmentasikan rekaman audio dunia nyata yang kompleks untuk tugas riset seperti deteksi peristiwa akustik, forensik audio, dan analisis skena bunyi.

Penutup

Sejujurnya, tidak banyak informasi di luar sana tentang cara sebenarnya menjalankan SAM Audio secara lokal. Saya mencoba menjalankannya di Kaggle dengan GPU T4, dan gagal. Saya juga mencoba menggunakan UV dan menyiapkan lingkungan Python virtual, tetapi itu juga gagal. 

Masalah utama yang terus saya temui adalah konflik dependensi. Memasang SAM Audio langsung dari repositori GitHub sering kali menimpa pustaka audio dan PyTorch yang ada, yang menyebabkan kernel Jupyter mogok. 

Inilah mengapa saya sangat merekomendasikan memulai dari penyiapan yang bersih menggunakan Conda atau lingkungan virtual Python yang baru, memasang PyTorch dan CUDA terlebih dahulu, lalu menambahkan pustaka yang diperlukan. Dalam tutorial ini, penyiapan menjadi stabil setelah saya memperbaiki crash dengan memasang ulang versi torchcodec yang benar.

Dalam tutorial ini, kita berhasil menjalankan model dasar SAM Audio pada RTX 3090 dengan penggunaan sekitar 14 GB VRAM, yang sangat wajar untuk inferensi lokal. Kecepatan inferensi cepat, dan kualitas pemisahan audio benar-benar mengesankan. Anda juga dapat memperluas penyiapan ini ke prompting berbasis video, di mana SAM Audio bekerja bersama SAM 3 untuk mengisolasi audio berdasarkan isyarat visual.

Untuk mempelajari lebih lanjut tentang SAM 3, saya sarankan melihat Tutorial SAM 3 berikutnya.