Stable Audio

Clore.ai पर Stable Audio के साथ संगीत और साउंड इफ़ेक्ट्स जेनरेट करें

CLORE.AI GPU पर Stability AI के Stable Audio के साथ संगीत और ध्वनि प्रभाव उत्पन्न करें।

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

Stable Audio क्यों?

• उच्च गुणवत्ता - 44.1kHz स्टेरियो ऑडियो जनरेशन

• वेरिएबल लंबाई - 95 सेकंड तक उत्पन्न करें

• बहुमुखी - संगीत, ध्वनि प्रभाव, परिवेशी ध्वनियाँ

• टेक्स्ट-से-ऑडियो - जो आप सुनना चाहते हैं उसका वर्णन करें

• ओपन वेट्स - Stable Audio Open उपलब्ध

मॉडल वेरिएंट

मॉडल	अवधि	गुणवत्ता	VRAM	लाइसेंस
Stable Audio Open	47 सेकंड	अच्छा	8GB	खोलें
Stable Audio 2.0	3 मिनट	उत्कृष्ट	12GB	वाणिज्यिक

CLORE.AI पर त्वरित डिप्लॉय

Docker इमेज:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

पोर्ट:

22/tcp
7860/http

कमांड:

pip install stable-audio-tools gradio && \
python -c "
import gradio as gr
import torch
from stable_audio_tools import get_pretrained_model
from stable_audio_tools.inference.generation import generate_diffusion_cond
import soundfile as sf
import tempfile

model, model_config = get_pretrained_model('stabilityai/stable-audio-open-1.0')
model = model.to('cuda')

def generate(prompt, duration, steps, seed):
    conditioning = [{
        'prompt': prompt,
        'seconds_start': 0,
        'seconds_total': duration
    }]

    generator = torch.Generator('cuda').manual_seed(seed) if seed > 0 else None

    output = generate_diffusion_cond(
        model,
        conditioning=conditioning,
        steps=steps,
        cfg_scale=7,
        sample_size=model_config['sample_size'],
        sample_rate=model_config['sample_rate'],
        device='cuda',
        seed=seed if seed > 0 else None
    )

    audio = output[0].T.cpu().numpy()

    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        sf.write(f.name, audio, model_config['sample_rate'])
        return f.name

gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label='Prompt'),
        gr.Slider(1, 47, value=10, label='Duration (sec)'),
        gr.Slider(10, 150, value=100, label='Steps'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Audio(label='Generated Audio'),
    title='Stable Audio Open'
).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 नीचे दिए उदाहरणों में।

हार्डवेयर आवश्यकताएँ

मॉडल	न्यूनतम GPU	अनुशंसित
Stable Audio Open	RTX 3070 8GB	RTX 3090 24GB
Stable Audio 2.0	RTX 3090 12GB	RTX 4090 24GB

इंस्टॉलेशन

pip install stable-audio-tools torch torchaudio

मूल उपयोग

टेक्स्ट से संगीत

import torch
import torchaudio
from stable_audio_tools import get_pretrained_model
from stable_audio_tools.inference.generation import generate_diffusion_cond

# मॉडल लोड करें
model, model_config = get_pretrained_model("stabilityai/stable-audio-open-1.0")
model = model.to("cuda")

sample_rate = model_config["sample_rate"]
sample_size = model_config["sample_size"]

# वे निर्धारित करें जो आप चाहते हैं
conditioning = [{
    "prompt": "कैची सिंथ मेलडी के साथ उत्साही इलेक्ट्रॉनिक डांस संगीत, 128 BPM",
    "seconds_start": 0,
    "seconds_total": 30
}]

# जनरेट करें
output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=100,
    cfg_scale=7,
    sample_size=sample_size,
    sample_rate=sample_rate,
    device="cuda"
)

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

साउंड इफेक्ट्स

conditioning = [{
    "prompt": "भारी बारिश और दूर का बिजली के साथ तूफान",
    "seconds_start": 0,
    "seconds_total": 20
}]

output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=100,
    cfg_scale=7,
    sample_size=sample_size,
    sample_rate=sample_rate,
    device="cuda"
)

torchaudio.save("thunderstorm.wav", output[0].T.cpu(), sample_rate)

परिवेशी ध्वनियाँ

conditioning = [{
    "prompt": "चिड़ियों की चहचहाहट और मृदु हवा के साथ शांत वन का वातावरण",
    "seconds_start": 0,
    "seconds_total": 45
}]

output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=100,
    cfg_scale=7,
    sample_size=sample_size,
    sample_rate=sample_rate,
    device="cuda"
)

torchaudio.save("forest.wav", output[0].T.cpu(), sample_rate)

प्रॉम्प्ट उदाहरण

संगीत शैलियाँ

prompts = {
    "electronic": "गहरी बेस, सिंथ आर्पेगियो और ड्राइविंग बीट के साथ ऊर्जा से भरपूर EDM ट्रैक, 130 BPM",
    "jazz": "अप्राप्य जैज़ पियानो ट्रियो जिसमें अप्राइट बेस और ब्रश ड्रम्स हों, धीमा टेम्पो",
    "rock": "डिस्टॉर्शन के साथ भारी रॉक गिटार रिफ, ड्रम्स और बेस, शक्तिशाली और ऊर्जा से भरपूर",
    "classical": "स्ट्रिंग्स और वुडविंड्स के साथ ऑर्केस्ट्रल पीस, नाटकीय और सिनेमाई",
    "ambient": "पैड्स और सूक्ष्म बनावटों के साथ वातावरणीय एम्बियंट साउंडस्केप, स्वप्निल",
    "hiphop": "विनाइल क्रैकल, मृदु पियानो और ठंडे ड्रम्स के साथ लो-फाई हिप हॉप बीट, 85 BPM"
}

साउंड इफेक्ट्स

prompts = {
    "explosion": "मसिव विस्फोट जिसमें मलबा और आग, सिनेमाई",
    "footsteps": "कंकड़ पर कदमों की आवाज़, धीमी चाल",
    "car": "स्पोर्ट्स कार का इंजन रेव करना और तेजी से बढ़ना",
    "water": "गुफा में पानी का चपटना और टपकना",
    "wind": "पहाड़ों में तेज़ हवा का हुंकार",
    "fire": "लकड़ी के फटने के साथ चटखती कैंपफायर"
}

परिवेशी/पृष्ठभूमि

prompts = {
    "cafe": "कॉफी शॉप का वातावरण जिसमें हल्की बातचीत और एस्प्रेसो मशीन की आवाज़ें हैं",
    "ocean": "रेतिलے समुद्र तट पर लहरें, दूर सीगल्स की आवाज़",
    "city": "भीड़-भाड़ वाली शहर की सड़क जिसमें ट्रैफिक, हॉर्न और पैदल यात्री हैं",
    "rain": "खिड़की पर हल्की बारिश और कभी-कभार गरज",
    "space": "साइ-फाई स्पेसशिप के अंदर की humming और बीप्स"
}

उन्नत विकल्प

जनरेशन को नियंत्रित करना

output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=150,              # अधिक स्टेप्स = बेहतर गुणवत्ता
    cfg_scale=7,            # प्रॉम्प्ट पालन (5-10)
    sample_size=sample_size,
    sample_rate=sample_rate,
    device="cuda",
    seed=42                 # पुनरुत्पादन योग्य परिणाम
)

वेरिएबल लंबाई

# छोटा साउंड इफेक्ट (5 सेकंड)
conditioning = [{
    "prompt": "धीरे-धीरे खुलते हुए दरवाजे की चरमराहट",
    "seconds_start": 0,
    "seconds_total": 5
}]

# मध्यम क्लिप (30 सेकंड)
conditioning = [{
    "prompt": "उत्साही रॉक संगीत",
    "seconds_start": 0,
    "seconds_total": 30
}]

# अधिकतम लंबाई (Open के लिए 47 सेकंड)
conditioning = [{
    "prompt": "विकसित होती बनावटों के साथ परिवेशी इलेक्ट्रॉनिक संगीत",
    "seconds_start": 0,
    "seconds_total": 47
}]

बैच जनरेशन

import os

prompts = [
    "ऊर्जावान ड्रम और बेस ट्रैक",
    "शांत पियानो मेलडी",
    "साइ-फाई लेजर साउंड इफेक्ट्स",
    "टिन की छत पर बारिश"
]

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

for i, prompt in enumerate(prompts):
    conditioning = [{
        "prompt": prompt,
        "seconds_start": 0,
        "seconds_total": 15
    }]

    output = generate_diffusion_cond(
        model,
        conditioning=conditioning,
        steps=100,
        cfg_scale=7,
        sample_size=sample_size,
        sample_rate=sample_rate,
        device="cuda"
    )

    torchaudio.save(f"{output_dir}/audio_{i}.wav", output[0].T.cpu(), sample_rate)
    print(f"Generated: {prompt[:30]}...")

    torch.cuda.empty_cache()

Gradio वेब इंटरफेस

import gradio as gr
import torch
import torchaudio
from stable_audio_tools import get_pretrained_model
from stable_audio_tools.inference.generation import generate_diffusion_cond
import tempfile

model, model_config = get_pretrained_model("stabilityai/stable-audio-open-1.0")
model = model.to("cuda")

sample_rate = model_config["sample_rate"]
sample_size = model_config["sample_size"]

def generate_audio(prompt, duration, steps, cfg_scale, seed):
    conditioning = [{
        "prompt": prompt,
        "seconds_start": 0,
        "seconds_total": duration
    }]

    generator_seed = seed if seed > 0 else None

    output = generate_diffusion_cond(
        model,
        conditioning=conditioning,
        steps=steps,
        cfg_scale=cfg_scale,
        sample_size=sample_size,
        sample_rate=sample_rate,
        device="cuda",
        seed=generator_seed
    )

    audio = output[0].T.cpu()

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        torchaudio.save(f.name, audio, sample_rate)
        return f.name

demo = gr.Interface(
    fn=generate_audio,
    inputs=[
        gr.Textbox(label="Prompt", placeholder="जिस ऑडियो को आप चाहते हैं उसका वर्णन करें..."),
        gr.Slider(1, 47, value=15, step=1, label="Duration (seconds)"),
        gr.Slider(20, 200, value=100, step=10, label="Steps"),
        gr.Slider(1, 15, value=7, step=0.5, label="CFG Scale"),
        gr.Number(value=-1, label="Seed (-1 for random)")
    ],
    outputs=gr.Audio(label="Generated Audio", type="filepath"),
    title="Stable Audio Open - Text to Audio",
    description="टेक्स्ट विवरणों से संगीत और ध्वनि प्रभाव उत्पन्न करें। CLORE.AI पर चल रहा है.",
    examples=[
        ["सिंथ के साथ उत्साही इलेक्ट्रॉनिक डांस संगीत, 128 BPM", 20, 100, 7, 42],
        ["भारी बारिश के साथ तूफान", 15, 100, 7, 123],
        ["शांत पियानो मेलडी, भावनात्मक", 30, 100, 7, 456]
    ]
)

demo.launch(server_name="0.0.0.0", server_port=7860)

प्रदर्शन

अवधि	स्टेप्स	GPU	समय
10 सेकंड	100	RTX 3090	~15s
10 सेकंड	100	RTX 4090	~10s
30 सेकंड	100	RTX 3090	~40s
30 सेकंड	100	RTX 4090	~25s
47 सेकंड	100	RTX 4090	~40s

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

बेहतर संगीत

# टेम्पो और शैली शामिल करें
prompt = "ऊर्जावान रॉक संगीत, इलेक्ट्रिक गिटार, ड्रम्स, बेस, 140 BPM, उच्च ऊर्जा"

# उपकरणों के बारे में विशिष्ट रहें
prompt = "सोलो एकोस्टिक गिटार फिंगरपिकिंग, फोक शैली, गर्म और अंतरंग"

# मूड का वर्णन करें
prompt = "विरहभरी पियानो रचना, माइनर की, धीमा टेम्पो, भावनात्मक और उदास"

बेहतर साउंड इफेक्ट्स

# विशिष्ट रहें
prompt = "राइफल से एकल गोली की आवाज़, बाहर, इको"

# परिवेश शामिल करें
prompt = "लकड़ी के फर्श पर कदमों की आवाज़, अंदर, धीमी चाल, चरमराना"

# बनावट का वर्णन करें
prompt = "आग की चटखनी, बड़ा अलाव, लकड़ी फटना, चिंगारियाँ"

लागत अनुमान

सामान्य CLORE.AI मार्केटप्लेस दरें:

GPU	घंटात्मक दर	~30 सेकंड क्लिप/घंटा
RTX 3060 12GB	~$0.03	~50
RTX 3090 24GB	~$0.06	~90
RTX 4090 24GB	~$0.10	~140
A100 40GB	~$0.17	~200

कीमतें भिन्न होती हैं। जाँच करें CLORE.AI मार्केटप्लेस वर्तमान दरों के लिए।

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

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

# अवधि कम करें
conditioning = [{
    "prompt": prompt,
    "seconds_total": 15  # 47 के बजाय
}]

# या CPU ऑफलोड सक्षम करें
model.enable_model_cpu_offload()

खराब गुणवत्ता आउटपुट

• स्टेप्स बढ़ाएँ (150-200)

• CFG स्केल समायोजित करें (5-10 आज़माएँ)

• प्रॉम्प्ट में अधिक विशिष्ट रहें

• विभिन्न सीड आज़माएँ

कोई ध्वनि / मौन

• जाँच करें कि प्रॉम्प्ट पर्याप्त वर्णनात्मक है

• बहुत ABSTRACT वर्णनों से बचें

• पहले जानी-पहचानी कार्यशील प्रॉम्प्ट आज़माएँ

ऑडियो आर्टिफैक्ट्स

• स्टेप्स बढ़ाएँ

• CFG स्केल घटाएँ

• अवधि घटाएँ

• GPU थर्मल थ्रॉटलिंग के लिए जाँच करें

Stable Audio बनाम अन्य

फ़ीचर	Stable Audio	AudioCraft	Bark
संगीत	उत्कृष्ट	उत्कृष्ट	खराब
SFX	बहुत अच्छा	अच्छा	खराब
भाषण	नहीं	नहीं	हाँ
अवधि	47s / 3min	30s	15s
गुणवत्ता	44.1kHz	32kHz	24kHz
खोलें	आंशिक	हाँ	हाँ

Stable Audio का उपयोग करें जब:

• उच्च-गुणवत्ता संगीत जनरेशन

• गेम/वीडियो के लिए साउंड इफेक्ट्स

• बैकग्राउंड संगीत

• परिवेशी साउंडस्केप

अगले कदम

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

• Bark TTS - वॉइस सिंथेसिस

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

• Whisper - ट्रांसक्रिप्शन