SAM Audio को लोकल रूप से कैसे चलाएँ

आप छवि और वीडियो सेगमेंटेशन से पहले से परिचित हो सकते हैं, लेकिन ऑडियो सेगमेंटेशन अपेक्षाकृत कम खोजा गया विचार है। इसका अर्थ ऑडियो स्ट्रीम के भीतर ध्वनियों को अलग करना और पृथक करना है—जैसे बैकग्राउंड म्यूजिक से बोलती हुई आवाज़ निकालना या समूह बैठक में किसी एक व्यक्ति की आवाज़ अलग करना। हाल तक, इन कार्यों के लिए विशेष, कार्य-विशिष्ट टूल और काफी मैनुअल प्रयास की आवश्यकता होती थी।

इस ट्यूटोरियल में, हम SAM Audio का अन्वेषण करेंगे, जो Segment Anything Model का ऑडियो एक्सटेंशन है। हम एक लोकल वातावरण सेट करेंगे, आवश्यक निर्भरताएँ इंस्टॉल करेंगे, मॉडल लोड करेंगे, और RTX 3090 GPU पर इन्फरेंस चलाएँगे। 

इसी दौरान, हम यह भी विज़ुअलाइज़ करेंगे कि SAM Audio किस तरह पारंपरिक ऑडियो प्रोसेसिंग तरीकों की तुलना में अधिक सहज और क्लिनिकल सटीकता के साथ ऑडियो सिग्नल के विशिष्ट हिस्सों को सटीक रूप से सेगमेंट कर सकता है।

SAM Audio क्या है?

SAM Audio अपनी तरह का पहला एकीकृत मल्टीमॉडल मॉडल है, जिसे ऑडियो सेपरेशन को उतना ही सहज बनाने के लिए डिज़ाइन किया गया है जितना कि स्वयं ध्वनि के साथ इंटरैक्ट करना। विज़न में Segment Anything Model की सफलता से प्रेरित, SAM Audio उपयोगकर्ताओं को टेक्स्ट, वीडियो में दृश्य संकेतों या समय-अंतराल को चिह्नित करके—प्राकृतिक संकेतों का उपयोग करते हुए—जटिल ऑडियो मिश्रणों से किसी भी ध्वनि को अलग करने देता है। यह एकीकृत दृष्टिकोण विखंडित, एक-उद्देश्यीय ऑडियो टूल्स को एक ऐसे सिस्टम से बदल देता है जो भाषण, संगीत और सामान्य ध्वनियों में, वास्तविक दुनिया के परिदृश्यों में भी, भरोसेमंद रूप से काम करता है।

स्रोत: facebookresearch/sam-audio

SAM Audio के केंद्र में है Perception Encoder Audiovisual (PE-AV), एक शक्तिशाली इंजन जो समय के साथ ऑडियो और विज़ुअल संकेतों को संयुक्त रूप से एन्कोड करके जो देखा जाता है और जो सुना जाता है, उनके बीच संरेखण करता है। 

Meta के ओपन-सोर्स Perception Encoder पर आधारित, PE-AV समृद्ध, समय-सटीक अभ्यावेदन प्रदान करता है जो मल्टीमॉडल ऑडियो सेपरेशन में अत्याधुनिक प्रदर्शन सक्षम करते हैं। 

साथ मिलकर, SAM Audio और PE-AV रचनात्मक मीडिया, सुलभता, और ऑडियो समझ के लिए नए अवसर खोलते हैं, जिससे प्रोफेशनल-ग्रेड ऑडियो सेगमेंटेशन पहले की तुलना में तेज़, अधिक सुलभ और नियंत्रण में आसान हो जाता है।

SAM Audio ट्यूटोरियल 

अब मैं आपको बताऊँगा कि SAM Audio को लोकल रूप से कैसे सेटअप और उपयोग करना है। 

1. वातावरण सेटअप

SAM Audio एक गेटेड मॉडल है, यानी आप इसे लोकल रूप से डाउनलोड और उपयोग करने से पहले एक्सेस का अनुरोध करना होगा। शुरुआत करें Hugging Face के मॉडल पेज पर जाकर: facebook/sam-audio-large और एक्सेस अनुरोध फॉर्म पूरा करें। स्वीकृति आमतौर पर लगभग 10 मिनट लेती है, लेकिन कुछ मामलों में, आपके स्थान या Meta द्वारा लागू अन्य नीतियों के आधार पर एक्सेस से इनकार भी किया जा सकता है।

स्रोत: facebook/sam-audio-large · Hugging Face

एक्सेस मिल जाने के बाद, एक लोकल Jupyter Notebook लॉन्च करें और आधिकारिक रिपोजिटरी से सीधे SAM Audio लाइब्रेरी इंस्टॉल करें:

!pip install -q git+https://github.com/facebookresearch/sam-audio.gitसंचालित द्वारा

SAM Audio के साथ काम करते समय एक सामान्य समस्या Jupyter कर्नेल का क्रैश होना या अनपेक्षित रूप से रीस्टार्ट होना है। यह आमतौर पर असंगत torchcodec संस्करण के कारण होता है। इसे ठीक करने के लिए, मौजूदा संस्करण अनइंस्टॉल करें और अनुशंसित संस्करण को स्पष्ट रूप से इंस्टॉल करें:

!pip uninstall -y torchcodec
!pip install --no-cache-dir "torchcodec==0.7.0" -f https://download.pytorch.org/whl/torchcodec/संचालित द्वारा

मॉडल और निर्भरताओं को तेज़ी से डाउनलोड करने के लिए, हम hf_transfer का उपयोग करेंगे: 

!pip install hf_transferसंचालित द्वारा

अंत में, एक एक्सेस टोकन का उपयोग करके Hugging Face Hub में लॉग इन करें। सुनिश्चित करें कि आपने अपने Hugging Face खाते से एक API टोकन जनरेट किया है और उसे एक environment variable (HF_TOKEN) के रूप में सहेजा है:

import os
from huggingface_hub import login

login(token=os.environ["HF_TOKEN"])संचालित द्वारा

2. SAM Audio मॉडल लोड करें (CUDA पर FP16)

इस चरण में, हम SAM Audio बेस मॉडल डाउनलोड और लोड करेंगे। हालाँकि SAM Audio एक बड़े वैरिएंट के साथ भी आता है, बेस मॉडल लगभग समान सेपरेशन गुणवत्ता प्रदान करता है और GPU मेमोरी पर काफी हल्का रहता है। 

यह इसे लोकल प्रयोगों के लिए, खासकर RTX 3090 जैसी कंज्यूमर GPUs पर, कहीं बेहतर विकल्प बनाता है।

आउट-ऑफ-मेमोरी (OOM) त्रुटियों से बचने के लिए, मॉडल को FP16 (हाफ प्रिसीजन) में लोड करना महत्वपूर्ण है, न कि FP32 में। 

RTX 3090 में FP16 का उत्कृष्ट समर्थन है, और हाफ प्रिसीजन में स्विच करने से VRAM उपयोग लगभग आधा हो जाता है, वह भी इन्फरेंस गुणवत्ता पर कोई स्पष्ट प्रभाव डाले बिना।

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)संचालित द्वारा

पहली बार चलाने पर डाउनलोड में समय लग सकता है। SAM Audio कई घटक और चेकपॉइंट्स खींचता है जो मिलकर पूरी ऑडियो सेगमेंटेशन पाइपलाइन बनाते हैं, जिसमें परसेप्शन एन्कोडर और जेनरेटिव सेपरेशन मॉड्यूल शामिल हैं। यह अपेक्षित व्यवहार है और केवल एक बार होता है, क्योंकि फ़ाइलें आगे के रन के लिए लोकली कैश हो जाती हैं।

मॉडल लोड हो जाने के बाद, यह सुनिश्चित करने के लिए कि सब कुछ लिमिट्स के भीतर चल रहा है, GPU मेमोरी उपयोग की जाँच करना अच्छा अभ्यास है:

!nvidia-smiसंचालित द्वारा

आप देखेंगे कि SAM Audio बेस मॉडल लगभग 14 GB VRAM का उपयोग करता है, जो RTX 3090 पर आसानी से फिट बैठता है। इससे इन्फरेंस और प्रयोग के लिए पर्याप्त हेडरूम बचता है, बिना मेमोरी समस्याएँ ट्रिगर किए, जिससे लोकल ऑडियो सेगमेंटेशन कार्यों के लिए सेटअप स्थिर और विश्वसनीय बनता है।

3. AudioCaps से एक उदाहरण ऑडियो सैंपल लोड करें

SAM Audio का परीक्षण करने के लिए, हमें एक यथार्थवादी ऑडियो सैंपल चाहिए जिसमें कई ओवरलैपिंग साउंड सोर्स हों। इस ट्यूटोरियल के लिए, हम AudioCaps से एक उदाहरण का उपयोग करेंगे, जो ऑडियो समझ और कैप्शनिंग के लिए व्यापक रूप से उपयोग किया जाने वाला बेंचमार्क डेटासेट है। 

AudioCaps में वास्तविक दुनिया के वातावरण से एकत्रित छोटी, विविध ऑडियो क्लिप्स शामिल हैं, जो ऑडियो सेपरेशन मॉडलों के मूल्यांकन के लिए आदर्श हैं।

हम datasets लाइब्रेरी का उपयोग करके Hugging Face से सीधे डेटासेट लोड करते हैं। सैंपल ऑडियो Parquet फॉर्मेट में संग्रहीत है और उसमें वेवफॉर्म डेटा के साथ-साथ सैंपलिंग रेट जैसी मेटाडेटा भी शामिल है।

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)संचालित द्वारा

यह कोड AudioCaps टेस्ट सेट के एक शार्ड को डाउनलोड करता है और प्रदर्शन के लिए एक ऑडियो क्लिप निकालता है। Audio विजेट आपको सीधे नोटबुक के अंदर कच्चा मिश्रण सुनने देता है, जो सेगमेंटेशन से पहले मूल ऑडियो कितना जटिल है, यह समझने में सहायक होता है। यह इस तरह सुनाई देता है:

4. ऑडियो ट्रैक का विज़ुअलाइज़ेशन

सुनना किसी ऑडियो मिश्रण को समझने का सबसे तेज़ तरीका है, लेकिन वेवफॉर्म का विज़ुअलाइज़ेशन आपको यह देखने में मदद करता है कि क्या कब होता है। 

वेवफॉर्म प्लॉट से उच्च ऊर्जा वाले पल (जैसे हॉर्न, ताली, या चिल्लाहट), शांत हिस्से (ठहराव या बैकग्राउंड नॉइज़), और अचानक स्पाइक्स जो अक्सर छोटी ध्वनि घटनाओं से मेल खाते हैं, को पहचानना आसान हो जाता है। 

यह तब विशेष रूप से उपयोगी हो जाता है जब हम ध्वनियों को अलग करना शुरू करते हैं, क्योंकि आप मूल मिश्रण की तुलना सेगमेंटेड आउटपुट से कर सकते हैं और जल्दी से सत्यापित कर सकते हैं कि SAM Audio ने वास्तव में सही क्षेत्र निकाला या नहीं।

नीचे एक सरल हेल्पर फ़ंक्शन है जो फिक्स्ड अवधि तक का वेवफॉर्म प्लॉट करता है (ताकि प्लॉट पठनीय रहे)। यह मोनो और स्टीरियो दोनों ऑडियो को सपोर्ट करता है और टेन्सर्स को स्वतः CPU पर ले आता है, जिससे यह नोटबुक में सुचारु रूप से काम करता है।

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")संचालित द्वारा

इस उदाहरण में, आप आमतौर पर एक व्यस्त, घना वेवफॉर्म देखेंगे जो निरंतर बैकग्राउंड नॉइज़ (ट्रैफिक) को दर्शाता है, और तेज़ शिखर जो अक्सर छोटी, ज़्यादा जोरदार घटनाओं (जैसे हॉर्न) से मेल खाते हैं। 

5. इन्फरेंस के लिए ऑडियो तैयार करें

SAM Audio चलाने से पहले, हमें सुनिश्चित करना होगा कि इनपुट वेवफॉर्म मॉडल की अपेक्षा के अनुरूप हो। व्यवहार में, डेटासेट्स से कच्चा ऑडियो आकार, dtype, चैनलों की संख्या और सैंपल रेट में भिन्न हो सकता है। यदि हम यह चरण छोड़ दें, तो अक्सर त्रुटियाँ (गलत डायमेंशंस), खराब परिणाम (गलत सैंपल रेट), या GPU मेमोरी की बर्बादी (गलत dtype) देखने को मिलती है।

हम निम्न बातों को मानकीकृत करेंगे:

• आकार: SAM Audio को [C, T] फ़ॉर्मेट (चैनल्स फ़र्स्ट) में ऑडियो चाहिए।
• प्रिसीजन: सुरक्षित प्रोसेसिंग के लिए पहले float32 में कन्वर्ट करें, फिर मॉडल dtype (CUDA पर FP16) से मिलाएँ।
• सैंपल रेट: प्रोसेसर द्वारा आवश्यक सैंपलिंग रेट पर रिसैंपल करें।
• चैनल्स: सेपरेशन को सरल बनाने और इन्फरेंस को सुसंगत रखने के लिए मोनो में कन्वर्ट करें।
• डिवाइस + dtype: वेवफॉर्म को GPU पर ले जाएँ और मॉडल वेट्स के समान dtype पर सेट करें ताकि इम्प्लिसिट कास्टिंग और अतिरिक्त मेमोरी ओवरहेड से बचा जा सके।

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")संचालित द्वारा

यदि सब कुछ सही ढंग से सेटअप है, तो आपको ऐसा आउटपुट दिखाई देगा:

Resampled duration: 10.00s @ 48000 Hzसंचालित द्वारा

यह पुष्टि करता है कि (1) ऑडियो की लंबाई अपेक्षित है, और (2) वेवफॉर्म अब मॉडल के पसंदीदा सैंपलिंग रेट का उपयोग कर रहा है।

6. SAM Audio के साथ ऑडियो सेपरेशन चलाएँ

अब आता है मज़ेदार हिस्सा: हम वास्तव में मूल ऑडियो मिश्रण से लक्षित ध्वनि को अलग करेंगे। SAM Audio आपको प्राकृतिक संकेतों का उपयोग करके यह करने देता है, और इस उदाहरण में, हम ट्रैफ़िक शोर और हॉर्न घटनाओं वाले क्लिप से “a horn honking” निकालेंगे।

हम एक साथ दो प्रकार के मार्गदर्शन का उपयोग करेंगे:

• टेक्स्ट प्रॉम्प्ट (description): मॉडल को बताते हैं कि हमें क्या चाहिए (“A horn honking”).
• स्पैन एंकर्स (anchors): मॉडल को बताते हैं कि लक्षित ध्वनि समय में कहाँ आती है (सेकंड में)।

यह सेपरेशन को काफी अधिक विश्वसनीय बनाता है, खासकर जब ऑडियो मिश्रण व्यस्त हो या जब लक्षित ध्वनि संक्षिप्त हो।

एंकर्स फ़ॉर्मेट में:

• + का अर्थ है इस समय-क्षेत्र को लक्षित ध्वनि के सकारात्मक साक्ष्य के रूप में शामिल करें
• [6.3, 7.0] समय-विंडो (आरंभ, अंत) सेकंड में है

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)संचालित द्वारा

जब यह सही ढंग से काम करता है, तो आउटपुट वास्तव में प्रभावशाली होता है: लक्षित ऑडियो एक साफ़ हॉर्न ट्रैक जैसा सुनाई देना चाहिए, जिसमें अधिकांश बैकग्राउंड हटा दिया गया हो। यही SAM Audio के पीछे का मूल विचार है: आपको परफेक्ट स्टेम्स या मैनुअल एडिटिंग की ज़रूरत नहीं—आप सहज संकेतों से मॉडल को मार्गदर्शन देते हैं, और यह आपके लिए ध्वनि को अलग कर देता है। नीचे यह इस तरह सुनाई देता है:

सुनना सबसे अच्छा सबूत है, लेकिन वेवफॉर्म से यह देखना आसान हो जाता है कि क्या हुआ। 

plot_waveform(target_np, processor.audio_sampling_rate, title="Cleand Audio with only Horn")संचालित द्वारा

अलग किए गए आउटपुट में, आप आमतौर पर उन स्थानों पर स्पष्ट स्पाइक्स देखेंगे जहाँ हॉर्न बजता है, जबकि बाकी वेवफॉर्म तुलनात्मक रूप से शांत रहता है।

SAM Audio एक रेजिडुअल ट्रैक भी लौटाता है, जो मूलतः लक्ष्य हटाने के बाद “बाकी का ऑडियो” होता है। 

plot_waveform(resid_np, processor.audio_sampling_rate, title="Residual Audio with no Horn")संचालित द्वारा

यहाँ हमें केवल ट्रैफ़िक/बैकग्राउंड शोर दिखाई देता है, और हॉर्न की ध्वनि नहीं। 

7. डेटासेट से एक और सैंपल लोड करना

आइए एक और कठिन, अधिक यथार्थवादी उदाहरण आज़माते हैं। इस बार, हम एक ऐसा क्लिप चुनेंगे जहाँ एक गैर-अंग्रेज़ी वक्ता फ़ोन पर बात कर रहा है और साथ ही भारी बैकग्राउंड शोर (सड़क का शोर, माहौल, ओवरलैपिंग ध्वनियाँ) है। 

यही वह स्थिति है जहाँ ऑडियो सेपरेशन वास्तव में उपयोगी हो जाता है: भाषण मौजूद है, लेकिन मिश्रण अव्यवस्थित होने के कारण समझना कठिन है।

पहले, एक नया सैंपल लोड करें और कच्चे ऑडियो मिश्रण को सुनें:

samples_2 = dset["train"][45]["audio"].get_all_samples()
Audio(samples_2.data, rate=samples_2.sample_rate)संचालित द्वारा

अब वेवफॉर्म का विज़ुअलाइज़ेशन करें। 

plot_waveform(samples_2.data, samples_2.sample_rate, title="Background Noise and a Man Talking")संचालित द्वारा

आप क्लिप के अधिकांश हिस्से में घना, उच्च-ऊर्जा वाला सिग्नल देखेंगे, जो आमतौर पर प्रबल बैकग्राउंड शोर और ओवरलैपिंग ऑडियो का संकेत देता है:

हम पहले की तरह ही प्रीप्रोसेसिंग चरण चलाएँगे: [C, T] आकार सुनिश्चित करें, प्रोसेसर के लक्षित सैंपलिंग रेट पर रिसैंपल करें, मोनो में कन्वर्ट करें, और GPU पर 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")
संचालित द्वारा

आपको कुछ इस तरह दिखाई देगा:

Duration: 10.00s @ 48000 Hzसंचालित द्वारा

पिछले उदाहरण में, हमने टाइम स्पैन एंकर और टेक्स्ट प्रॉम्प्ट से मॉडल की मदद की थी। यहाँ, हम केवल टेक्स्ट-आधारित प्रॉम्प्टिंग करेंगे, जो यह परखने का बढ़िया तरीका है कि बिना अतिरिक्त मार्गदर्शन के मॉडल कितना अच्छा सामान्यीकरण करता है।

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")संचालित द्वारा

अंत में, अलग किए गए भाषण का वेवफॉर्म प्लॉट करें। मूल मिश्रण की तुलना में, वेवफॉर्म साफ़ और कम “व्यस्त” दिखना चाहिए, खासकर उन क्षेत्रों में जहाँ पहले बैकग्राउंड शोर हावी था:

यदि ऊपर दिया गया कोड चलाते समय आपको किसी भी समस्या का सामना करना पड़े, तो कृपया नीचे दिए गए DataLab नोटबुक को देखें, जिसमें पूरा, कार्यशील संदर्भ और अतिरिक्त मार्गदर्शन उपलब्ध है: Using SAM-Audio Locally — DataLab।

SAM Audio के उपयोग के मामले

SAM Audio को वास्तविक दुनिया की ऑडियो समझ और एडिटिंग के लिए डिज़ाइन किया गया है। कार्य-विशिष्ट टूल्स पर निर्भर रहने के बजाय, यह प्राकृतिक संकेतों का उपयोग करता है ताकि भाषण, संगीत और रोज़मर्रा के वातावरण में ध्वनियों को अलग और पृथक किया जा सके। 

ये विशेषताएँ इसे रचनात्मक, पेशेवर और शोध वर्कफ़्लोज़ में उपयोगी बनाती हैं, जहाँ साफ़ और नियंत्रित ऑडियो महत्वपूर्ण होता है।

• पॉडकास्ट और वॉयस रिकॉर्डिंग क्लीनअप: पॉडकास्ट, इंटरव्यू और वॉयस रिकॉर्डिंग में बैकग्राउंड शोर और एम्बिएंट साउंड्स से स्पीकर को अलग करके भाषण की स्पष्टता बेहतर करें।
• म्यूज़िक प्रोडक्शन और स्टेम एक्सट्रैक्शन: रीमिक्सिंग, सैंपलिंग, मास्टरिंग या क्रिएटिव साउंड डिज़ाइन के लिए मिक्स्ड म्यूज़िक ट्रैक्स से वोकल्स या व्यक्तिगत इंस्ट्रूमेंट्स को अलग करें।
• फ़िल्म और वीडियो पोस्ट-प्रोडक्शन: ट्रैफ़िक, हवा या भीड़ जैसे अवांछित बैकग्राउंड साउंड्स को हटाएँ, जबकि डॉयलॉग और महत्वपूर्ण साउंड इफेक्ट्स को बरकरार रखें।
• सुलभता और श्रवण संवर्धन: शोरगुल वाले वातावरण में भाषण को बेहतर बनाकर श्रवण सहायता टूल्स और सुलभता तथा स्पष्ट संचार पर केंद्रित अनुप्रयोगों का समर्थन करें।
• ऑडियो रिसर्च और साउंड विश्लेषण: जटिल वास्तविक दुनिया की ऑडियो रिकॉर्डिंग्स को सेगमेंट करें—जैसे ध्वनिक घटना पहचान, ऑडियो फॉरेंसिक्स, और साउंड सीन विश्लेषण के शोध कार्यों के लिए।

अंतिम विचार

सच कहूँ तो, SAM Audio को लोकल रूप से वास्तव में कैसे चलाया जाए, इस पर बहुत अधिक जानकारी उपलब्ध नहीं है। मैंने इसे Kaggle पर T4 GPUs के साथ चलाने की कोशिश की, और यह विफल रहा। मैंने UV का उपयोग करने और एक वर्चुअल Python वातावरण सेट करने की भी कोशिश की, लेकिन वह भी असफल रहा। 

मुख्य समस्या जो बार-बार सामने आई, वह निर्भरता संघर्ष थी। GitHub रिपोजिटरी से सीधे SAM Audio इंस्टॉल करने पर अक्सर मौजूदा ऑडियो और PyTorch लाइब्रेरी ओवरराइड हो जाती हैं, जिससे Jupyter कर्नेल क्रैश हो जाता है। 

इसीलिए मैं दृढ़ता से सलाह देता हूँ कि Conda या एक नए Python वर्चुअल वातावरण से क्लीन सेटअप शुरू करें, पहले PyTorch और CUDA इंस्टॉल करें, और फिर आवश्यक लाइब्रेरी जोड़ें। इस ट्यूटोरियल में, सही torchcodec संस्करण को पुनःइंस्टॉल करके क्रैश को ठीक करने के बाद सेटअप स्थिर हो गया।

इस ट्यूटोरियल में, हमने RTX 3090 पर लगभग 14 GB VRAM का उपयोग करते हुए SAM Audio बेस मॉडल को सफलतापूर्वक चलाया, जो लोकल इन्फरेंस के लिए काफ़ी उचित है। इन्फरेंस स्पीड तेज़ है, और ऑडियो सेपरेशन की गुणवत्ता वास्तव में प्रभावशाली है। आप इस सेटअप को वीडियो-आधारित प्रॉम्प्टिंग तक भी बढ़ा सकते हैं, जहाँ SAM Audio, SAM 3 के साथ मिलकर दृश्य संकेतों के आधार पर ऑडियो को अलग करता है।

SAM 3 के बारे में और जानने के लिए, मैं हमारा SAM 3 ट्यूटोरियल देखने की सलाह देता हूँ।