Решения

Музыкальные модели на GPU: генерация и демиксинг

Задача страницы. Инженерный гид по развёртыванию Music ML на GPU: генерация музыки (text/melody/condition‑based), апсемплинг/вокодинг, и демиксинг (stem‑сепарация) для вокала/баса/барабанов/инструментов. Дадим пайплайны (онлайн/батч), таблицу профилей 24/48/80 ГБ, конфиги (Docker/K8s/YAML), наблюдаемость (TTFA/RTF/tokens‑per‑sec/steps‑per‑sec), экономику и траблшутинг. Базовые паттерны: локальный NVMe‑кэш, режимы On‑Demand (низкая латентность) и Interruptible (массовые офлайн‑партии), стриминг через SSE/WebSocket.

TL;DR

  • Два режима:
    • On‑Demand — интерактивная генерация клипов/лупов и предпросмотр; демиксинг коротких отрывков онлайн.
    • Interruptible — массовая генерация каталога/саундпаков, полнотрековый демиксинг со стемами.
  • Генерация: Text→Tokenizer/Фонемы→Acoustic/Latent→Vocoder/Decoder→Post. Управление: жанр, BPM, тональность, «seed», референс‑аудио, MIDI/аккорды.
  • Демиксинг: STFT/SSL→Masker/Separator→iSTFT→стемы (vocals/bass/drums/other…); overlap‑add, loudness‑match.
  • Ключевые метрики: TTFA_gen (до первого аудиофрейма), RTF_gen/RTF_demix, tokens/sec (AR), steps/sec (diffusion), clipping‑rate, LUFS.
  • Тюнинг: FP16/BF16, фьюзинг, TensorRT/ONNX‑сервинг, кэш токенизации и кондишнов на NVMe. См. https://cloudcompute.ru/solutions/performance-tuning/, https://cloudcompute.ru/solutions/fp8-bf16/, https://cloudcompute.ru/solutions/throughput-vs-latency/
  • Экономика: Cost_per_min = (c_gpu * RTF / U) / 60; для демикса многостемного: RTF_total ≈ Σ RTF_stem или меньше при shared‑encoder.
  • Интеграции: ASR/TTS/VC/энхансмент, пайплайны и мониторинг. См. хабы в конце страницы.

Сценарии (когда это нужно)

  • Продакшен/геймдев/медиа: генерация бэков/лупов, вариаций, переходов; пакетный рендер саундпаков.
  • Каталоги/стоки: авто‑теги/жанры, генерация в ключе/темпе по промпту; A/B‑пакеты для отбора качества.
  • Пост‑продакшен: демиксинг для ремиксов/реставрации/караоке; извлечение вокала, барабанов и т. д.
  • Реал‑тайм‑интерактив: предпросмотр и сглаженная догенерация следующего блока (inpainting/continuation) в UI.
  • R&D: сравнение стеков (autoregressive/latent diffusion/DDSP‑класс), LoRA‑адаптации под домен.

Архитектуры и пайплайны

1) Генерация (низкая латентность, стриминг блоками 1–4 с)

				
					Prompt (text/MIDI/chords/ref)
  └─> Normalize/Tokenize/Cond Cache
       └─> GPU: Acoustic/Latent Model (AR или diffusion; stream blocks)
            └─> GPU: Vocoder/Decoder (24–48 kHz, FP16/BF16)
                 └─> Loudness/AGC + Dither
                      └─> Stream Out (SSE/WebSocket, PCM/Opus)

Особенности: TTFA_gen 0.7–2.0 с (зависит от типа модели/шага диффузии), стабильный буфер 200–500 мс, backpressure, кросс‑фейд 5–10 мс между блоками.

2) Демиксинг (стем‑сепарация, офлайн/онлайн)

				
					Audio In
  └─> Preprocess (resample, mono/stereo)
       └─> GPU: Encoder (STFT/SSL)
            └─> GPU: Separator/Masker (N stems)
                 └─> iSTFT/Decoder → Stems (vocals/bass/drums/other,...)
                      └─> Post (loudness match, phase align)
                           └─> Writer (WAV/FLAC + stems.json)

Особенности: overlap‑add для швов, согласование громкости (LUFS), фазовая согласованность каналов.

3) Сервисная шина (мульти‑тенант)

				
					Ingress ─> Auth ─> Router(by tenant/stack) ─> GPU Pools (24/48/80 ГБ)
                                     └─> Autoscaler (по U/RTF/queue)
                                     └─> Policy (контент/контракты)

GPU‑профили и ориентиры

Оценка одновременных потоков реального времени при целевом U≈0.7. Для батчей масштабируйте по «Экономике».

Профиль GPU

Память

Типичные стеки

Реал‑тайм потоки*

Батчи (параллель)

Комментарии

24 ГБ (Compact)

24 ГБ

AR‑класс + HiFi‑GAN‑класс / лёгкий демикс (2‑4 стема)

1–2

2–6

Быстрые предпросмотры/лупы; базовый демикс коротких клипов.

48 ГБ (Balanced)

48 ГБ

Latent/diffusion‑класс + HQ‑вокодер / демикс (4–5 стемов)

2–4

6–12

Баланс качества и скорости, устойчивый p95.

80 ГБ (HQ)

80 ГБ

Крупные diffusion‑стэки (48 кГц) / демикс HQ multi‑stem

4–8

12–24

HQ‑контент, длинные продолжения, сложные материалы.

* Сильно зависит от частоты дискретизации, длины блока, числа шагов диффузии, числа стемов и пост‑процесса.
 См. тюнинг: https://cloudcompute.ru/solutions/performance-tuning/, https://cloudcompute.ru/solutions/fp8-bf16/, https://cloudcompute.ru/solutions/throughput-vs-latency/

Конфиги и скелеты кода

Docker Compose (генерация + демиксинг)

				
					version: "3.9"

x-common-env: &env
  MODELS_DIR: /models
  CACHE_DIR: /var/cache/music
  SAMPLE_RATE: "48000"
  FRAME_SEC: "2.0"            # длина стрим-блока (генерация)
  PRECISION: "fp16"           # bf16|fp16
  STREAM_CODEC: "pcm_s16le"   # или opus
  DIFFUSION_STEPS: "30"       # для diffusion-класса
  AR_MAX_TOKENS: "8192"       # для AR-класса
  DEMIX_STEMS: "vocals,bass,drums,other"

services:
  music-gen-rt:
    image: cloudcompute/music-gen:latest
    environment:
      <<: *env
      SERVICE_MODE: "realtime"
      TTFA_TARGET_MS: "1200"
    deploy:
      resources:
        reservations:
          devices: [{ capabilities: ["gpu"] }]
    ports: ["8060:8060"]
    volumes:
      - /nvme/models:/models
      - /nvme/music-cache:/var/cache/music
    command: ["python", "serve_gen.py", "--host=0.0.0.0", "--port=8060"]

  music-demix-batch:
    image: cloudcompute/music-demix:latest
    environment:
      <<: *env
      SERVICE_MODE: "batch"
      MAX_CHUNK_SECONDS: "120"
      OVERLAP_SECONDS: "0.5"
    deploy:
      resources:
        reservations:
          devices: [{ capabilities: ["gpu"] }]
    volumes:
      - /nvme/models:/models
      - /nvme/music-cache:/var/cache/music
      - /mnt/audio-in:/data/in
      - /mnt/stems-out:/data/out
    command: ["python", "run_demix.py", "--input=/data/in", "--output=/data/out"]

K8s (скелет, 1 GPU/под)

				
					apiVersion: apps/v1
kind: Deployment
metadata:
  name: music-gen-rt
spec:
  replicas: 2
  selector: { matchLabels: { app: music-gen-rt } }
  template:
    metadata:
      labels: { app: music-gen-rt }
    spec:
      containers:
        - name: gen
          image: cloudcompute/music-gen:latest
          ports: [{ containerPort: 8060 }]
          env:
            - { name: PRECISION, value: "fp16" }
            - { name: SAMPLE_RATE, value: "48000" }
            - { name: FRAME_SEC, value: "2.0" }
            - { name: DIFFUSION_STEPS, value: "30" }
          volumeMounts:
            - { name: models, mountPath: /models }
            - { name: cache,  mountPath: /var/cache/music }
          resources:
            limits:
              nvidia.com/gpu: 1
              memory: "24Gi"
              cpu: "4"
      volumes:
        - name: models
          hostPath: { path: /nvme/models }
        - name: cache
          hostPath: { path: /nvme/music-cache }

Конфиг пайплайна (YAML)

				
					pipeline:
  input:
    sample_rate: 48000
    stereo: true
  generation:
    mode: "latent_diffusion"    # latent_diffusion|autoregressive|ddsp_like
    prompt:
      text: "uplifting electronic, 120 BPM, key A minor"
      bpm: 120
      key: "Amin"
      seed: 42
    controls:
      chords_midi: null
      style_ref_wav: null
    sampler:
      steps: 30
      guidance: 3.5
      stream_blocks_sec: 2.0
    vocoder:
      type: "hifigan_like"      # при AR-режиме
      precision: "fp16"
  demix:
    enabled: true
    stems: ["vocals","bass","drums","other"]
    separator: "demucs_like"    # или mask_unet_like
    overlap_sec: 0.5
  post:
    loudness_target_lufs: -14
    dither: true
  output:
    formats: [wav, stems_json]
    stream_codec: pcm_s16le

FastAPI: стриминг генерации (SSE, PCM‑фреймы) и демиксинга (архив стемов)

				
					from fastapi import FastAPI, Body
from sse_starlette.sse import EventSourceResponse
import base64, asyncio, io, zipfile

app = FastAPI()

# --- Generation stream (blocks) ---
async def gen_blocks(prompt_cfg):
    async for block in generate_audio(prompt_cfg):  # 1–4 s PCM48k stereo
        yield base64.b64encode(block).decode("ascii")

@app.post("/music/gen/stream")
async def music_gen_stream(payload: dict = Body(...)):
    cfg = payload.get("config", {})
    async def event_gen():
        async for b64_chunk in gen_blocks(cfg):
            yield {"event": "audio", "data": b64_chunk}
        yield {"event": "done", "data": "{}"}
    return EventSourceResponse(event_gen())

# --- Demix batch (return zip of stems) ---
@app.post("/music/demix")
async def music_demix(payload: dict = Body(...)):
    wav = decode_wav(payload["audio_b64"])
    stems = run_demix(wav, stems=("vocals","bass","drums","other"))
    buf = io.BytesIO()
    with zipfile.ZipFile(buf, "w") as z:
        for name, audio in stems.items():
            z.writestr(f"{name}.wav", encode_wav(audio, sr=48000))
    buf.seek(0)
    return {"stems_zip_b64": base64.b64encode(buf.read()).decode("ascii")}

Батч‑генерация + A/B‑оценка качества (псевдокод)

				
					from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

def render(prompt, cfg):
    wav = generate_full(prompt, cfg)
    return postprocess(wav, lufs=-14)

def batch_generate(prompts, outdir, cfg_a, cfg_b):
    out = Path(outdir); out.mkdir(parents=True, exist_ok=True)
    with ThreadPoolExecutor(max_workers=GPU_PARALLEL) as ex:
        results_a = list(ex.map(lambda p: render(p, cfg_a), prompts))
        results_b = list(ex.map(lambda p: render(p, cfg_b), prompts))
    for i, (wa, wb) in enumerate(zip(results_a, results_b)):
        write_wav(out/f"trk_{i:05d}_A.wav", wa, sr=48000)
        write_wav(out/f"trk_{i:05d}_B.wav", wb, sr=48000)

Наблюдаемость, метрики, алерты

Метрики (Prometheus‑стиль):

  • TTFA_gen: music_ttfa_seconds{mode=rt} — время до первого блока аудио. Цель p95 ≤ 1.5–2.0 с.
  • RTF_gen / RTF_demix: music_rtf{mode=rt|batch} — t_proc / t_audio.
  • Perf: music_tokens_per_sec (AR), music_steps_per_sec (diffusion), music_blocks_per_sec.
  • Audio quality/proxy: music_loudness_lufs, music_clipping_rate, music_spectral_spread, music_onsets_per_min.
  • Stability: music_jitter_ms, music_buffer_underrun_total, music_drop_rate.
  • GPU: music_gpu_utilization, music_gpu_memory_bytes, music_gpu_mem_peak_bytes.
  • I/O: music_nvme_read_mb_s, music_nvme_write_mb_s, hit‑rate кэша токенизации/кондишнов.

Алерты (примеры):

  • ttfa_p95 > 2.0s — уменьшить steps, увеличить буфер, включить подогрев.
  • rtf_p95 > 0.8 в real‑time — упростить стек (AR/меньше шагов), снизить SR, добавить GPU.
  • clipping_rate > 0.01 — нормализация/лимитер/порог генерации.
  • gpu_mem_peak / HBM > 0.9 — уменьшить блок, FP16/BF16, offload, разбить сервисы.

См. хабы: https://cloudcompute.ru/solutions/monitoring-logging/ • https://cloudcompute.ru/solutions/llm-inference/observability/

Экономика и формулы

Обозначения: c_gpu — цена GPU/час, U — целевая загрузка, RTF_gen, RTF_demix.

  • Онлайн‑генерация (стриминг):
     GPU_count = ceil( (Σ RTF_gen_streams) / U ).
  • Демиксинг (N стемов):
     Если отдельные головы без shared‑encoder:
     RTF_total ≈ Σ_i RTF_stem_i.
     При shared‑encoder:
     RTF_total ≈ RTF_encoder + max_i RTF_head_i.
  • Стоимость минуты аудио:
     Cost_per_min = (c_gpu × RTF / U) / 60.
  • Диффузия (оценка RTF):
     RTF_gen ≈ (steps × t_step) / L_audio. Уменьшая steps, снижаете качество/детализацию.
  • Батчи:
     T_batch ≈ (RTF × L_audio_total) / (GPU_count × U).

Оптимизация: микс профилей 24/48/80 ГБ под стек/частоту, батчирование офлайна, NVMe‑кэш кондишнов/эмбеддингов. См. https://cloudcompute.ru/solutions/cost-planner/ и https://cloudcompute.ru/solutions/throughput-vs-latency/

Безопасность/политики

  • Контент и права: храните связи промпт↔аудио↔лицензия, файлы прав/контракты — отдельно; логируйте только необходимые метаданные.
  • Ретеншн: временные WAV/стемы/эмбеддинги — авто‑очистка по TTL; кэш на NVMe.
  • Изоляция: раздельные GPU‑пулы по тенантам/стекам; доступ к бакетам по ролям.
  • Секреты: через Secret‑хранилища/переменные окружения; ротация.
  • Фильтры: базовая валидация входных промптов/референсов (размер/формат/политики контента).

Подробнее: https://cloudcompute.ru/solutions/security/ • https://cloudcompute.ru/solutions/storage-data/

Траблшутинг

Симптом

Возможная причина

Решение

Длинный TTFA

Слишком много шагов диффузии/«холодный» сервис

Подогрев, уменьшить steps, укрупнить блоки/буфер

«Мыльный» звук

Низкая частота/агрессивный денойз после вокодера

Увеличить SR до 48 кГц, смягчить пост‑фильтры

Флэт по громкости

Жёсткий лимитер/неверный LUFS

Калибровать loudness‑таргет (‑14/‑16 LUFS), мягкий лимитер

Повторы/циклы

AR‑инстабилити/слишком длинные фразы

Ограничить max‑tokens, сброс кэш‑состояния, использовать continuation с «seed»

Фазовые артефакты в стемах

Неверный overlap‑add/iSTFT

Увеличить overlap, согласовать окна, фазовые поправки

Утечка инструмента между стемами

Недостаточный контекст/маска

Увеличить окно, усилить модель/регуляризацию, пост‑маскирование

VRAM OOM

Высокий SR/длинные блоки/много стемов

FP16/BF16, уменьшить блоки, разделить сервисы на разные GPU

RTF > SLA

Перегрузка модели/IO

Снизить steps/сложность, уменьшить SR, добавить GPU, улучшить NVMe/сетку

См. также: https://cloudcompute.ru/solutions/performance-tuning/ • https://cloudcompute.ru/solutions/interruptible-patterns/

Как запустить в cloudcompute.ru

  1. Откройте Шаблоны запусков: https://cloudcompute.ru/solutions/templates/
     Выберите Music Generation (Real‑time) или Music Demix (Batch).
  2. Профиль GPU: 24/48/80 ГБ. Для интерактива — AR/latent с низкими steps; для HQ офлайна — diffusion‑класс с 48 кГц и большим числом шагов.
  3. Диски: смонтируйте /nvme/models, /nvme/music-cache; для батчей — /mnt/audio-in и /mnt/stems-out.
  4. Переменные окружения по docker-compose.yml: DIFFUSION_STEPS, AR_MAX_TOKENS, SAMPLE_RATE, DEMIX_STEMS.
  5. Продакшн: автоскейл по U/RTF/queue, отдельные пулы для генерации и демикса, мониторинг/алерты.

Дополнительно:
 https://cloudcompute.ru/solutions/triton-inference-server/ — сервинг через ONNX/TensorRT.
 https://cloudcompute.ru/solutions/gradio-fastapi/ — быстрый UI/эндпойнты.
 https://cloudcompute.ru/solutions/containers-ci-cd/ — сборка и выкладка контейнеров.
 https://cloudcompute.ru/solutions/monitoring-logging/ — мониторинг.
 https://cloudcompute.ru/solutions/llm-inference/observability/ — наблюдаемость инференса.

Чек‑лист перед продом

  • Замерены TTFA_gen p50/p95, RTF_gen/RTF_demix p50/p95, jitter.
  • Выбран стек (AR/latent/diffusion) и SR (24/48 кГц) под SLA.
  • NVMe‑кэш и каталоги примонтированы; кэш токенизации/кондишнов активен.
  • Настроены алерты по TTFA/RTF/HBM/clipping/queue.
  • Оверлап/окна для демикса калиброваны; нет швов и фазовых сдвигов.
  • Политики контента/ретеншна внедрены; секреты — в Secret‑хранилище.
  • Interruptible‑джобы идемпотентны, чанк ≤ 120 с, ретраи настроены.
  • Нагрузочный прогон ≥ 30 мин с целевыми p95 и стабильной громкостью.

Навигация