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 las GPU de CLORE.AI.

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

¿Por qué Stable Audio?

• Alta calidad - generación de audio estéreo de 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 del modelo

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

Despliegue rápido en CLORE.AI

Imagen de Docker:

pytorch/pytorch:2.11.0-cuda12.8-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='Instrucción'),
        gr.Slider(1, 47, value=10, label='Duración (s)'),
        gr.Slider(10, 150, value=100, label='Pasos'),
        gr.Number(value=-1, label='Semilla')
    ],
    outputs=gr.Audio(label='Audio generado'),
    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. Ve a Mis pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (p. ej., abc123.clorecloud.net)

Usa https://YOUR_HTTP_PUB_URL en lugar de localhost en los ejemplos a continuación.

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 enérgica con una pegadiza melodía de sintetizador, 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 eléctrica 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 canto de pájaros 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 graves profundos, arpegios de sintetizador y un ritmo marcado, 130 BPM",
    "jazz": "Trío de piano de jazz suave con contrabajo y batería con escobillas, tempo relajado",
    "rock": "Riff de guitarra rock pesado con distorsión, batería y bajo, potente y enérgico",
    "classical": "Pieza orquestal con cuerdas y vientos de madera, dramática y cinematográfica",
    "ambient": "Paisaje sonoro ambiental atmosférico con pads y texturas sutiles, onírico",
    "hiphop": "Beat lo-fi hip hop con crujido 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 caminata lento",
    "car": "Motor de coche deportivo revolucionando y acelerando",
    "water": "Agua salpicando y goteando en una cueva",
    "wind": "Viento fuerte aullando entre montañas",
    "fire": "Hoguera crepitante con leña estallando"
}

Ambiental/de fondo

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

Opciones avanzadas

Control de la generación

output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=150,              # Más pasos = mejor calidad
    cfg_scale=7,            # Fidelidad 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 abriéndose lentamente con chirrido",
    "seconds_start": 0,
    "seconds_total": 5
}]

# Clip medio (30 segundos)
conditioning = [{
    "prompt": "Música rock enérgica",
    "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 = [
    "Pista de drum and bass enérgica",
    "Melodía de piano tranquila",
    "Efectos de sonido láser de ciencia ficción",
    "Lluvia sobre un tejado de chapa"
]

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"Generado: {prompt[:30]}...")

    torch.cuda.empty_cache()

Interfaz web de 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="Instrucción", 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=[
        ["Música electrónica dance enérgica con sintetizadores, 128 BPM", 20, 100, 7, 42],
        ["Tormenta eléctrica con lluvia intensa", 15, 100, 7, 123],
        ["Melodía de piano tranquila, emotiva", 30, 100, 7, 456]
    ]
)

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

Rendimiento

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

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 = "Punteo de guitarra acústica en solitario, estilo folk, cálido e íntimo"

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

Mejores efectos de sonido

# Sé específico
prompt = "Un solo disparo de rifle, al aire libre, con eco"

# Incluye el entorno
prompt = "Pasos sobre piso de madera, en interiores, paso lento, chirriante"

# Describe la textura
prompt = "Fuego crepitando, gran hoguera, leña estallando, chispas"

Estimación de costos

Tarifas típicas del mercado de CLORE.AI:

GPU	Tarifa por hora	~30 s de 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 Marketplace de CLORE.AI las tarifas actuales.

Solución de problemas

Sin memoria

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

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

Salida de mala 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

• Comprueba 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

• Comprueba si hay limitación térmica de la GPU

Stable Audio frente a otros

Función	Stable Audio	AudioCraft	Bark
Música	Excelente	Excelente	Mala
Efectos de sonido	Excelente	Bueno	Mala
Habla	No	No	Sí
Duración	47 s / 3 min	30 s	15 s
Calidad	44,1 kHz	32 kHz	24 kHz
Abre	Parcial	Sí	Sí

Usa Stable Audio cuando:

• Generación de música de alta calidad

• Efectos de sonido para juegos/vídeo

• Música de fondo

• Paisajes sonoros ambientales

Siguientes pasos

• AudioCraft - Generación musical de Meta

• Bark TTS - Síntesis de voz

• Demucs - Separación de audio

• Whisper - Transcripción