# AudioCraft Música

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](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/bark-tts) - Generación de voz
* [Clon de voz RVC](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/rvc-voice-clone) - Conversión de voz
* [Separación Demucs](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/demucs-separation) - Separación de audio