# Música AudioCraft

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

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

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrar por tipo de GPU, VRAM y precio
3. Elegir **Bajo demanda** (tarifa fija) o **Spot** (precio de puja)
4. Configura tu pedido:
   * Selecciona imagen Docker
   * Establece puertos (TCP para SSH, HTTP para interfaces web)
   * Agrega variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera el 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 modelos

| Modelo  | VRAM | Calidad          | Velocidad |
| ------- | ---- | ---------------- | --------- |
| small   | 4GB  | Bueno            | Rápido    |
| medium  | 8GB  | Genial           | Medio     |
| grande  | 16GB | Mejor            | Lento     |
| melodía | 8GB  | Genial + melodía | Medio     |

## Despliegue rápido

**Imagen Docker:**

```
pytorch/pytorch:2.5.1-cuda12.4-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='Prompt'), 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. 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.

## 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 bailable y animada con bajo potente"
output = model.generate([prompt])

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

### Múltiples Prompts

```python
prompts = [
    "jazz relajante de piano",
    "épica orquestal cinematográfica",
    "canción folk con guitarra acústica",
    "metal pesado agresivo"
]

outputs = model.generate(prompts)

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

### Condicionamiento por 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

Continuar desde 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",
    "arranque de motor de coche",
    "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 por núcleo (0 = deshabilitado)
    temperature=1.0,       # Aleatoriedad
    cfg_coef=3.0,          # Guía sin clasificador (classifier-free guidance)
    two_step_cfg=False,    # CFG en 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 laxa | Estricto con el prompt |

## 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": "intro ambiental misteriosa, construcción lenta"},
    {"name": "verse", "prompt": "ritmo chill lo-fi hip hop"},
    {"name": "chorus", "prompt": "estribillo pop electrónico energético"},
    {"name": "outro", "prompt": "desvanecimiento calmado de piano"},
]

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 por streaming

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

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

# Activar streaming
streamer = model.get_streaming_generator(
    "música pop animada",
    max_gen_len=256  # tokens
)

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

# 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(["partitura orquestal cinematográfica"])

# Forma de salida: [batch, 2, samples] 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 Eficaces

```python

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

# Referencia de estilo
"ritmo lo-fi hip hop, música tranquila para estudiar, crepitar de vinilo"

# Cinemático
"música orquestal épica de tráiler, aumentando la tensión, 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 agradable"  # No es lo suficientemente específico

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

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

## Postprocesamiento

### 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")

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

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

### Agregar 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)

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

# Use 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 |
| ------- | -------- | ------------------ |
| small   | RTX 3090 | \~10s              |
| medium  | RTX 3090 | \~25s              |
| grande  | RTX 4090 | \~45s              |
| melodía | RTX 3090 | \~30s              |

## Comparación

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

## Solución de problemas

### Memoria insuficiente

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

### Calidad pobre

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

### Salida Repetitiva

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

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha 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* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *para las tarifas actuales.*

**Ahorra dinero:**

* Usa **Spot** market para cargas de trabajo flexibles (a menudo 30-50% más barato)
* Paga con **CLORE** tokens
* Compara precios entre diferentes proveedores

## Próximos pasos

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


---

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