Massed Compute

Provision Blackwell GPU VM

Launch a new VM with the RTX PRO 6000 Blackwell GPU and Ubuntu 24.04 with pre-installed NVIDIA drivers:

• Product: gpu_1x_pro_6000_blackwell
• Image: Ubuntu Server 24.04 w/ Drivers (ID: 184)
• Region: Any region with available capacity
• Instance name: blackwell-musicgen

Wait for the VM to reach running status and verify SSH connectivity. If reusing a public IP, clear any old host keys:

ssh-keygen -R YOUR_VM_IP

Verify GPU Hardware

Confirm the expected Blackwell GPU configuration and driver version:

ssh ubuntu@YOUR_VM_IP \
  'nvidia-smi --query-gpu=name,driver_version,memory.total,memory.free --format=csv,noheader'

Expected output: RTX PRO 6000 Blackwell, driver 580.x or newer, approximately 96GB total VRAM.

Install System Dependencies

Install Python, audio libraries, and create a virtual environment:

ssh ubuntu@YOUR_VM_IP 'bash -s' <<'EOF'
set -euxo pipefail

# Wait for cloud-init if apt is locked
sudo apt-get update
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y \
  python3.12-venv python3-pip ffmpeg \
  libavformat-dev libavcodec-dev libavdevice-dev libavutil-dev \
  libavfilter-dev libswscale-dev libswresample-dev pkg-config curl

python3 -m venv ~/musicgen-env
. ~/musicgen-env/bin/activate
python -m pip install --upgrade pip setuptools wheel
EOF

Install PyTorch with CUDA 13.0

Install PyTorch 2.10.0 from the cu130 index, which includes proper Blackwell sm_120 support:

ssh ubuntu@YOUR_VM_IP 'bash -s' <<'EOF'
set -euxo pipefail
. ~/musicgen-env/bin/activate

python -m pip install \
  torch==2.10.0 torchvision torchaudio \
  --index-url https://download.pytorch.org/whl/cu130
EOF

Verify PyTorch can access the Blackwell GPU:

ssh ubuntu@YOUR_VM_IP 'bash -s' <<'EOF'
. ~/musicgen-env/bin/activate
python - <<'PY'
import torch
print(torch.__version__, torch.cuda.is_available(), torch.cuda.get_device_name(0))
a = torch.randn((2048, 2048), device='cuda', dtype=torch.float16)
b = torch.randn((2048, 2048), device='cuda', dtype=torch.float16)
torch.cuda.synchronize()
c = a @ b
torch.cuda.synchronize()
print('BLACKWELL_TORCH_OK', c.shape, c.dtype)
PY
EOF

Install MusicGen Dependencies

Install Hugging Face Transformers and acceleration libraries:

ssh ubuntu@YOUR_VM_IP 'bash -s' <<'EOF'
set -euxo pipefail
. ~/musicgen-env/bin/activate
python -m pip install --retries 5 --timeout 60 \
  transformers==4.57.3 accelerate==1.12.0
EOF

Create Generation Script

Set up a self-contained MusicGen script with WAV output:

ssh ubuntu@YOUR_VM_IP 'bash -s' <<'EOF'
set -euxo pipefail

mkdir -p ~/musicgen ~/musicgen/outputs
cat > ~/musicgen/generate.py <<'PY'
#!/usr/bin/env python3
import argparse
import wave
import numpy as np
import torch
from transformers import AutoProcessor, MusicgenForConditionalGeneration

DEFAULT_MODEL_ID = 'facebook/musicgen-small'
SAMPLE_RATE = 32000

def write_wav(path, samples):
    samples = np.asarray(samples, dtype=np.float32)
    samples = np.clip(samples, -1.0, 1.0)
    pcm = (samples * 32767.0).astype(np.int16)
    with wave.open(path, 'wb') as wf:
        wf.setnchannels(1)
        wf.setsampwidth(2)
        wf.setframerate(SAMPLE_RATE)
        wf.writeframes(pcm.tobytes())

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('prompt', nargs='?', default='lo-fi hip hop beat, mellow piano')
    parser.add_argument('--duration', type=int, default=4)
    parser.add_argument('--output', default='outputs/smoke_test.wav')
    parser.add_argument('--temperature', type=float, default=1.0)
    parser.add_argument('--top-k', type=int, default=250)
    parser.add_argument('--model-id', default=DEFAULT_MODEL_ID)
    args = parser.parse_args()

    processor = AutoProcessor.from_pretrained(args.model_id)
    model = MusicgenForConditionalGeneration.from_pretrained(
        args.model_id,
        dtype=torch.float16,
    ).to('cuda')
    inputs = processor(text=[args.prompt], padding=True, return_tensors='pt').to('cuda')
    with torch.no_grad():
        audio = model.generate(
            **inputs,
            max_new_tokens=int(args.duration * 50),
            do_sample=True,
            top_k=args.top_k,
            temperature=args.temperature,
        )
    samples = audio[0, 0].detach().float().cpu().numpy()
    write_wav(args.output, samples)
    print(f'Wrote {args.output}')
    print('MUSICGEN_SMOKE_OK')

if __name__ == '__main__':
    main()
PY
EOF

Generate Smoke Test Audio

Run a quick smoke test with MusicGen-small to verify the complete pipeline:

ssh ubuntu@YOUR_VM_IP 'bash -s' <<'EOF'
set -euxo pipefail
. ~/musicgen-env/bin/activate
cd ~/musicgen
python generate.py 'lo-fi hip hop beat, mellow piano' \
  --duration 4 \
  --output outputs/smoke_test.wav
EOF

Look for the MUSICGEN_SMOKE_OK confirmation message.

Verify Audio Output

Confirm the generated WAV file is valid and contains audio data:

ssh ubuntu@YOUR_VM_IP 'bash -s' <<'EOF'
set -euo pipefail
cd ~/musicgen
ls -lah outputs/smoke_test.wav
python - <<'PY'
import wave
with wave.open('outputs/smoke_test.wav', 'rb') as wf:
    print('WAV', wf.getframerate(), wf.getnchannels(), wf.getnframes())
    assert wf.getframerate() == 32000
    assert wf.getnframes() > 1000
PY
EOF

Scale to Larger Models

After the smoke test passes, generate higher-quality audio with MusicGen-large:

ssh ubuntu@YOUR_VM_IP 'bash -s' <<'EOF'
set -euxo pipefail
. ~/musicgen-env/bin/activate
cd ~/musicgen
python generate.py 'epic orchestral trailer music, rising strings' \
  --model-id facebook/musicgen-large \
  --duration 30 \
  --output outputs/musicgen_large_30s.wav
EOF