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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/stable-audio.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.