AudioCraft संगीत

Clore.ai पर Meta के AudioCraft के साथ संगीत और ऑडियो जनरेट करें

Meta के AudioCraft (MusicGen) का उपयोग करके संगीत और ऑडियो उत्पन्न करें.

सभी उदाहरण 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>

AudioCraft क्या है?

AudioCraft में शामिल हैं:

• MusicGen - टेक्स्ट-टू-म्यूज़िक जनरेशन

• AudioGen - ध्वनि प्रभाव जनरेशन

• EnCodec - ऑडियो संपीड़न

• MAGNeT - तेज़ जनरेशन

मॉडल आकार

मॉडल	VRAM	गुणवत्ता	गति
छोटा	4GB	अच्छा	तेज़
मध्यम	8GB	उत्कृष्ट	मध्यम
बड़ा	16GB	सर्वोत्तम	धीमा
मेलोडी	8GB	बहुत बढ़िया + मेलोडी	मध्यम

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

Docker इमेज:

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

पोर्ट:

22/tcp
7860/http

कमांड:

pip install audiocraft gradio scipy && \\
python -c "
import gradio as gr
from audiocraft.models import MusicGen
import scipy.io.wavfile as wav
import tempfile

model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=10)

def generate(prompt, duration):
    model.set_generation_params(duration=duration)
    output = model.generate([prompt])
    audio = output[0].cpu().numpy().T
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        wav.write(f.name, 32000, audio)
        return f.name

demo = gr.Interface(
    fn=generate,
    inputs=[gr.Textbox(label='प्रॉम्प्ट'), gr.Slider(5, 30, value=10, label='अवधि (से)')],
    outputs=gr.Audio(label='जनरेट किया गया संगीत'),
    title='MusicGen'
)
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 audiocraft
pip install scipy torchaudio

MusicGen: टेक्स्ट-टू-म्यूज़िक

मूल जनरेशन

from audiocraft.models import MusicGen
import torchaudio

# मॉडल लोड करें
model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=15)  # सेकंड

# जनरेट करें
prompt = "जोशीला इलेक्ट्रॉनिक डांस संगीत, भारी बास के साथ"
output = model.generate([prompt])

# सहेजें
audio = output[0].cpu()
torchaudio.save("music.wav", audio, sample_rate=32000)

एकाधिक प्रॉम्प्ट

prompts = [
    "आरामदायक पियानो जैज़",
    "महाकाव्य ऑर्केस्ट्रल सिनेमैटिक",
    "ध्वनिक गिटार लोक गीत",
    "आक्रामक हेवी मेटल"
]

outputs = model.generate(prompts)

for i, output in enumerate(outputs):
    torchaudio.save(f"music_{i}.wav", output.cpu(), sample_rate=32000)

मेलोडी कंडीशनिंग

संदर्भ के रूप में एक मेलोडी का उपयोग करें:

from audiocraft.models import MusicGen
import torchaudio

# मेलोडी मॉडल लोड करें
model = MusicGen.get_pretrained('facebook/musicgen-melody')
model.set_generation_params(duration=15)

# संदर्भ मेलोडी लोड करें
melody, sr = torchaudio.load("reference.wav")
melody = melody.unsqueeze(0).cuda()

# मेलोडी के साथ जनरेट करें
output = model.generate_with_chroma(
    ["जैज़ पियानो संस्करण"],
    melody,
    sr
)

torchaudio.save("jazz_version.wav", output[0].cpu(), sample_rate=32000)

जारी रखना

मौजूदा ऑडियो से जारी रखें:

# जारी रखने के लिए ऑडियो लोड करें
audio, sr = torchaudio.load("start.wav")
audio = audio.unsqueeze(0).cuda()

# जारी रखें
output = model.generate_continuation(
    audio,
    prompt_sample_rate=sr,
    descriptions=["ड्रम्स के साथ अधिक ऊर्जावान"],
    progress=True
)

torchaudio.save("continued.wav", output[0].cpu(), sample_rate=32000)

AudioGen: ध्वनि प्रभाव

from audiocraft.models import AudioGen

# मॉडल लोड करें
model = AudioGen.get_pretrained('facebook/audiogen-medium')
model.set_generation_params(duration=5)

# ध्वनियाँ जनरेट करें
prompts = [
    "दूर कहीं कुत्ते के भौंकने की आवाज़",
    "खिड़की पर बारिश",
    "कार इंजन स्टार्ट होना",
    "कंसर्ट में भीड़ की तालियाँ"
]

outputs = model.generate(prompts)

for i, output in enumerate(outputs):
    torchaudio.save(f"sound_{i}.wav", output.cpu(), sample_rate=16000)

निर्माण पैरामीटर

model.set_generation_params(
    duration=30,           # सेकंड में लंबाई
    top_k=250,             # टॉप-k सैंपलिंग
    top_p=0.0,             # न्यूक्लियस सैंपलिंग (0 = अक्षम)
    temperature=1.0,       # यादृच्छिकता
    cfg_coef=3.0,          # क्लासिफ़ायर-फ़्री गाइडेंस
    two_step_cfg=False,    # दो-चरणीय CFG
)

पैरामीटर प्रभाव

पैरामीटर	कम मान	उच्च मान
temperature	सावधान	रचनात्मक
top_k	अधिक केंद्रित	अधिक विविधता
cfg_coef	ढीली व्याख्या	प्रॉम्प्ट के अनुसार सख्त

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

from audiocraft.models import MusicGen
import torchaudio
import os

model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=15)

prompts = [
    {"name": "intro", "prompt": "रहस्यमय एम्बिएंट इंट्रो, धीमा निर्माण"},
    {"name": "verse", "prompt": "चिल लो-फाई हिप हॉप बीट"},
    {"name": "chorus", "prompt": "ऊर्जावान इलेक्ट्रॉनिक पॉप कोरस"},
    {"name": "outro", "prompt": "शांत पियानो फेड आउट"},
]

output_dir = "./music_parts"
os.makedirs(output_dir, exist_ok=True)

for item in prompts:
    output = model.generate([item["prompt"]])
    torchaudio.save(
        os.path.join(output_dir, f"{item['name']}.wav"),
        output[0].cpu(),
        sample_rate=32000
    )
    print(f"जनरेट हुआ: {item['name']}")

स्ट्रीमिंग जनरेशन

from audiocraft.models import MusicGen
import torch

model = MusicGen.get_pretrained('facebook/musicgen-small')

# स्ट्रीमिंग सक्षम करें
streamer = model.get_streaming_generator(
    "जोशीला पॉप संगीत",
    max_gen_len=256  # टोकन
)

all_tokens = []
for tokens in streamer:
    all_tokens.append(tokens)
    # चंक प्रोसेस करें...

# सब डिकोड करें
audio = model.decode(torch.cat(all_tokens, dim=-1))

स्टीरियो जनरेशन

from audiocraft.models import MusicGen

# स्टीरियो मॉडल लोड करें
model = MusicGen.get_pretrained('facebook/musicgen-stereo-medium')
model.set_generation_params(duration=15)

output = model.generate(["सिनेमैटिक ऑर्केस्ट्रल स्कोर"])

# आउटपुट आकार: स्टीरियो के लिए [batch, 2, samples]

torchaudio.save("stereo_music.wav", output[0].cpu(), sample_rate=32000)

एपीआई सर्वर

from fastapi import FastAPI
from fastapi.responses import FileResponse
from audiocraft.models import MusicGen
import torchaudio
import tempfile

app = FastAPI()
model = MusicGen.get_pretrained('facebook/musicgen-medium')

@app.post("/generate")
async def generate_music(prompt: str, duration: int = 10):
    model.set_generation_params(duration=duration)
    output = model.generate([prompt])

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        torchaudio.save(f.name, output[0].cpu(), sample_rate=32000)
        return FileResponse(f.name, media_type="audio/wav")

@app.post("/generate_with_melody")
async def generate_with_melody(prompt: str, melody_path: str, duration: int = 15):
    melody, sr = torchaudio.load(melody_path)

    model_melody = MusicGen.get_pretrained('facebook/musicgen-melody')
    model_melody.set_generation_params(duration=duration)

    output = model_melody.generate_with_chroma([prompt], melody.unsqueeze(0).cuda(), sr)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        torchaudio.save(f.name, output[0].cpu(), sample_rate=32000)
        return FileResponse(f.name, media_type="audio/wav")

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

प्रॉम्प्ट इंजीनियरिंग

प्रभावी प्रॉम्प्ट

# शैली + वाद्ययंत्र + मूड
"जोशीला जैज़, सैक्सोफोन और पियानो के साथ, खुशमिज़ाज और ऊर्जावान"

# शैली संदर्भ
"लो-फाई हिप हॉप बीट, चिल स्टडी म्यूज़िक, विनाइल क्रैकल"

# सिनेमैटिक
"महाकाव्य ऑर्केस्ट्रल ट्रेलर संगीत, बढ़ता तनाव, नाटकीय"

# विशिष्ट तत्व
"ध्वनिक गिटार की स्ट्रमिंग पैटर्न, लोक गीत, कैम्पफ़ायर वाइब्स"

खराब प्रॉम्प्ट

# बहुत अस्पष्ट
"अच्छा संगीत"  # पर्याप्त विशिष्ट नहीं

# गीत के बोल
"जन्मदिन की शुभकामनाएँ आपको..."  # काम नहीं करेगा

# कलाकारों के नाम
"बीटल्स जैसा"  # कलाकारों को नहीं समझता

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

क्लिप्स जोड़ें

from pydub import AudioSegment

intro = AudioSegment.from_wav("intro.wav")
verse = AudioSegment.from_wav("verse.wav")
chorus = AudioSegment.from_wav("chorus.wav")

# क्रॉसफेड
song = intro.append(verse, crossfade=1000)
song = song.append(chorus, crossfade=1000)

song.export("full_song.mp3", format="mp3")

प्रभाव जोड़ें

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

audio = AudioSegment.from_wav("generated.wav")

# वॉल्यूम सामान्य करें
audio = normalize(audio)

# संपीड़न जोड़ें
audio = compress_dynamic_range(audio)

# फेड इन/आउट
audio = audio.fade_in(2000).fade_out(3000)

audio.export("processed.wav", format="wav")

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

import torch
from audiocraft.models import MusicGen

# छोटा मॉडल उपयोग करें
model = MusicGen.get_pretrained('facebook/musicgen-small')

# CPU ऑफलोड सक्षम करें
model.to('cpu')

# GPU पर जनरेट करें, तुरंत ऑफलोड करें
with torch.cuda.amp.autocast():
    output = model.generate(["prompt"])
    output = output.cpu()
    torch.cuda.empty_cache()

प्रदर्शन

मॉडल	GPU	30 सेकंड जनरेशन
छोटा	RTX 3090	~10 सेकंड
मध्यम	RTX 3090	~25 सेकंड
बड़ा	RTX 4090	~45 सेकंड
मेलोडी	RTX 3090	~30 सेकंड

तुलना

विशेषता	MusicGen	Stable Audio	Riffusion
गुणवत्ता	उत्कृष्ट	उत्कृष्ट	अच्छा
अवधि	30 सेकंड	90 सेकंड	लूप
मेलोडी इनपुट	हाँ	नहीं	नहीं
ओपन सोर्स	हाँ	नहीं	हाँ

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

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

• छोटा मॉडल उपयोग करें (large के बजाय small)

• अवधि कम करें

• कैश साफ़ करें: torch.cuda.empty_cache()

खराब गुणवत्ता

• अधिक विशिष्ट प्रॉम्प्ट का उपयोग करें

• मध्यम या बड़े मॉडल का प्रयास करें

• तापमान समायोजित करें (0.8-1.2)

दोहरावपूर्ण आउटपुट

• top_k बढ़ाएँ

• cfg_coef कम करें

• विभिन्न प्रॉम्प्ट आज़माएँ

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

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 टोकन

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

अगले चरण

• Bark TTS - आवाज़ जनरेशन

• RVC वॉइस क्लोन - आवाज़ रूपांतरण

• Demucs पृथक्करण - ऑडियो पृथक्करण