Demucs पृथक्करण

Demucs के साथ संगीत को वोकल्स, ड्रम्स, बास, और अधिक में अलग करें

Demucs के साथ संगीत को स्टेम्स (वोकल्स, ड्रम्स, बास, अन्य) में अलग करें।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

CLORE.AI पर किराए पर लेना

1. विज़िट करें CLORE.AI मार्केटप्लेस

2. GPU प्रकार, VRAM और कीमत के अनुसार फ़िल्टर करें

3. चुनें ऑन-डिमांड (स्थिर दर) या स्पॉट (बोली मूल्य)

4. अपना ऑर्डर कॉन्फ़िगर करें:

   • Docker इमेज चुनें

   • पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)

   • यदि आवश्यक हो तो environment variables जोड़ें

   • स्टार्टअप कमांड दर्ज करें

5. भुगतान चुनें: CLORE, BTCया USDT/USDC

6. ऑर्डर बनाएं और डिप्लॉयमेंट की प्रतीक्षा करें

अपने सर्वर तक पहुँचें

• कनेक्शन विवरण यहाँ खोजें मेरे ऑर्डर

• वेब इंटरफ़ेस: HTTP पोर्ट URL का उपयोग करें

• SSH: ssh -p <port> root@<proxy-address>

Demucs क्या है?

Meta AI का Demucs यह कर सकता है:

• संगीत से वोकल्स अलग करें

• ड्रम्स, बास और अन्य वाद्ययंत्र निकालें

• किसी भी ऑडियो फ़ॉर्मेट को प्रोसेस करें

• उच्च-गुणवत्ता वाला स्टेम निष्कर्षण

त्वरित डिप्लॉय

Docker इमेज:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

पोर्ट:

22/tcp
7860/http

कमांड:

pip install demucs gradio && \
python -c "
import gradio as gr
from demucs.pretrained import get_model
from demucs.apply import apply_model
import torch
import torchaudio
import tempfile
import os

model = get_model('htdemucs')
model.cuda()

def separate(audio_path, stem):
    wav, sr = torchaudio.load(audio_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    stems = {'drums': 0, 'bass': 1, 'other': 2, 'vocals': 3}
    output = sources[stems[stem]].cpu()

    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        torchaudio.save(f.name, output, sr)
        return f.name

demo = gr.Interface(
    fn=separate,
    inputs=[gr.Audio(type='filepath'), gr.Dropdown(['vocals', 'drums', 'bass', 'other'])],
    outputs=gr.Audio(),
    title='Demucs ऑडियो सेपरेटर'
)
demo.launch(server_name='0.0.0.0', server_port=7860)
"

अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना http_pub URL यहाँ मेरे ऑर्डर:

1. पर जाएँ मेरे ऑर्डर पेज

2. अपने ऑर्डर पर क्लिक करें

3. खोजें http_pub URL (उदा., abc123.clorecloud.net)

उपयोग करें https://YOUR_HTTP_PUB_URL की बजाय localhost नीचे दिए गए उदाहरणों में।

इंस्टॉलेशन

pip install demucs

# या
pip install -e git+https://github.com/facebookresearch/demucs#egg=demucs

कमांड लाइन उपयोग

मूलभूत पृथक्करण

# 4 स्टेम्स में अलग करें
demucs song.mp3

# आउटपुट: separated/htdemucs/song/{drums,bass,other,vocals}.wav

विकल्प

demucs \
    --two-stems vocals \     # केवल वोकल्स + वाद्य
    -n htdemucs \            # मॉडल का नाम
    -d cuda \                # GPU का उपयोग करें
    -o ./output \            # आउटपुट डायरेक्टरी
    --mp3 \                  # MP3 के रूप में आउटपुट
    song.mp3

फ़ोल्डर प्रोसेस करें

demucs --two-stems vocals -d cuda ./songs/*.mp3

पायथन API

मूलभूत पृथक्करण

from demucs.pretrained import get_model
from demucs.apply import apply_model
import torchaudio
import torch

# मॉडल लोड करें
model = get_model('htdemucs')
model.cuda()
model.eval()

# ऑडियो लोड करें
wav, sr = torchaudio.load("song.mp3")
wav = wav.cuda()

# अलग करें
with torch.no_grad():
    sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

# sources का आकार: [4, channels, samples]

# 0: ड्रम्स, 1: बास, 2: अन्य, 3: वोकल्स

# स्टेम्स सहेजें
stems = ['drums', 'bass', 'other', 'vocals']
for i, stem in enumerate(stems):
    torchaudio.save(f"{stem}.wav", sources[i].cpu(), sr)

केवल वोकल्स प्राप्त करें

def extract_vocals(audio_path):
    wav, sr = torchaudio.load(audio_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    vocals = sources[3].cpu()  # Index 3 = vocals
    return vocals, sr

vocals, sr = extract_vocals("song.mp3")
torchaudio.save("vocals.wav", vocals, sr)

वाद्य प्राप्त करें (वोकल्स नहीं)

def extract_instrumental(audio_path):
    wav, sr = torchaudio.load(audio_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    # ड्रम्स + बास + अन्य को जोड़ें
    instrumental = sources[0] + sources[1] + sources[2]
    return instrumental.cpu(), sr

instrumental, sr = extract_instrumental("song.mp3")
torchaudio.save("instrumental.wav", instrumental, sr)

मॉडल वेरिएंट

मॉडल	स्टेम्स	गुणवत्ता	गति
htdemucs	4	सर्वोत्तम	मध्यम
htdemucs_ft	4	Best+	धीमा
htdemucs_6s	6	उत्कृष्ट	मध्यम
mdx_extra	4	उत्कृष्ट	तेज़

6-स्टेम मॉडल

model = get_model('htdemucs_6s')

# स्टेम्स: ड्रम्स, बास, अन्य, वोकल्स, गिटार, पियानो

फाइन-ट्यून किया गया मॉडल

model = get_model('htdemucs_ft')

# उच्च गुणवत्ता लेकिन धीमा

बैच प्रोसेसिंग

import os
from demucs.pretrained import get_model
from demucs.apply import apply_model
import torchaudio
import torch

model = get_model('htdemucs')
model.cuda()
model.eval()

input_dir = "./songs"
output_dir = "./separated"

for filename in os.listdir(input_dir):
    if filename.endswith(('.mp3', '.wav', '.flac')):
        input_path = os.path.join(input_dir, filename)
        song_output_dir = os.path.join(output_dir, filename.rsplit('.', 1)[0])
        os.makedirs(song_output_dir, exist_ok=True)

        print(f"प्रोसेस हो रहा है: {filename}")

        wav, sr = torchaudio.load(input_path)
        wav = wav.cuda()

        with torch.no_grad():
            sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

        stems = ['drums', 'bass', 'other', 'vocals']
        for i, stem in enumerate(stems):
            torchaudio.save(
                os.path.join(song_output_dir, f"{stem}.wav"),
                sources[i].cpu(),
                sr
            )

        print(f"सहेजा गया: {song_output_dir}")

एपीआई सर्वर

from fastapi import FastAPI, UploadFile
from fastapi.responses import FileResponse
from demucs.pretrained import get_model
from demucs.apply import apply_model
import torchaudio
import torch
import tempfile
import os

app = FastAPI()

model = get_model('htdemucs')
model.cuda()
model.eval()

@app.post("/separate")
async def separate(file: UploadFile, stem: str = "vocals"):
    # अपलोड की गई फ़ाइल सहेजें
    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
        content = await file.read()
        tmp.write(content)
        tmp_path = tmp.name

    # लोड करें और अलग करें
    wav, sr = torchaudio.load(tmp_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    stems = {'drums': 0, 'bass': 1, 'other': 2, 'vocals': 3}
    output = sources[stems[stem]].cpu()

    # आउटपुट सहेजें
    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as out:
        torchaudio.save(out.name, output, sr)
        return FileResponse(out.name, media_type="audio/wav")

@app.post("/instrumental")
async def get_instrumental(file: UploadFile):
    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
        content = await file.read()
        tmp.write(content)
        tmp_path = tmp.name

    wav, sr = torchaudio.load(tmp_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    # गैर-वोकल स्टेम्स को मिलाएँ
    instrumental = sources[0] + sources[1] + sources[2]

    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as out:
        torchaudio.save(out.name, instrumental.cpu(), sr)
        return FileResponse(out.name, media_type="audio/wav")

# चलाएँ: uvicorn server:app --host 0.0.0.0 --port 8000

मेमोरी अनुकूलन

लंबे ऑडियो के लिए

from demucs.apply import apply_model

# लंबे ऑडियो के लिए विभाजन का उपयोग करें
sources = apply_model(
    model,
    wav.unsqueeze(0),
    split=True,         # खंडों में विभाजित करें
    overlap=0.25,       # खंडों के बीच ओवरलैप
    progress=True
)[0]

सीमित VRAM के लिए

# कुछ ऑपरेशनों के लिए CPU का उपयोग करें
model.cpu()
wav = wav.cpu()

# या सेगमेंट प्रोसेसिंग का उपयोग करें
sources = apply_model(
    model,
    wav.unsqueeze(0),
    split=True,
    segment=10  # 10 सेकंड के सेगमेंट
)[0]

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

कराओके ट्रैक

def create_karaoke(song_path):
    wav, sr = torchaudio.load(song_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    # वोकल्स को छोड़कर सब कुछ
    karaoke = sources[0] + sources[1] + sources[2]
    return karaoke.cpu(), sr

रीमिक्स तैयारी

def extract_all_stems(song_path, output_dir):
    wav, sr = torchaudio.load(song_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    stems = ['drums', 'bass', 'other', 'vocals']
    paths = {}

    for i, stem in enumerate(stems):
        path = os.path.join(output_dir, f"{stem}.wav")
        torchaudio.save(path, sources[i].cpu(), sr)
        paths[stem] = path

    return paths

अकैपेला निष्कर्षण

def extract_acapella(song_path):
    wav, sr = torchaudio.load(song_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    vocals = sources[3]
    return vocals.cpu(), sr

गुणवत्ता सुझाव

सर्वोत्तम परिणामों के लिए

• लॉसलेस इनपुट का उपयोग करें (WAV, FLAC)

• उच्च सैंपल दर = बेहतर गुणवत्ता

• उपयोग करें htdemucs_ft महत्वपूर्ण कार्य के लिए

पोस्ट-प्रोसेसिंग

from pydub import AudioSegment
from pydub.effects import normalize, high_pass_filter

# अलग किए गए वोकल लोड करें
vocals = AudioSegment.from_wav("vocals.wav")

# लो-रंबल हटाएँ
vocals = high_pass_filter(vocals, 80)

# सामान्यीकृत करें
vocals = normalize(vocals)

vocals.export("vocals_clean.wav", format="wav")

प्रदर्शन

ऑडियो लंबाई	GPU	समय
3 मिनट का गीत	RTX 3090	~15 सेकंड
3 मिनट का गीत	RTX 4090	~10 सेकंड
3 मिनट का गीत	A100	~8s
1 घंटे का एल्बम	RTX 3090	~5 मिनट

समस्या निवारण

मेमोरी समाप्त

# छोटे सेगमेंट का उपयोग करें
demucs --segment 10 song.mp3

खराब पृथक्करण

• htdemucs_ft मॉडल का उपयोग करें

• इनपुट गुणवत्ता जाँचें

• बहुत अधिक संपीड़ित MP3 से बचें

आर्टिफैक्ट्स

• ओवरलैप बढ़ाएँ

• उच्च गुणवत्ता वाले मॉडल का उपयोग करें

• इनपुट में क्लिपिंग की जाँच करें

लागत का अनुमान

CLORE.AI मार्केटप्लेस की सामान्य दरें (2024 तक):

GPU	प्रति घंटा दर	प्रति दिन दर	4-घंटे का सत्र
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

मूल्य प्रदाता और मांग के अनुसार बदलते हैं। देखें CLORE.AI मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• का उपयोग करें स्पॉट बाधित किए जा सकने वाले कार्य के लिए मार्केट — लगभग एक-तिहाई सर्वरों की स्पॉट कीमत ऑन-डिमांड से कम होती है (मध्य ~13% छूट), बाकी उससे मेल खाते हैं

• से भुगतान करें CLORE टोकन

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले चरण

• RVC वॉइस क्लोन - निकाले गए वोकल्स प्रोसेस करें

• AudioCraft संगीत - नया संगीत जनरेट करें

• Whisper प्रतिलेखन - वोकल्स का ट्रांसक्रिप्शन करें