AI 音乐生成与实时交互：从 MIDI 控制到现场表演的工程实现

键盘鼓手苏苏

1093人浏览 · 2026-06-12 10:30:10

键盘鼓手苏苏 · 2026-06-12 10:30:10 发布

AI 音乐生成与实时交互：从 MIDI 控制到现场表演的工程实现

一、AI 音乐的"延迟鸿沟"：离线生成 vs 实时响应

AI 音乐生成在离线场景下已取得显著进展，但实时交互场景对延迟提出了严苛要求。某现场演出中，AI 系统需要根据鼓手的节奏实时生成和声伴奏，但模型推理延迟 800ms，导致伴奏与鼓点严重脱节。音乐表演的延迟容忍度极低：人耳对 20ms 以上的延迟即可感知，50ms 以上明显影响节奏感。

实时 AI 音乐生成的工程挑战在于：在极低延迟（< 20ms）的约束下完成模型推理、MIDI 事件处理和音频合成三个环节。这需要从模型架构、推理优化和音频管线三个层面协同设计。

二、实时 AI 音乐交互的管线架构

flowchart LR
    subgraph 输入层["实时输入"]
        A1[MIDI 控制器<br/>Note On/Off + CC]
        A2[音频输入<br/>乐器拾音]
        A3[传感器<br/>力度/踏板/手势]
    end

    subgraph 处理层["AI 处理管线"]
        B1[事件预处理<br/>量化 + 去抖<br/>< 2ms]
        B2[节奏追踪<br/>BPM 检测 + 节拍预测<br/>< 5ms]
        B3[和声生成<br/>轻量模型推理<br/>< 10ms]
        B4[MIDI 生成<br/>音符 + 力度 + 时值<br/>< 1ms]
    end

    subgraph 输出层["音频输出"]
        C1[软件合成器<br/>SF2/SFZ 采样回放<br/>< 5ms]
        C2[硬件合成器<br/>MIDI OUT<br/>< 1ms]
    end

    A1 --> B1 --> B2 --> B3 --> B4 --> C1
    A2 --> B2
    A3 --> B1
    B4 --> C2

    style 输入层 fill:#eef,stroke:#333
    style 处理层 fill:#fee,stroke:#333
    style 输出层 fill:#efe,stroke:#333

三、实时 AI 音乐交互的代码实现

from dataclasses import dataclass, field
from typing import List, Dict, Optional, Callable, Tuple
from enum import Enum
from collections import deque
from datetime import datetime
import time
import struct


class MidiMessageType(Enum):
    NOTE_ON = 0x90
    NOTE_OFF = 0x80
    CONTROL_CHANGE = 0xB0
    PROGRAM_CHANGE = 0xC0
    PITCH_BEND = 0xE0


@dataclass
class MidiEvent:
    """MIDI 事件"""
    message_type: MidiMessageType
    channel: int
    data1: int          # 音符号 / 控制器号
    data2: int          # 力度 / 控制值
    timestamp: float    # 秒（相对时间）


@dataclass
class ChordProgression:
    """和弦进行"""
    chords: List[str]           # ["Cmaj7", "Dm7", "G7", "Cmaj7"]
    beats_per_chord: int = 4    # 每和弦拍数
    current_index: int = 0
    current_beat: int = 0


@dataclass
class RhythmState:
    """节奏状态"""
    bpm: float = 120.0
    time_signature: Tuple[int, int] = (4, 4)
    current_beat: float = 0.0
    last_beat_time: float = 0.0
    beat_history: deque = field(default_factory=lambda: deque(maxlen=32))


class BeatTracker:
    """
    节拍追踪器：从 MIDI 输入中检测 BPM 和节拍位置
    基于 onset 检测和自相关算法
    """

    def __init__(self, sample_rate: int = 44100):
        self._onset_times: deque = deque(maxlen=64)
        self._bpm: float = 120.0
        self._last_onset: float = 0.0

    def process_note_on(self, event: MidiEvent) -> Optional[float]:
        """处理 Note On 事件，更新 BPM 估计"""
        current_time = event.timestamp

        if event.data2 < 30:  # 忽略极低力度
            return None

        # 记录 onset 时间
        if self._last_onset > 0:
            interval = current_time - self._last_onset
            if 0.1 < interval < 2.0:  # 合理的节拍间隔
                self._onset_times.append(interval)

        self._last_onset = current_time

        # 估计 BPM
        if len(self._onset_times) >= 4:
            avg_interval = sum(self._onset_times) / len(self._onset_times)
            estimated_bpm = 60.0 / avg_interval

            # BPM 合理性检查
            if 40 < estimated_bpm < 240:
                # 平滑更新
                self._bpm = 0.7 * self._bpm + 0.3 * estimated_bpm

        return self._bpm

    @property
    def bpm(self) -> float:
        return self._bpm

    def get_beat_phase(self, current_time: float) -> float:
        """获取当前节拍相位（0-1）"""
        beat_duration = 60.0 / self._bpm
        return (current_time % beat_duration) / beat_duration


class RealtimeHarmonyGenerator:
    """
    实时和声生成器：基于输入音符和和弦进行生成伴奏
    使用轻量级规则引擎 + 预计算查找表，避免重型模型推理
    """

    # 和弦音程映射（半音偏移）
    CHORD_INTERVALS = {
        "maj": [0, 4, 7],
        "min": [0, 3, 7],
        "7": [0, 4, 7, 10],
        "maj7": [0, 4, 7, 11],
        "min7": [0, 3, 7, 10],
        "dim": [0, 3, 6],
        "aug": [0, 4, 8],
    }

    # 根音到 MIDI 音符号的映射
    ROOT_NOTES = {
        "C": 60, "C#": 61, "Db": 61, "D": 62, "D#": 63,
        "Eb": 63, "E": 64, "F": 65, "F#": 66, "Gb": 66,
        "G": 67, "G#": 68, "Ab": 68, "A": 69, "A#": 70,
        "Bb": 70, "B": 71,
    }

    def __init__(self):
        self._progression = ChordProgression(
            chords=["Cmaj7", "Dm7", "G7", "Cmaj7"]
        )
        self._velocity_scale = 0.7  # 伴奏力度缩放
        self._octave_offset = -1    # 伴奏比主旋律低一个八度

    def set_progression(self, chords: List[str], beats_per_chord: int = 4):
        """设置和弦进行"""
        self._progression = ChordProgression(
            chords=chords,
            beats_per_chord=beats_per_chord,
        )

    def generate_accompaniment(self, input_note: int,
                                beat_phase: float,
                                bpm: float) -> List[MidiEvent]:
        """
        根据输入音符和当前节拍生成伴奏
        使用预计算的和弦音，避免实时推理
        """
        events = []
        current_chord = self._get_current_chord()
        chord_notes = self._parse_chord(current_chord)

        # 根据节拍相位决定伴奏模式
        if beat_phase < 0.1:
            # 强拍：播放和弦根音
            root = chord_notes[0] + 12 * self._octave_offset
            events.append(MidiEvent(
                message_type=MidiMessageType.NOTE_ON,
                channel=1,
                data1=root,
                data2=int(80 * self._velocity_scale),
                timestamp=time.time(),
            ))

        elif 0.45 < beat_phase < 0.55:
            # 弱拍：播放和弦三音或七音
            if len(chord_notes) > 2:
                note = chord_notes[2] + 12 * self._octave_offset
                events.append(MidiEvent(
                    message_type=MidiMessageType.NOTE_ON,
                    channel=1,
                    data1=note,
                    data2=int(60 * self._velocity_scale),
                    timestamp=time.time(),
                ))

        return events

    def _get_current_chord(self) -> str:
        """获取当前和弦"""
        return self._progression.chords[
            self._progression.current_index
            % len(self._progression.chords)
        ]

    def _parse_chord(self, chord_name: str) -> List[int]:
        """解析和弦名称为 MIDI 音符列表"""
        # 解析根音和类型
        if len(chord_name) >= 2 and chord_name[1] in "#b":
            root = chord_name[:2]
            chord_type = chord_name[2:]
        else:
            root = chord_name[:1]
            chord_type = chord_name[1:]

        root_note = self.ROOT_NOTES.get(root, 60)
        intervals = self.CHORD_INTERVALS.get(chord_type, [0, 4, 7])

        return [root_note + interval for interval in intervals]

    def advance_beat(self):
        """推进节拍"""
        self._progression.current_beat += 1
        if self._progression.current_beat >= self._progression.beats_per_chord:
            self._progression.current_beat = 0
            self._progression.current_index = (
                (self._progression.current_index + 1)
                % len(self._progression.chords)
            )


class AudioPipeline:
    """
    音频管线：管理 MIDI 到音频的实时转换
    核心约束：端到端延迟 < 20ms
    """

    def __init__(self, buffer_size: int = 256, sample_rate: int = 44100):
        self._buffer_size = buffer_size
        self._sample_rate = sample_rate
        self._buffer_duration_ms = buffer_size / sample_rate * 1000
        self._active_notes: Dict[int, float] = {}  # note -> velocity

    def get_latency_budget(self) -> Dict[str, float]:
        """获取各环节延迟预算"""
        total_budget = 20.0  # 总预算 20ms
        return {
            "midi_preprocessing": 1.0,
            "beat_tracking": 3.0,
            "harmony_generation": 5.0,
            "midi_output": 1.0,
            "audio_synthesis": 5.0,
            "buffer_latency": self._buffer_duration_ms,
            "total": (
                1.0 + 3.0 + 5.0 + 1.0 + 5.0 + self._buffer_duration_ms
            ),
        }

    def note_on(self, note: int, velocity: int):
        """激活音符"""
        self._active_notes[note] = velocity / 127.0

    def note_off(self, note: int):
        """释放音符"""
        self._active_notes.pop(note, None)

    def render_buffer(self) -> bytes:
        """渲染一个音频缓冲区（简化版正弦波合成）"""
        samples = []
        for i in range(self._buffer_size):
            sample = 0.0
            for note, velocity in self._active_notes.items():
                # 简单正弦波合成
                freq = 440.0 * (2.0 ** ((note - 69) / 12.0))
                t = i / self._sample_rate
                sample += velocity * 0.3 * (
                    0.6 * (2 * (freq * t % 1) - 1)  # 锯齿波近似
                )
            # 限幅
            sample = max(-1.0, min(1.0, sample))
            # 16bit PCM
            samples.append(struct.pack("<h", int(sample * 32767)))

        return b"".join(samples)


class RealtimeMusicSystem:
    """
    实时音乐系统：整合节拍追踪、和声生成和音频输出
    """

    def __init__(self):
        self._beat_tracker = BeatTracker()
        self._harmony_gen = RealtimeHarmonyGenerator()
        self._audio_pipeline = AudioPipeline()
        self._running = False

    def process_midi_input(self, event: MidiEvent):
        """处理 MIDI 输入事件"""
        if event.message_type == MidiMessageType.NOTE_ON:
            # 节拍追踪
            bpm = self._beat_tracker.process_note_on(event)

            # 和声生成
            if bpm:
                beat_phase = self._beat_tracker.get_beat_phase(event.timestamp)
                accompaniment = self._harmony_gen.generate_accompaniment(
                    input_note=event.data1,
                    beat_phase=beat_phase,
                    bpm=bpm,
                )
                return accompaniment

        return []

    def get_system_status(self) -> Dict:
        """获取系统状态"""
        return {
            "bpm": self._beat_tracker.bpm,
            "latency_budget": self._audio_pipeline.get_latency_budget(),
            "active_notes": len(self._audio_pipeline._active_notes),
        }

四、实时 AI 音乐交互的 Trade-offs

模型复杂度与延迟的矛盾。大型 Transformer 模型生成的音乐质量更高，但推理延迟远超实时要求。当前工程折中方案是：离线用大模型生成和弦进行和旋律模板，实时用轻量规则引擎执行。这牺牲了实时生成的多样性，但保证了延迟可控。

MIDI 量化的精度损失。节拍量化将自由节奏映射到网格上，会丢失演奏的微妙节奏变化（如 Swing、Rubato）。量化精度越高，延迟越大（需要等待更多输入来判断节拍位置）。现场表演中，通常选择粗量化（1/8 音符网格）以降低延迟。

音频缓冲区大小的权衡。缓冲区越小，延迟越低，但 CPU 占用越高且容易出现爆音。256 采样（约 5.8ms @44.1kHz）是常见的折中值。在性能受限的设备上，可能需要增大到 512 或 1024 采样，代价是延迟翻倍。

多通道并发的资源竞争。实时音频线程需要最高优先级，AI 推理和 MIDI 处理不能阻塞音频渲染。解决方案是将 AI 推理放在独立线程，通过无锁队列传递生成结果。但线程间通信引入了额外延迟和同步复杂度。

五、总结

实时 AI 音乐交互的核心工程挑战是在 20ms 延迟预算内完成事件预处理、节拍追踪、和声生成和音频合成。节拍追踪器从 MIDI 输入中估计 BPM 和节拍相位，和声生成器基于预计算查找表生成伴奏（避免重型模型推理），音频管线管理 MIDI 到音频的实时转换。关键权衡在于模型复杂度与延迟、MIDI 量化精度与延迟、音频缓冲区大小与 CPU 占用，以及多通道并发的资源竞争。实时音乐系统的设计哲学是：离线生成策略，实时执行决策。