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

सामान्य समाधान: लिब्रोसा

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

import librosa

# load in any audio to test
sampleAudio, sr = librosa.load("sample.mp3", sr=None) # sr=None means the original sampling rate
spectrogram = librosa.feature.melspectrogram(
    y=sampleAudio,
    sr=sr,
    n_fft=int(0.05 * sr),  # 50ms
    hop_length=int(0.0125 * sr),  # 12.5ms
    win_length=int(0.05 * sr),
)

सीधा और एक जीसीपी जी2 वीएम पर इसमें औसतन 2 एमएस का समय लगता है। खैर, दो मुख्य मुद्दे हैं:

1. आमतौर पर, डीएल मॉडल के साथ काम करते समय, आपको मॉडल को जीपीयू पर चलाने की आवश्यकता होगी। इसका मतलब है कि आपकी श्रृंखला का हिस्सा सीपीयू पर चलता है और फिर आप परिणामों को वापस जीपीयू पर कॉपी करते हैं। बैच किए गए अनुमान के लिए, यह अधिकतर ठीक है क्योंकि आपको उतना ही डेटा एकत्र करना चाहिए जितना आप GPU/ट्रांसफर पर फिट कर सकते हैं। हालाँकि, हमारे मामले में, प्रतीक्षा और प्रसंस्करण समय को कम करने के लिए हम अक्सर एक समय में एक फ्रेम के साथ काम करते हैं।
2. हमारा कुल समय बजट लगभग 33 एमएस/फ़्रेम है। इसमें एपीआई सर्वर से एमएल इंट्रेंस सर्वर, सीपीयू से जीपीयू कॉपी, प्रीप्रोसेसिंग और मेलस्पेक्ट्रोग्राम सहित मॉडलों के लिए पोस्टप्रोसेसिंग में ट्रांसफर विलंबता शामिल है। जब आप इतने कम बजट के साथ काम कर रहे हों तो हर मिलीसेकंड मायने रखता है। इन दो मिलीसेकंड ने वास्तव में सिमली के लिए एक कामकाजी लाइव रेंडर वीडियो स्ट्रीम बनाने में योगदान दिया (खैर यह एक या दो मिलीसेकंड के लायक कई अनुकूलन थे)।

समाधान के लिए ऑनलाइन खोज रहे हैं

यह देखने की कोशिश करते समय कि अन्य लोगों ने इसे कैसे किया है (सौभाग्य से यह हमारे लिए कोई अनोखी समस्या नहीं है), मुझे यह लेख मिला जिसमें बताया गया है कि मेलस्पेक्ट्रोग्राम कैसे काम करते हैं और एक संदर्भ कार्यान्वयन प्रदान किया गया है जिसमें किसी कारण से केवल 1 एमएस (50) लगा % सुधार)। यह एक अच्छी शुरुआत है लेकिन अभी भी पहली समस्या है, सब कुछ GPU पर नहीं था। हम PyTorch का उपयोग कर रहे हैं और अधिकतम गति में सुधार के लिए mode=reduce-overhead के साथ torch.compile पर भरोसा कर रहे हैं। हालाँकि, इस तरह डेटा ट्रांसफर से प्रदर्शन ख़राब हो सकता है क्योंकि PyTorch कंपाइलर फ़ंक्शन को अनुकूलित करने में भी सक्षम नहीं होगा। समाधान थोड़ा कठिन है लेकिन अपेक्षाकृत आसान है, इसे टॉर्च में फिर से लिखें। PyTorch टीम ने यह सुनिश्चित किया है कि उनका बहुत सारा सिंटैक्स और कार्यक्षमता यथासंभव NumPy के करीब है (कुछ किनारे के मामले जो आमतौर पर अच्छी तरह से प्रलेखित होते हैं, एक को छोड़कर जिसमें मुझे कुछ दिन बर्बाद हो गए लेकिन यह एक अलग ब्लॉग के लिए एक कहानी है) .

PyTorch पुनः लिखना

इसलिए पाइटोरच में सब कुछ सफलतापूर्वक फिर से लिखने के लिए हमें कुछ कदम उठाने होंगे। मेलस्पेक्ट्रोग्राम को तीन चरणों में विभाजित किया जा सकता है:

• कंप्यूटिंग कम समय फूरियर रूपांतरण
• मेल स्केल फ़्रीक्वेंसी बैंक बनाना
• स्पेक्ट्रोग्राम उत्पन्न करना।

अच्छी और बुरी खबरें हैं। अच्छी खबर यह है कि सभी आवश्यक कार्यक्षमताएं पाइटोरच या टॉर्चऑडियो में आसानी से उपलब्ध हैं। बुरी खबर यह है कि डिफ़ॉल्ट व्यवहार लिब्रोसा से बहुत अलग है इसलिए इसे सही करने के लिए बहुत सारे कॉन्फ़िगरेशन और परीक्षण और त्रुटि की आवश्यकता होती है। मैं इससे गुजर चुका हूं और मैं जानकारी इसलिए साझा कर रहा हूं क्योंकि मैं अपने सबसे बड़े दुश्मन पर ऐसी मार की कामना भी नहीं कर सकता। एक बात जो हमें समझने की आवश्यकता है वह यह है कि यह कोड हमारे कुछ परिणामों को बाद में उपयोग करने के लिए कैशिंग पर बहुत अधिक निर्भर करता है। यह एक इनिशियलाइज़ेशन फ़ंक्शन में किया जाता है जो सभी स्थिर सरणियों को पूर्व-उत्पन्न करता है (उदाहरण के लिए मेल फ़्रीक्वेंसी बैंक नमूना दर और आपके लिए आवश्यक मेल्स की संख्या पर निर्भर करता है)। यहां PyTorch का उपयोग करके मेलस्पेक्ट्रोग्राम फ़ंक्शन का हमारा अनुकूलित संस्करण है

import torch

if torch.cuda.is_available
    @torch.compile(mode="reduce-overhead")
else:
    @torch.compile
def melspecrogram_torch(wav:torch.Tensor,sample_rate:int, hann_window: torch.Tensor, mel_basis: torch.Tensor):
    stftWav = torch.stft(
            wav,
            n_fft=int(sample_rate*0.05),
            win_length=int(sample_rate*0.05),
            hop_length=int(sample_rate*0.0125),
            window=hann_window,
            pad_mode="constant",
            return_complex=True,
        ).abs()
    stftWav = stftWav.squeeze()
    mel_stftWav = torch.mm(mel_basis, stftWav)
    return mel_stftWav

device = "cuda" if torch.cuda.is_available() else "cpu"

melspectrogram_torch(
    sampleAudio,
    sr,
    torch.hann_window(int(sample_rate*0.05), device=device, dtype=torch.float32),
    torchaudio.functional.melscale_fbanks(
        sample_rate=sr,
        n_freqs=(int(sample_rate*0.05) // 2   1),
        norm="slaney", # this is the normalization algorithm used by librosa
        # this is an example that's related to our own pipeline, check what you need for yours
        n_mels=80,
        f_min=55,
        f_max=7600,
    )
    .T.to(device)
)

प्रारंभिक संकलन चलाने के बाद, हमने एनवीडिया एल4 जीपीयू (हैन_विंडो और मेलस्केल_फबैंक्स को कैशिंग के साथ) का उपयोग करके 350 माइक्रोसेकंड लेने के लिए इस फ़ंक्शन को मापा। समायोजित कॉल इस तरह दिखेगी:

hann=torch.hann_window(int(sample_rate*0.05), device=device, dtype=torch.float32),
melscale=torchaudio.functional.melscale_fbanks(
        sample_rate=sr,
        n_freqs=(int(sample_rate*0.05) // 2   1),
        norm="slaney", # this is the normalization algorithm used by librosa
        # this is an example that's related to our own pipeline, check what you need for yours
        n_mels=80,
        f_min=55,
        f_max=7600,
    )
    .T.to(device)
melspectrogram_torch(
    sampleAudio,
    sr,
    hann,
    melscale,
)

यह लेखों की एक श्रृंखला का एक हिस्सा है कि हमने अपने तैनात पूर्व-प्रशिक्षित मॉडलों को कैसे अनुकूलित किया, प्रीप्रोसेसिंग और पोस्टप्रोसेसिंग चरणों को अनुकूलित किया। आप हमारे द्वारा प्रदान किए गए तैनात मॉडल और सबसे कम विलंबता अवतार देखने के लिए https://www.simli.com/demo देख सकते हैं