# Stable Audio

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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## ¿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:**

```bash
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

```bash
pip install stable-audio-tools torch torchaudio
```

## Uso básico

### Texto a música

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
# 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

```python
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

```python
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

```python
# 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

```python
# 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*](https://clore.ai/marketplace) *para las tarifas actuales.*

## Solución de problemas

### Memoria insuficiente

```python
# 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](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/audiocraft-music) - Generación de música de Meta
* [Bark TTS](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/bark-tts) - Síntesis de voz
* [Demucs](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/demucs-separation) - Separación de audio
* [Whisper](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/whisper-transcription) - Transcripción