Stable Audio

Genera música y efectos de sonido con Stable Audio en Clore.ai

Genera música y efectos de sonido con Stable Audio de Stability AI en GPUs de CLORE.AI.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

¿Por qué Stable Audio?

• Alta calidad - Generación de audio estéreo a 44,1 kHz

• Longitud variable - Genera hasta 95 segundos

• Versátil - Música, efectos de sonido, sonidos ambientales

• Texto a audio - Describe lo que quieres escuchar

• Pesos abiertos - Stable Audio Open disponible

Variantes de modelo

Modelo	Duración	Calidad	VRAM	Licencia
Stable Audio Open	47 seg	Bueno	8GB	Abrir
Stable Audio 2.0	3 min	Excelente	12GB	Comercial

Despliegue rápido en CLORE.AI

Imagen Docker:

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

Puertos:

22/tcp
7860/http

Comando:

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)
"

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Requisitos de hardware

Modelo	GPU mínima	Recomendado
Stable Audio Open	RTX 3070 8GB	RTX 3090 24GB
Stable Audio 2.0	RTX 3090 12GB	RTX 4090 24GB

Instalación

pip install stable-audio-tools torch torchaudio

Uso básico

Texto a música

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

# Cargar modelo
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"]

# Define lo que quieres
conditioning = [{
    "prompt": "Música electrónica dance animada con una melodía de sintetizador pegadiza, 128 BPM",
    "seconds_start": 0,
    "seconds_total": 30
}]

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

# Guardar
audio = output[0].T
torchaudio.save("music.wav", audio.cpu(), sample_rate)

Efectos de sonido

conditioning = [{
    "prompt": "Tormenta con lluvia intensa y truenos lejanos",
    "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)

Sonidos ambientales

conditioning = [{
    "prompt": "Ambiente de bosque tranquilo con pájaros cantando y viento suave",
    "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)

Ejemplos de prompts

Géneros musicales

prompts = {
    "electronic": "Pista EDM enérgica con bajo profundo, arpegios de sintetizador y un ritmo impulsor, 130 BPM",
    "jazz": "Trío de jazz suave con piano, contrabajo y batería con escobillas, tempo relajado",
    "rock": "Riff de guitarra rock contundente con distorsión, batería y bajo, poderoso y enérgico",
    "classical": "Pieza orquestal con cuerdas y vientos, dramática y cinematográfica",
    "ambient": "Paisaje sonoro ambiental con pads y texturas sutiles, onírico",
    "hiphop": "Beat lo-fi hip hop con crepitar de vinilo, piano suave y batería chill, 85 BPM"
}

Efectos de sonido

prompts = {
    "explosion": "Explosión masiva con escombros y fuego, cinematográfica",
    "footsteps": "Pasos sobre grava, ritmo de caminar lento",
    "car": "Motor de coche deportivo acelerando y revolucionando",
    "water": "Agua salpicando y goteando en una cueva",
    "wind": "Viento fuerte aullando entre montañas",
    "fire": "Hoguera crepitando con madera tronando"
}

Ambiental/Fondo

prompts = {
    "cafe": "Ambiente de cafetería con conversación baja y máquina de espresso",
    "ocean": "Olas del océano en una playa de arena, gaviotas a lo lejos",
    "city": "Calle concurrida de la ciudad con tráfico, bocinas y peatones",
    "rain": "Lluvia suave en la ventana con truenos ocasionales",
    "space": "Zumbido y pitidos del interior de una nave espacial de ciencia ficción"
}

Opciones avanzadas

Controlando la generación

output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=150,              # Más pasos = mejor calidad
    cfg_scale=7,            # Adhesión al prompt (5-10)
    sample_size=sample_size,
    sample_rate=sample_rate,
    device="cuda",
    seed=42                 # Resultados reproducibles
)

Longitud variable

# Efecto de sonido corto (5 segundos)
conditioning = [{
    "prompt": "Puerta crujiendo al abrirse lentamente",
    "seconds_start": 0,
    "seconds_total": 5
}]

# Clip mediano (30 segundos)
conditioning = [{
    "prompt": "Música rock animada",
    "seconds_start": 0,
    "seconds_total": 30
}]

# Longitud máxima (47 segundos para Open)
conditioning = [{
    "prompt": "Música electrónica ambiental, texturas en evolución",
    "seconds_start": 0,
    "seconds_total": 47
}]

Generación por lotes

import os

prompts = [
    "Energetic drum and bass track",
    "Calm piano melody",
    "Sci-fi laser sound effects",
    "Rain on a tin roof"
]

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()

Interfaz web 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="Describe el audio que quieres..."),
        gr.Slider(1, 47, value=15, step=1, label="Duración (segundos)"),
        gr.Slider(20, 200, value=100, step=10, label="Pasos"),
        gr.Slider(1, 15, value=7, step=0.5, label="Escala CFG"),
        gr.Number(value=-1, label="Semilla (-1 para aleatorio)")
    ],
    outputs=gr.Audio(label="Audio generado", type="filepath"),
    title="Stable Audio Open - Texto a Audio",
    description="Genera música y efectos de sonido a partir de descripciones de texto. Ejecutándose en CLORE.AI.",
    examples=[
        ["Upbeat electronic dance music with synths, 128 BPM", 20, 100, 7, 42],
        ["Thunderstorm with heavy rain", 15, 100, 7, 123],
        ["Peaceful piano melody, emotional", 30, 100, 7, 456]
    ]
)

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

Rendimiento

Duración	Pasos	GPU	Tiempo
10 seg	100	RTX 3090	~15s
10 seg	100	RTX 4090	~10s
30 seg	100	RTX 3090	~40s
30 seg	100	RTX 4090	~25s
47 seg	100	RTX 4090	~40s

Consejos de calidad

Mejor música

# Incluye tempo y estilo
prompt = "Música rock enérgica, guitarra eléctrica, batería, bajo, 140 BPM, alta energía"

# Sé específico sobre los instrumentos
prompt = "Guitarra acústica solista con fingerpicking, estilo folk, cálida e íntima"

# Describe el estado de ánimo
prompt = "Pieza de piano melancólica, tonalidad menor, tempo lento, emocional y triste"

Mejores efectos de sonido

# Sé específico
prompt = "Disparo único de rifle, exterior, eco"

# Incluye el entorno
prompt = "Pasos en suelo de madera, interior, ritmo lento, crujidos"

# Describe la textura
prompt = "Crepitar de fuego, gran hoguera, madera tronando, chispas"

Estimación de costos

Tarifas típicas del mercado de CLORE.AI:

GPU	Tarifa por hora	~30 seg clips/hora
RTX 3060 12GB	~$0.03	~50
RTX 3090 24GB	~$0.06	~90
RTX 4090 24GB	~$0.10	~140
A100 40GB	~$0.17	~200

Los precios varían. Consulta CLORE.AI Marketplace para las tarifas actuales.

Solución de problemas

Memoria insuficiente

# Reduce la duración
conditioning = [{
    "prompt": prompt,
    "seconds_total": 15  # En lugar de 47
}]

# O habilita el descarga a CPU
model.enable_model_cpu_offload()

Salida de baja calidad

• Aumenta los pasos (150-200)

• Ajusta la escala CFG (prueba 5-10)

• Sé más específico en el prompt

• Prueba diferentes semillas

Sin sonido / Silencio

• Verifica que el prompt sea lo suficientemente descriptivo

• Evita descripciones muy abstractas

• Prueba primero prompts que sepas que funcionan

Artefactos de audio

• Aumenta los pasos

• Reduce la escala CFG

• Reduce la duración

• Verifica el estrangulamiento térmico de la GPU

Stable Audio frente a otros

Función	Stable Audio	AudioCraft	Bark
Música	Excelente	Excelente	Pobre
Efectos	Genial	Bueno	Pobre
Voz	No	No	Sí
Duración	47 s / 3 min	30 s	15 s
Calidad	44,1 kHz	32 kHz	24 kHz
Abrir	Parcial	Sí	Sí

Usa Stable Audio cuando:

• Generación de música de alta calidad

• Efectos de sonido para juegos/video

• Música de fondo

• Paisajes sonoros ambientales

Próximos pasos

• AudioCraft - Generación de música de Meta

• Bark TTS - Síntesis de voz

• Demucs - Separación de audio

• Whisper - Transcripción