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

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

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

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:

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

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

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:

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:

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

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

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

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

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

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

# 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

# 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

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

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

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

• RVC Voice Clone - Conversión de voz

• Separación con Demucs - Separación de audio