> 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/audiocraft-music.md).

# Música AudioCraft

Genera música y audio con AudioCraft de Meta en Clore.ai

Genera música y audio con AudioCraft de Meta (MusicGen).

{% 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 %}

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
2. Filtra por tipo de GPU, VRAM y precio
3. Elige **Bajo demanda** (tarifa fija) o **Spot** (precio ofertado)
4. Configura tu pedido:
   * Selecciona la imagen de Docker
   * Configura los puertos (TCP para SSH, HTTP para interfaces web)
   * Añade variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona el método de pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera al despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Qué es AudioCraft?

AudioCraft incluye:

* **MusicGen** - Generación de música a partir de texto
* **AudioGen** - Generación de efectos de sonido
* **EnCodec** - Compresión de audio
* **MAGNeT** - Generación más rápida

## Tamaños de modelo

| Modelo  | VRAM | Calidad             | Velocidad |
| ------- | ---- | ------------------- | --------- |
| pequeño | 4GB  | Bueno               | Rápido    |
| mediano | 8GB  | Excelente           | Medio     |
| grande  | 16GB | Mejor               | Lento     |
| melodía | 8GB  | Excelente + melodía | Medio     |

## Despliegue rápido

**Imagen de Docker:**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Puertos:**

```
22/tcp
7860/http
```

**Comando:**

```bash
pip install audiocraft gradio scipy && \
python -c "
import gradio as gr
from audiocraft.models import MusicGen
import scipy.io.wavfile as wav
import tempfile

model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=10)

def generate(prompt, duration):
    model.set_generation_params(duration=duration)
    output = model.generate([prompt])
    audio = output[0].cpu().numpy().T
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        wav.write(f.name, 32000, audio)
        return f.name

demo = gr.Interface(
    fn=generate,
    inputs=[gr.Textbox(label='Indicador'), gr.Slider(5, 30, value=10, label='Duración (s)')],
    outputs=gr.Audio(label='Música generada'),
    title='MusicGen'
)
demo.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.

## Instalación

```bash
pip install audiocraft
pip install scipy torchaudio
```

## MusicGen: Texto a música

### Generación básica

```python
from audiocraft.models import MusicGen
import torchaudio

# Cargar modelo
model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=15)  # segundos

# Generar
prompt = "música electrónica de baile enérgica con graves profundos"
output = model.generate([prompt])

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

### Múltiples prompts

```python
prompts = [
    "jazz de piano relajante",
    "cinemático orquestal épico",
    "canción folk de guitarra acústica",
    "heavy metal agresivo"
]

outputs = model.generate(prompts)

for i, output in enumerate(outputs):
    torchaudio.save(f"music_{i}.wav", output.cpu(), sample_rate=32000)
```

### Condicionamiento de melodía

Usa una melodía como referencia:

```python
from audiocraft.models import MusicGen
import torchaudio

# Cargar modelo de melodía
model = MusicGen.get_pretrained('facebook/musicgen-melody')
model.set_generation_params(duration=15)

# Cargar melodía de referencia
melody, sr = torchaudio.load("reference.wav")
melody = melody.unsqueeze(0).cuda()

# Generar con melodía
output = model.generate_with_chroma(
    ["versión de piano jazz"],
    melody,
    sr
)

torchaudio.save("jazz_version.wav", output[0].cpu(), sample_rate=32000)
```

### Continuación

Continúa a partir de audio existente:

```python

# Cargar audio para continuar
audio, sr = torchaudio.load("start.wav")
audio = audio.unsqueeze(0).cuda()

# Continuar
output = model.generate_continuation(
    audio,
    prompt_sample_rate=sr,
    descriptions=["más enérgico con batería"],
    progress=True
)

torchaudio.save("continued.wav", output[0].cpu(), sample_rate=32000)
```

## AudioGen: Efectos de sonido

```python
from audiocraft.models import AudioGen

# Cargar modelo
model = AudioGen.get_pretrained('facebook/audiogen-medium')
model.set_generation_params(duration=5)

# Generar sonidos
prompts = [
    "perro ladrando a lo lejos",
    "lluvia en una ventana",
    "motor de coche arrancando",
    "multitud animando en un concierto"
]

outputs = model.generate(prompts)

for i, output in enumerate(outputs):
    torchaudio.save(f"sound_{i}.wav", output.cpu(), sample_rate=16000)
```

## Parámetros de generación

```python
model.set_generation_params(
    duration=30,           # Duración en segundos
    top_k=250,             # Muestreo top-k
    top_p=0.0,             # Muestreo de núcleo (0 = desactivado)
    temperature=1.0,       # Aleatoriedad
    cfg_coef=3.0,          # Guía sin clasificador
    two_step_cfg=False,    # CFG de dos pasos
)
```

### Efectos de los parámetros

| Parámetro   | Valor bajo              | Valor alto                  |
| ----------- | ----------------------- | --------------------------- |
| temperature | Conservador             | Creativo                    |
| top\_k      | Más enfocado            | Más variedad                |
| cfg\_coef   | Interpretación flexible | Estricto con la instrucción |

## Procesamiento por lotes

```python
from audiocraft.models import MusicGen
import torchaudio
import os

model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=15)

prompts = [
    {"name": "intro", "prompt": "introducción ambiental misteriosa, desarrollo lento"},
    {"name": "verse", "prompt": "beat chill de hip hop lo-fi"},
    {"name": "chorus", "prompt": "estribillo pop electrónico enérgico"},
    {"name": "outro", "prompt": "fundido final de piano tranquilo"},
]

output_dir = "./music_parts"
os.makedirs(output_dir, exist_ok=True)

for item in prompts:
    output = model.generate([item["prompt"]])
    torchaudio.save(
        os.path.join(output_dir, f"{item['name']}.wav"),
        output[0].cpu(),
        sample_rate=32000
    )
    print(f"Generado: {item['name']}")
```

## Generación en streaming

```python
from audiocraft.models import MusicGen
import torch

model = MusicGen.get_pretrained('facebook/musicgen-small')

# Habilitar streaming
streamer = model.get_streaming_generator(
    "música pop enérgica",
    max_gen_len=256  # tokens
)

all_tokens = []
for tokens in streamer:
    all_tokens.append(tokens)
    # Procesar bloque...

# Decodificar todo
audio = model.decode(torch.cat(all_tokens, dim=-1))
```

## Generación estéreo

```python
from audiocraft.models import MusicGen

# Cargar modelo estéreo
model = MusicGen.get_pretrained('facebook/musicgen-stereo-medium')
model.set_generation_params(duration=15)

output = model.generate(["banda sonora orquestal cinematográfica"])

# Forma de salida: [lote, 2, muestras] para estéreo

torchaudio.save("stereo_music.wav", output[0].cpu(), sample_rate=32000)
```

## Servidor API

```python
from fastapi import FastAPI
from fastapi.responses import FileResponse
from audiocraft.models import MusicGen
import torchaudio
import tempfile

app = FastAPI()
model = MusicGen.get_pretrained('facebook/musicgen-medium')

@app.post("/generate")
async def generate_music(prompt: str, duration: int = 10):
    model.set_generation_params(duration=duration)
    output = model.generate([prompt])

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        torchaudio.save(f.name, output[0].cpu(), sample_rate=32000)
        return FileResponse(f.name, media_type="audio/wav")

@app.post("/generate_with_melody")
async def generate_with_melody(prompt: str, melody_path: str, duration: int = 15):
    melody, sr = torchaudio.load(melody_path)

    model_melody = MusicGen.get_pretrained('facebook/musicgen-melody')
    model_melody.set_generation_params(duration=duration)

    output = model_melody.generate_with_chroma([prompt], melody.unsqueeze(0).cuda(), sr)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        torchaudio.save(f.name, output[0].cpu(), sample_rate=32000)
        return FileResponse(f.name, media_type="audio/wav")

# Ejecutar: uvicorn server:app --host 0.0.0.0 --port 8000
```

## Ingeniería de prompts

### Prompts efectivos

```python

# Género + instrumentos + estado de ánimo
"jazz animado con saxofón y piano, alegre y enérgico"

# Referencia de estilo
"beat de hip hop lo-fi, música relajada para estudiar, crujido de vinilo"

# Cinematográfico
"música épica orquestal de tráiler, tensión creciente, dramática"

# Elementos específicos
"patrón de rasgueo de guitarra acústica, canción folk, ambiente de fogata"
```

### Prompts malos

```python

# Demasiado vago
"música bonita"  # No es lo suficientemente específico

# Letras de canciones
"Feliz cumpleaños a ti..."  # No funcionará

# Nombres de artistas
"como los Beatles"  # No entiende a los artistas
```

## Posprocesamiento

### Combinar clips

```python
from pydub import AudioSegment

intro = AudioSegment.from_wav("intro.wav")
verse = AudioSegment.from_wav("verse.wav")
chorus = AudioSegment.from_wav("chorus.wav")

# Fundido cruzado
song = intro.append(verse, crossfade=1000)
song = song.append(chorus, crossfade=1000)

song.export("full_song.mp3", format="mp3")
```

### Añadir efectos

```python
from pydub import AudioSegment
from pydub.effects import normalize, compress_dynamic_range

audio = AudioSegment.from_wav("generated.wav")

# Normalizar volumen
audio = normalize(audio)

# Añadir compresión
audio = compress_dynamic_range(audio)

# Fundido de entrada/salida
audio = audio.fade_in(2000).fade_out(3000)

audio.export("processed.wav", format="wav")
```

## Optimización de memoria

```python
import torch
from audiocraft.models import MusicGen

# Usar un modelo más pequeño
model = MusicGen.get_pretrained('facebook/musicgen-small')

# Habilitar descarga a CPU
model.to('cpu')

# Generar en GPU, descargar inmediatamente
with torch.cuda.amp.autocast():
    output = model.generate(["prompt"])
    output = output.cpu()
    torch.cuda.empty_cache()
```

## Rendimiento

| Modelo  | GPU      | Generación de 30 s |
| ------- | -------- | ------------------ |
| pequeño | RTX 3090 | \~10 s             |
| mediano | RTX 3090 | \~25 s             |
| grande  | RTX 4090 | \~45 s             |
| melodía | RTX 3090 | \~30 s             |

## Comparación

| Función            | MusicGen  | Stable Audio | Riffusion |
| ------------------ | --------- | ------------ | --------- |
| Calidad            | Excelente | Excelente    | Bueno     |
| Longitud           | 30 s      | 90 s         | Bucle     |
| Entrada de melodía | Sí        | No           | No        |
| Código abierto     | Sí        | No           | Sí        |

## Solución de problemas

### Sin memoria

* Usa un modelo más pequeño (small en lugar de large)
* Reduce la duración
* Borrar caché: `torch.cuda.empty_cache()`

### Calidad deficiente

* Usa prompts más específicos
* Prueba el modelo medium o large
* Ajusta la temperatura (0.8-1.2)

### Salida repetitiva

* Aumenta top\_k
* Disminuye cfg\_coef
* Prueba diferentes prompts

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir de 2024):

| GPU       | Tarifa por hora | Tarifa diaria | Sesión de 4 horas |
| --------- | --------------- | ------------- | ----------------- |
| RTX 3060  | \~$0.03         | \~$0.70       | \~$0.12           |
| RTX 3090  | \~$0.06         | \~$1.50       | \~$0.25           |
| RTX 4090  | \~$0.10         | \~$2.30       | \~$0.40           |
| A100 40GB | \~$0.17         | \~$4.00       | \~$0.70           |
| A100 80GB | \~$0.25         | \~$6.00       | \~$1.00           |

*Los precios varían según el proveedor y la demanda. Consulta* [*Marketplace de CLORE.AI*](https://clore.ai/marketplace) *las tarifas actuales.*

**Ahorra dinero:**

* Usa el **Spot** mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de \~13% de descuento), el resto lo iguala
* Paga con **CLORE** tokens
* Compara precios entre distintos proveedores

## Siguientes pasos

* [Bark TTS](/guides/guides_v2-es/audio-y-voz/bark-tts.md) - Generación de voz
* [RVC Voice Clone](/guides/guides_v2-es/audio-y-voz/rvc-voice-clone.md) - Conversión de voz
* [Separación con Demucs](/guides/guides_v2-es/audio-y-voz/demucs-separation.md) - Separación de audio


---

# 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/audiocraft-music.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.