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)

   • यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें

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

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

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

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

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

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

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

AudioCraft क्या है?

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

• MusicGen - टेक्स्ट-से-संगीत जेनरेशन

• AudioGen - साउंड इफेक्ट्स जेनरेशन

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

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

मॉडल आकार

मॉडल	VRAM	गुणवत्ता	स्पीड
small	4GB	अच्छा	तेज़
medium	8GB	बहुत अच्छा	मध्यम
large	16GB	सर्वोत्तम	धीमा
melody	8GB	Great + melody	मध्यम

त्वरित तैनाती

Docker इमेज:

pytorch/pytorch:2.5.1-cuda12.4-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='Prompt'), gr.Slider(5, 30, value=10, label='Duration (s)')],
    outputs=gr.Audio(label='Generated Music'),
    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: Text-to-Music

मूल जनरेशन

from audiocraft.models import MusicGen
import torchaudio

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

# जनरेट करें
prompt = "upbeat electronic dance music with heavy bass"
output = model.generate([prompt])

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

Multiple Prompts

prompts = [
    "relaxing piano jazz",
    "epic orchestral cinematic",
    "acoustic guitar folk song",
    "aggressive heavy metal"
]

outputs = model.generate(prompts)

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

Melody Conditioning

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

from audiocraft.models import MusicGen
import torchaudio

# Load melody model
model = MusicGen.get_pretrained('facebook/musicgen-melody')
model.set_generation_params(duration=15)

# Load reference melody
melody, sr = torchaudio.load("reference.wav")
melody = melody.unsqueeze(0).cuda()

# Generate with melody
output = model.generate_with_chroma(
    ["jazz piano version"],
    melody,
    sr
)

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

Continuation

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

# Load audio to continue
audio, sr = torchaudio.load("start.wav")
audio = audio.unsqueeze(0).cuda()

# Continue
output = model.generate_continuation(
    audio,
    prompt_sample_rate=sr,
    descriptions=["more energetic with drums"],
    progress=True
)

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

AudioGen: Sound Effects

from audiocraft.models import AudioGen

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

# Generate sounds
prompts = [
    "dog barking in the distance",
    "rain on a window",
    "car engine starting",
    "crowd cheering at a concert"
]

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,           # Length in seconds
    top_k=250,             # Top-k sampling
    top_p=0.0,             # Nucleus sampling (0 = disabled)
    temperature=1.0,       # Randomness
    cfg_coef=3.0,          # Classifier-free guidance
    two_step_cfg=False,    # Two-step CFG
)

Parameter Effects

पैरामीटर	Low Value	High Value
temperature	Conservative	Creative
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": "mysterious ambient intro, slow build"},
    {"name": "verse", "prompt": "chill lo-fi hip hop beat"},
    {"name": "chorus", "prompt": "energetic electronic pop chorus"},
    {"name": "outro", "prompt": "calm piano fade out"},
]

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"Generated: {item['name']}")

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

from audiocraft.models import MusicGen
import torch

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

# Enable streaming
streamer = model.get_streaming_generator(
    "upbeat pop music",
    max_gen_len=256  # tokens
)

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

# Decode all
audio = model.decode(torch.cat(all_tokens, dim=-1))

Stereo Generation

from audiocraft.models import MusicGen

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

output = model.generate(["cinematic orchestral score"])

# Output shape: [batch, 2, samples] for stereo

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

API सर्वर

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

Prompt Engineering

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

# Genre + instruments + mood
"upbeat jazz with saxophone and piano, happy and energetic"

# शैली संदर्भ
"lo-fi hip hop beat, chill study music, vinyl crackle"

# Cinematic
"epic orchestral trailer music, building tension, dramatic"

# Specific elements
"acoustic guitar strumming pattern, folk song, campfire vibes"

Bad Prompts

# Too vague
"nice music"  # Not specific enough

# Song lyrics
"Happy birthday to you..."  # Won't work

# Artist names
"like Beatles"  # Doesn't understand artists

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

Combine Clips

from pydub import AudioSegment

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

# Crossfade
song = intro.append(verse, crossfade=1000)
song = song.append(chorus, crossfade=1000)

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

Add Effects

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

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

# Normalize volume
audio = normalize(audio)

# Add compression
audio = compress_dynamic_range(audio)

# Fade in/out
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')

# Generate on GPU, offload immediately
with torch.cuda.amp.autocast():
    output = model.generate(["prompt"])
    output = output.cpu()
    torch.cuda.empty_cache()

प्रदर्शन

मॉडल	GPU	30s Generation
small	RTX 3090	~10s
medium	RTX 3090	~25s
large	RTX 4090	~45s
melody	RTX 3090	~30s

तुलना

फ़ीचर	MusicGen	Stable Audio	Riffusion
गुणवत्ता	बहुत अच्छा	बहुत अच्छा	अच्छा
Length	30s	90s	Loop
Melody Input	हां	नहीं	नहीं
ओपन सोर्स	हां	नहीं	हां

समस्याओं का निवारण

आउट ऑफ़ मेमोरी

• छोटा मॉडल उपयोग करें (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 मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)

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

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

अगले कदम

• Bark TTS - वॉइस जेनरेशन

• RVC वॉयस क्लोन - वॉयस कन्वर्शन

• Demucs Separation - ऑडियो विभाजन