最近在音乐制作圈和AI技术圈，一个事件引发了不小的讨论：说唱歌手Fenix Flexin在单曲《Rubberz》的制作中，被质疑使用了AI技术，而他本人对此的态度从最初的否认转向了不再否认。这背后折射出的，是AI生成内容（AIGC）技术，特别是AI音乐生成，正以前所未有的速度渗透到创意产业的核心地带。对于开发者、音乐技术爱好者乃至所有内容创作者而言，这不再是一个遥远的话题，而是一个需要立刻去理解、掌握甚至参与塑造的技术浪潮。

本文将从一个技术实践者的角度，深入探讨AI音乐生成的现状、核心原理、主流工具以及如何从零开始动手实现一个简单的AI音乐生成项目。我们不会停留在事件评论，而是聚焦于“如何做”。无论你是想为你的游戏添加动态配乐的程序员，还是希望探索新创作方式的音乐人，或是单纯对生成式AI技术好奇的开发者，都能从本文中获得一套可复现的技术方案和清晰的行业认知。

1. 背景与核心概念：当AI遇见音乐

在深入代码之前，我们有必要厘清几个关键概念，理解AI音乐生成究竟在做什么，以及Fenix Flexin事件为何具有标志性。

1.1 什么是AI音乐生成？

简单来说，AI音乐生成是指利用人工智能算法，自动或半自动地创作出音乐旋律、和声、节奏乃至完整编曲的过程。它不同于简单的音频拼接或采样，其核心在于模型从海量音乐数据中学习到了音乐的内在规律（如音高、时值、和弦进行、乐器搭配等），并能够根据给定的“提示”（如风格、情绪、几个音符）生成符合音乐逻辑的全新内容。

从技术范式上，主要分为两类：

1. 符号音乐生成：将音乐表示为离散的符号序列，如MIDI格式（包含音符、力度、音轨等信息）。模型学习这些符号序列的统计规律，生成新的符号序列，再通过音源合成音频。这种方式生成效率高，易于控制和编辑，但音质依赖合成器。
2. 音频直接生成：直接对原始音频波形或频谱（如梅尔频谱）进行建模和生成。这种方式可以生成带有人声、特殊音效的复杂音频，音质可以很高，但对算力要求极大，且可控性相对较差。

目前，结合两者优势的混合方法（如先生成MIDI，再通过高质量合成器或声码器转换为音频）正成为主流。

1.2 Fenix Flexin与《Rubberz》事件的启示

虽然事件细节众说纷纭，但其象征意义大于事实本身。它标志着：

• 技术成熟度临界点：AI生成音乐的质量已经达到了足以“以假乱真”、引发行业讨论和听众困惑的水平。
• 创作伦理前沿：关于创作主权、艺术家人设、作品“真实性”的争论，从文字、绘画正式蔓延至音乐领域。
• 开发者新机遇：音乐产业的生产工具链正在被重构。围绕AI音乐的工具开发、平台服务、个性化应用（如短视频配乐、游戏动态音乐）将成为新的技术热点。

1.3 核心应用场景

理解场景有助于我们定位技术方向：

• 辅助创作：为创作者提供灵感片段、生成伴奏带、自动配和声。
• 内容生产：为视频平台、播客、游戏批量生成无版权问题的背景音乐（BGM）。
• 个性化体验：根据用户实时心率、运动状态生成匹配情绪的运动音乐；根据故事情节生成交互式电影配乐。
• 教育与分析：生成特定风格的音乐用于教学；分析AI生成曲目与人类作品的差异。

2. 环境准备与工具选型

在动手之前，我们需要搭建一个可以进行AI音乐生成实验的环境。考虑到易用性和社区活跃度，我们将以Python为核心，选择主流框架和库。

2.1 基础环境配置

操作系统：推荐 Linux (Ubuntu 20.04+) 或 macOS，Windows也可行但可能在某些音频处理库上遇到更多配置问题。Python版本：3.8 或 3.9（与多数深度学习框架兼容性最好）。包管理工具：pip或conda。

2.2 核心Python库安装

我们将使用一个虚拟环境来管理依赖。以下是核心库及其作用：

# 创建并激活虚拟环境（以conda为例） conda create -n ai_music python=3.9 conda activate ai_music # 安装核心科学计算和深度学习框架 pip install numpy pandas matplotlib # 基础数据处理与可视化 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu # PyTorch (此处以CPU版本为例，GPU版本请参考官网) pip install tensorflow # 可选，部分工具依赖 # 安装音乐处理专用库 pip install pretty_midi # MIDI文件读写和操作的神器 pip install mido # 另一个轻量级MIDI库 pip install music21 # 音乐学分析、生成和转换（功能强大） pip install librosa # 音频分析和处理，如提取梅尔频谱 pip install fluidsynth # 将MIDI合成音频（需要SoundFont文件） pip install pydub # 音频文件格式转换和简单处理 # 安装深度学习相关工具 pip install transformers # Hugging Face，用于使用预训练模型 pip install datasets # 方便地加载数据集

版本说明：以上库的版本迭代较快，本文重点在于提供一套可行的工具组合和思路。如果遇到版本冲突，可以尝试指定稍早的稳定版本（如pip install pretty_midi==0.2.9），或查阅其官方文档。

2.3 开发工具与资源

• IDE：VS Code、PyCharm 或 Jupyter Notebook（非常适合分步实验）。
• 数据集：实验需要音乐数据。可以从以下途径获取：
  • MAESTRO Dataset：包含钢琴演奏的MIDI和音频对齐数据。
  • Lakh MIDI Dataset：一个大规模的多流派MIDI文件集合。
  • 网络资源：许多网站提供免费MIDI文件，可用于学习和测试。
• SoundFont文件：用于fluidsynth将MIDI转为高质量音频。推荐“FluidR3_GM.sf2”，这是一个通用的GM音色库，可以在网上搜索下载。

3. 核心原理与模型架构拆解

AI音乐生成模型的核心是序列生成模型。我们以最经典的“符号音乐生成”为例，拆解其技术原理。

3.1 音乐的表征：从音频到数据

计算机不理解音乐，只理解数字。因此，第一步是将音乐“编码”成模型能处理的格式。

MIDI表示法： 一个MIDI文件可以看作一个事件序列。每个事件包括：

• 音符开：[时间戳， 通道， 音符编号（音高）， 力度]
• 音符关：[时间戳， 通道， 音符编号， 0]
• 控制变更：如音量、踏板。 我们可以将一首曲子扁平化为一个长长的事件序列，作为模型的训练数据。

使用pretty_midi加载和查看MIDI：

import pretty_midi # 加载一个MIDI文件 midi_data = pretty_midi.PrettyMIDI('example.mid') # 打印所有乐器（音轨） for i, instrument in enumerate(midi_data.instruments): print(f'Instrument {i}: {instrument.name}') for note in instrument.notes: # note包含：start, end, pitch, velocity print(f' Note: pitch={note.pitch}, start={note.start:.2f}, end={note.end:.2f}')

3.2 模型架构：循环神经网络与Transformer

1. RNN/LSTM/GRU：早期主流选择。它们能很好地处理序列数据，记忆之前的音符信息来预测下一个音符。但存在长程依赖问题，生成的音乐结构可能不够宏大。

   # 简化的LSTM模型结构示意 import torch.nn as nn class MusicLSTM(nn.Module): def __init__(self, input_size, hidden_size, output_size, num_layers=2): super().__init__() self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) self.fc = nn.Linear(hidden_size, output_size) def forward(self, x, hidden=None): lstm_out, hidden = self.lstm(x, hidden) output = self.fc(lstm_out) return output, hidden

2. Transformer：当前的主流和SOTA。依靠自注意力机制，能同时关注序列中所有位置的信息，非常适合音乐这种具有复杂和声与对位关系的序列。GPT（生成式预训练Transformer）系列模型在音乐生成上取得了惊人效果。

   • 核心：将音符事件当作“词元”，使用类似自然语言处理的方法进行训练和生成。
   • 优势：生成质量高，音乐结构连贯，能学习到复杂的音乐模式。

3.3 生成策略：自回归采样

无论是RNN还是Transformer，在生成时通常采用自回归方式：

1. 给定一个起始符（如代表“歌曲开始”的特殊符号）。
2. 将当前序列输入模型，模型输出下一个可能事件（音符）的概率分布。
3. 根据这个分布采样一个事件，添加到序列末尾。
4. 重复步骤2-3，直到生成结束符或达到预定长度。采样策略（如贪婪采样、核采样、温度采样）直接影响生成结果的“创造性”和“稳定性”。

4. 完整实战案例：构建一个简易的钢琴旋律生成器

我们将使用一个简化流程，基于LSTM模型，训练一个能够生成简短钢琴旋律的AI。

4.1 项目结构与数据准备

ai_music_project/ ├── data/ │ ├── raw_midi/ # 存放原始的MIDI文件 │ └── processed/ # 存放处理后的数据 ├── models/ # 模型定义代码 ├── utils/ # 数据处理工具函数 ├── train.py # 训练脚本 ├── generate.py # 生成脚本 └── requirements.txt

数据预处理脚本utils/data_preprocessor.py：

import os import pickle import numpy as np import pretty_midi from collections import Counter def load_and_process_midi(midi_path, seq_length=100): """加载单个MIDI文件，并将其转换为模型可用的数字序列""" try: pm = pretty_midi.PrettyMIDI(midi_path) notes = [] # 这里简化处理：只取第一个钢琴音轨的音符，并按时间排序 for instrument in pm.instruments: if instrument.is_drum == False and instrument.name.lower().find('piano') != -1: for note in instrument.notes: # 将音符信息编码为一个数字（简化版：只编码音高） # 更复杂的编码可以包含时长、力度等 notes.append(note.pitch) break # 只取第一个钢琴音轨 if len(notes) < seq_length + 1: return None return notes except Exception as e: print(f"Error processing {midi_path}: {e}") return None def create_sequences(notes, vocab_size, seq_length=100): """将音符列表转换为输入（X）和目标（y）序列对""" note_to_int = {note: i for i, note in enumerate(sorted(set(notes)))} int_to_note = {i: note for note, i in note_to_int.items()} network_input = [] network_output = [] for i in range(0, len(notes) - seq_length, 1): seq_in = notes[i:i + seq_length] seq_out = notes[i + seq_length] network_input.append([note_to_int[char] for char in seq_in]) network_output.append(note_to_int[seq_out]) n_patterns = len(network_input) # 将输入 reshape 成 [样本数, 序列长度, 1]，并归一化 X = np.reshape(network_input, (n_patterns, seq_length, 1)) X = X / float(vocab_size) # 归一化到0-1之间 # 将输出进行one-hot编码 y = np.zeros((n_patterns, vocab_size)) for i, note_index in enumerate(network_output): y[i, note_index] = 1 return X, y, note_to_int, int_to_note def prepare_data(data_dir, seq_length=100): """批量处理数据目录下的所有MIDI文件""" all_notes = [] for file in os.listdir(data_dir): if file.endswith('.mid') or file.endswith('.midi'): notes = load_and_process_midi(os.path.join(data_dir, file), seq_length) if notes: all_notes.extend(notes) if not all_notes: raise ValueError("No valid MIDI data found!") # 创建词汇表 vocab = sorted(set(all_notes)) vocab_size = len(vocab) print(f'Total notes: {len(all_notes)}') print(f'Unique notes (vocab size): {vocab_size}') X, y, note_to_int, int_to_note = create_sequences(all_notes, vocab_size, seq_length) print(f'Total training sequences (patterns): {len(X)}') # 保存处理好的数据和映射字典 with open('processed/data.pkl', 'wb') as f: pickle.dump((X, y, note_to_int, int_to_note, vocab_size), f) return X, y, note_to_int, int_to_note, vocab_size

4.2 模型定义

模型文件models/lstm_model.py：

import torch import torch.nn as nn class MelodyLSTM(nn.Module): def __init__(self, input_size, hidden_size, output_size, num_layers=2, dropout=0.3): super(MelodyLSTM, self).__init__() self.hidden_size = hidden_size self.num_layers = num_layers self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True, dropout=dropout if num_layers>1 else 0) self.dropout = nn.Dropout(dropout) self.fc = nn.Linear(hidden_size, output_size) self.softmax = nn.LogSoftmax(dim=1) # 用于生成概率分布 def forward(self, x, hidden=None): # x shape: (batch_size, seq_length, input_size) lstm_out, hidden = self.lstm(x, hidden) # lstm_out shape: (batch_size, seq_length, hidden_size) # 我们只取最后一个时间步的输出 last_out = lstm_out[:, -1, :] out = self.dropout(last_out) out = self.fc(out) out = self.softmax(out) return out, hidden def init_hidden(self, batch_size, device): # 初始化隐藏状态 weight = next(self.parameters()).data hidden = (weight.new(self.num_layers, batch_size, self.hidden_size).zero_().to(device), weight.new(self.num_layers, batch_size, self.hidden_size).zero_().to(device)) return hidden

4.3 训练脚本

训练脚本train.py：

import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset import numpy as np from models.lstm_model import MelodyLSTM from utils.data_preprocessor import prepare_data import os # 超参数配置 SEQ_LENGTH = 100 HIDDEN_SIZE = 256 NUM_LAYERS = 2 DROPOUT = 0.3 BATCH_SIZE = 64 EPOCHS = 50 LEARNING_RATE = 0.001 DATA_DIR = 'data/raw_midi' # 设备配置 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(f'Using device: {device}') # 1. 准备数据 print("Preparing data...") X, y, note_to_int, int_to_note, VOCAB_SIZE = prepare_data(DATA_DIR, SEQ_LENGTH) INPUT_SIZE = 1 # 我们的输入是归一化后的单个数字 # 转换为PyTorch张量 X_tensor = torch.FloatTensor(X).to(device) y_tensor = torch.LongTensor(np.argmax(y, axis=1)).to(device) # 将one-hot转回索引 dataset = TensorDataset(X_tensor, y_tensor) dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True) # 2. 初始化模型、损失函数和优化器 model = MelodyLSTM(INPUT_SIZE, HIDDEN_SIZE, VOCAB_SIZE, NUM_LAYERS, DROPOUT).to(device) criterion = nn.NLLLoss() # 负对数似然损失，与LogSoftmax配合 optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE) # 3. 训练循环 print("Starting training...") for epoch in range(EPOCHS): model.train() total_loss = 0 for batch_x, batch_y in dataloader: optimizer.zero_grad() hidden = model.init_hidden(batch_x.size(0), device) # batch_x shape: [batch, seq, 1] output, hidden = model(batch_x, hidden) loss = criterion(output, batch_y) loss.backward() # 梯度裁剪，防止爆炸 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5) optimizer.step() total_loss += loss.item() * batch_x.size(0) avg_loss = total_loss / len(dataset) if (epoch + 1) % 5 == 0: print(f'Epoch [{epoch+1}/{EPOCHS}], Average Loss: {avg_loss:.4f}') # 4. 保存模型和词汇映射 os.makedirs('saved_models', exist_ok=True) torch.save(model.state_dict(), 'saved_models/melody_lstm.pth') with open('saved_models/vocab.pkl', 'wb') as f: import pickle pickle.dump((note_to_int, int_to_note, VOCAB_SIZE), f) print("Training finished. Model saved.")

4.4 生成脚本

生成脚本generate.py：

import torch import numpy as np import pickle from models.lstm_model import MelodyLSTM import pretty_midi def generate_melody(model, seed_sequence, note_to_int, int_to_note, length=500, temperature=1.0): """根据种子序列生成新的旋律""" model.eval() generated = list(seed_sequence) input_seq = seed_sequence.copy() VOCAB_SIZE = len(note_to_int) with torch.no_grad(): for _ in range(length): # 准备输入 x = np.reshape(input_seq, (1, len(input_seq), 1)) x = x / float(VOCAB_SIZE) x_tensor = torch.FloatTensor(x).to(device) # 预测下一个音符 hidden = model.init_hidden(1, device) output, hidden = model(x_tensor, hidden) output = output.squeeze().cpu().numpy() # 应用温度采样 output = np.exp(output / temperature) output = output / np.sum(output) predicted_note_idx = np.random.choice(range(VOCAB_SIZE), p=output) # 将预测的音符添加到生成序列中 predicted_note = int_to_note[predicted_note_idx] generated.append(predicted_note) # 更新输入序列（滑动窗口） input_seq.append(predicted_note) input_seq = input_seq[1:] return generated def notes_to_midi(notes, output_path='generated_melody.mid', tempo=120): """将音符列表转换为MIDI文件""" pm = pretty_midi.PrettyMIDI() piano_program = pretty_midi.instrument_name_to_program('Acoustic Grand Piano') piano = pretty_midi.Instrument(program=piano_program) # 简化：每个音符固定时值和力度 note_duration = 0.5 # 半拍 velocity = 100 current_time = 0.0 for pitch in notes: # 创建音符事件 note = pretty_midi.Note(velocity=velocity, pitch=pitch, start=current_time, end=current_time + note_duration) piano.notes.append(note) current_time += note_duration pm.instruments.append(piano) pm.write(output_path) print(f'MIDI file saved to {output_path}') if __name__ == '__main__': device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # 加载模型和词汇表 with open('saved_models/vocab.pkl', 'rb') as f: note_to_int, int_to_note, VOCAB_SIZE = pickle.load(f) INPUT_SIZE = 1 HIDDEN_SIZE = 256 NUM_LAYERS = 2 DROPOUT = 0.3 model = MelodyLSTM(INPUT_SIZE, HIDDEN_SIZE, VOCAB_SIZE, NUM_LAYERS, DROPOUT).to(device) model.load_state_dict(torch.load('saved_models/melody_lstm.pth', map_location=device)) # 选择一个种子序列（可以从训练数据中随机取，或手动指定） # 这里手动指定一个简单的C大调音阶开头 seed_notes = [60, 62, 64, 65, 67, 69, 71, 72] # C4, D4, E4, F4, G4, A4, B4, C5 # 将种子音符转换为模型内部的整数索引 seed_sequence = [note_to_int.get(n, 0) for n in seed_notes] # 如果种子音符不在词汇表，用0代替 # 生成旋律 print("Generating melody...") generated_note_indices = generate_melody(model, seed_sequence, note_to_int, int_to_note, length=100, temperature=0.8) generated_notes = [int_to_note[i] for i in generated_note_indices] # 保存为MIDI notes_to_midi(generated_notes, 'output/generated_song.mid') print("Generation complete!")

4.5 运行与结果说明

1. 准备数据：将一些钢琴曲的MIDI文件放入data/raw_midi/目录。
2. 训练模型：在项目根目录运行python train.py。这个过程可能需要一段时间，取决于数据量和你的硬件。
3. 生成音乐：训练完成后，运行python generate.py。它将以一个简单的C大调音阶为“提示”，生成一段新的旋律，并保存为output/generated_song.mid。
4. 聆听结果：使用MIDI播放器（如DAW软件Ableton Live, FL Studio，或简单的播放器Timidity）打开生成的.mid文件。你也可以使用fluidsynth将其转换为WAV：

   fluidsynth -ni your_soundfont.sf2 output/generated_song.mid -F output/generated_song.wav -r 44100

预期与局限：

• 预期：生成的旋律在音高上会遵循训练数据中的统计规律，听起来像是一段“合理”的、风格接近训练集的钢琴片段。
• 局限：这个模型极其简化。它只学习了音高序列，忽略了节奏、和弦、多声部、乐曲结构等关键音乐元素。因此，生成的音乐可能单调、缺乏节奏感。但这正是你理解AI音乐生成起点的一个完美范例。

5. 常见问题与排查思路

在实践AI音乐生成项目时，你可能会遇到以下典型问题：

6. 进阶方向与工程最佳实践

完成基础实践后，你可以从以下几个方向深入，打造更专业、实用的AI音乐生成系统。

6.1 使用更先进的模型与框架

• Transformer模型：放弃LSTM，使用GPT-2或Music Transformer等架构。你可以使用Hugging Face的transformers库，甚至能找到社区开源的预训练音乐模型（如MuseNet、Jukebox的简化版实现）。
• 扩散模型：在音频直接生成领域，扩散模型（如AudioLDM, MusicGen）已成为新的SOTA。它们能生成高质量、富有细节的音频，但计算成本极高。
• 专用库：探索像Magenta(Google)、Muzic(微软) 这样的开源研究项目，它们提供了从符号生成到音频合成的完整工具链和预训练模型。

6.2 改进音乐表征

我们之前的例子只用了音高，这是远远不够的。一个完整的符号表征应包括：

• 节奏（时值）：将音符的开始时间和持续时间离散化。
• 和弦：将和弦作为单独的事件或同时触发的音符组。
• 音乐结构：引入“小节线”、“段落开始/结束”等结构标记。
• 多音轨：同时处理多个乐器音轨。

一种常见的做法是使用REMI或Compound Word等tokenization方法，将丰富的音乐信息编码成一个单一的token序列，然后交给Transformer模型处理。

6.3 引入控制与交互性

让AI不只是随机生成，而是成为“合作者”：

• 条件生成：在生成时输入条件，如“风格=爵士乐”、“情绪=欢快”、“和弦进行=C-G-Am-F”。这需要在训练数据中标注这些属性，并在模型输入中加入条件向量。
• 交互式生成：开发一个实时系统，用户弹奏几个音符，AI立即续写。这需要模型能快速进行前向推理（推理优化），并可能用到“前缀调优”技术。
• A/B测试与迭代：建立一套评估生成音乐质量的指标（可以是基于规则的，如音程和谐度；也可以是基于学习的，如使用一个鉴别器网络），让模型在生成-评估的循环中自我改进。

6.4 工程化与部署考量

如果计划将项目产品化：

• 数据管道：构建自动化的数据爬取、清洗、预处理和增强管道。
• 模型服务化：使用FastAPI或Flask将模型封装成REST API，提供“生成”端点。
• 前端界面：开发一个简单的Web界面，让用户选择风格、输入和弦、试听并下载生成结果。
• 性能优化：对模型进行量化、剪枝或转换为ONNX格式，以加速推理，满足实时性要求。
• 版权与伦理：务必使用有明确授权可用于AI训练的数据集。对于生成结果，要明确告知用户其AI生成属性，并制定清晰的使用条款，规避法律风险。

从Fenix Flexin的案例到我们亲手搭建的简易生成器，AI音乐生成的技术脉络已经清晰可见。它不再是科幻概念，而是由数据、算法和代码构成的、可被理解和构建的工程系统。对于开发者而言，最大的优势在于我们不仅能使用这些工具，更能深入其原理，并根据具体需求进行定制和创造。

下一步，我建议你：

1. 丰富数据集：用更多样、更高质量的音乐数据训练你的模型。
2. 升级模型：尝试用一个小型的Transformer（如GPT-2 small）替换LSTM，感受生成质量的提升。
3. 完善表征：实现一个包含音高、时值、力度的完整REMI编码器。
4. 探索应用：思考如何将它用于你的具体场景，比如为你的独立游戏生成独一无二的背景音乐循环。

技术的边界正在被不断拓宽，而创造的工具正变得前所未有的平民化。掌握它，理解它，然后明智地使用它，或许是这个时代给每一位技术创作者的新命题。