AudioCraft Música

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

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

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

Alquilar en CLORE.AI

1. Visita 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:

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

pip install audiocraft
pip install scipy torchaudio

MusicGen: Texto a Música

Generación básica

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

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:

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:

# 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

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

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

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

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

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

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

# 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

# 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

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

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

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 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 - Generación de voz

• Clon de voz RVC - Conversión de voz

• Separación Demucs - Separación de audio