> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/stable-audio.md).

# 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.

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

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

```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='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

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

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

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

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

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

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

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

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

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

```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="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

```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 = "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

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

## Solución de problemas

### Sin memoria

```python
# 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](/guides/guides_v2-es/audio-y-voz/audiocraft-music.md) - Generación musical 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.