揭秘 AIGC 领域 AI 作曲的核心算法

揭秘 AIGC 领域 AI 作曲的核心算法：从音符到旋律的魔法工厂

关键词：AI作曲、AIGC、生成模型、音乐表征、RNN、Transformer、GAN

摘要：你是否听过AI生成的音乐？从流行歌曲到古典乐章，AI正用代码“创作”出动人旋律。本文将带你走进AI作曲的核心世界，用“做蛋糕”的故事类比复杂算法，拆解RNN、Transformer、GAN等核心技术如何将数学公式转化为跳动的音符。无论你是音乐爱好者还是技术极客，读完都能理解AI作曲的“魔法原理”。

---

背景介绍

目的和范围

AI作曲是AIGC（人工智能生成内容）的重要分支，本文将聚焦其核心算法原理，覆盖从音乐数据处理到模型生成的全流程，帮助读者理解“AI如何学会写歌”。

预期读者

• 音乐爱好者：想了解AI如何辅助创作
• 技术入门者：对生成模型感兴趣但害怕复杂公式
• 开发者：希望用代码实现简单AI作曲

文档结构概述

本文从“蛋糕店的新学徒”故事切入，逐步讲解音乐数据的“原材料”（音乐表征）、“烹饪工具”（生成模型），再通过代码实战演示AI作曲的具体过程，最后探讨未来趋势。

术语表

• MIDI：音乐设备数字接口（Musical Instrument Digital Interface），用数字信号记录音符、力度等信息（类比“乐谱的电子版”）。
• 钢琴卷帘（Piano Roll）：MIDI的可视化形式，横轴是时间，纵轴是钢琴键，色块表示音符（像“时间-音高的表格”）。
• RNN（循环神经网络）：能记住“过去”的神经网络（类比“会记歌词的歌手”）。
• Transformer：用“注意力”聚焦关键信息的模型（类比“听音乐时自动抓住主歌的听众”）。
• GAN（生成对抗网络）：由“生成器”和“判别器”组成的“对抗训练”模型（类比“互相切磋的作曲家和乐评人”）。

---

核心概念与联系

故事引入：蛋糕店的新学徒——AI如何“学作曲”？

想象你开了一家“旋律蛋糕店”，客人想要定制一首“温暖、带点钢琴前奏的小甜歌”。过去你得自己翻乐谱、试和弦，现在店里来了个AI学徒：

1. 学经验：AI先“读”了10000首经典歌曲的MIDI文件（像学徒背了10000份蛋糕配方）；
2. 找规律：它发现“C大调”的曲子常以“1-3-5”和弦开头（像学徒发现“草莓蛋糕”总用新鲜草莓）；
3. 做新蛋糕：根据规律，AI生成了一首“C大调、钢琴前奏、温暖风格”的新歌（像学徒用新草莓做了创新蛋糕）。

这个过程的关键，就是AI作曲的核心——用生成模型从音乐数据中学习规律，再生成新旋律。

核心概念解释（像给小学生讲故事一样）

核心概念一：音乐表征——AI的“乐谱字典”

AI不会读纸质乐谱，它需要把音乐转换成自己能“看懂”的数字形式，这就是音乐表征。最常用的是MIDI和钢琴卷帘：

• MIDI：就像给每个音符发“身份证”——记录音高（多高的音，比如“中央C”是60）、时长（弹多久，比如0.5秒）、力度（弹多用力，比如80/127）。
• 钢琴卷帘：把MIDI画成表格，横轴是时间（每一格0.25秒），纵轴是钢琴键（从低音到高音）。如果某个时间格的某个琴键被按下，就涂一个色块（像“时间-音高的涂色本”）。

类比：音乐表征就像把蛋糕配方写成“面粉200g、糖50g、烤箱180℃”的数字步骤，AI看了就能“按方做蛋糕”。

核心概念二：生成模型——AI的“作曲大脑”

生成模型是AI的“作曲大脑”，它能从大量音乐数据中学习规律，然后“猜”出下一个音符。常见的有三种：

• RNN（循环神经网络）：像会“记歌词”的大脑。它每一步生成音符时，都会记住之前所有音符（比如前三个音是“1-3-5”，它会记住这个序列，然后预测第四个音可能是“1”或“6”）。
• Transformer：像“抓重点”的听众。它生成音符时，不仅记住之前的音，还能“注意”到更重要的部分（比如主歌的旋律比伴奏更关键，就多关注主歌的历史音符）。
• GAN（生成对抗网络）：像“互相较劲”的两人组。一个“生成器”拼命写旋律，另一个“判别器”拼命挑毛病（“这旋律太老套！”），两人越斗越厉害，最后生成器能写出连判别器都辨不出真假的好旋律。

核心概念三：损失函数——AI的“纠错老师”

AI作曲不是一步到位的，它需要“纠错老师”指导。损失函数就是这个老师，它计算AI生成的旋律和真实旋律的差距（比如音高错了、节奏太乱），然后告诉模型“哪里需要改”。比如：

• 如果真实旋律的下一个音是“6”，但AI猜成“7”，损失函数会说“音高错了，罚分！”；
• 如果真实节奏是“四分音符”，但AI写成“八分音符”，损失函数会说“节奏错了，罚分！”。

类比：损失函数就像蛋糕店的质检表——“甜度不够扣1分，蛋糕太扁扣2分”，AI根据扣分调整配方。

核心概念之间的关系（用小学生能理解的比喻）

音乐表征、生成模型、损失函数就像“蛋糕三兄弟”：

• **音乐表征（乐谱字典）**是原材料，生成模型（作曲大脑）是烤箱，损失函数（纠错老师）是温度计。
• 没有乐谱字典（原材料），烤箱（生成模型）不知道该烤什么；没有温度计（损失函数），烤箱可能烤焦或没烤熟。

具体关系：

• 音乐表征 ↔ 生成模型：生成模型需要“读”懂音乐表征（就像烤箱需要“读”懂蛋糕配方），才能学习规律。
• 生成模型 ↔ 损失函数：生成模型生成旋律后，损失函数计算“多差”，然后指导模型调整参数（就像温度计告诉烤箱“温度高了，调低10℃”）。
• 音乐表征 ↔ 损失函数：损失函数的计算依赖音乐表征的具体形式（比如用钢琴卷帘的话，损失函数会检查色块位置对不对）。

核心概念原理和架构的文本示意图

AI作曲的核心流程：

音乐数据（MIDI/钢琴卷帘） → 预处理（转数字矩阵） → 生成模型（RNN/Transformer/GAN） → 损失函数（计算误差） → 调整模型 → 生成新旋律（MIDI输出）

Mermaid 流程图

graph TD
    A[原始音乐数据] --> B[预处理：转钢琴卷帘矩阵]
    B --> C[生成模型（RNN/Transformer/GAN）]
    C --> D[生成候选旋律矩阵]
    D --> E[损失函数：对比真实数据计算误差]
    E --> F{误差是否足够小？}
    F -->|否| C[调整模型参数]
    F -->|是| G[输出MIDI旋律]

---

核心算法原理 & 具体操作步骤

AI作曲的核心是序列生成（按时间顺序生成音符），常用算法有RNN、Transformer、GAN，我们逐一拆解。

1. RNN（循环神经网络）：会“记歌词”的作曲者

原理

RNN的核心是“记忆单元”，每个时间步的输出不仅依赖当前输入，还依赖之前的“记忆”。用公式表示：
$$h_t=\sigma (W_{hh}{h}_{t-1}+W_{xh}{x}_t+b_h)$$
$$y_t=\sigma (W_{hy}{h}_t+b_y)$$
其中：

• ( h_t ) 是t时刻的“记忆状态”（比如前t个音符的记忆）；
• ( x_t ) 是t时刻的输入（当前音符的钢琴卷帘向量）；
• ( y_t ) 是t时刻的输出（预测的下一个音符概率分布）；
• ( W ) 和 ( b ) 是模型参数（需要训练学习）；
• ( \sigma ) 是激活函数（比如Sigmoid或ReLU）。

类比：RNN像一个记歌词的小朋友，第一句记住“一闪一闪”，第二句就知道接“亮晶晶”，因为它记住了前一句的内容。

具体操作步骤（用Python代码示例）

我们用Keras实现一个简单的RNN来生成旋律：

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# 步骤1：准备数据（假设已将MIDI转为钢琴卷帘矩阵）
# 钢琴卷帘矩阵形状：(样本数, 时间步, 音高数)，这里音高数=128（钢琴88键+扩展）
# 例如：X是前3个时间步的音符，y是第4个时间步的音符
X = np.random.rand(1000, 3, 128)  # 1000个样本，每个样本3个时间步，128个音高
y = np.random.rand(1000, 128)     # 预测下一个时间步的128个音高概率

# 步骤2：搭建RNN模型（这里用LSTM，RNN的改进版，更擅长长记忆）
model = Sequential()
model.add(LSTM(128, input_shape=(3, 128), return_sequences=False))  # 记忆层
model.add(Dense(128, activation='softmax'))  # 输出每个音高的概率

# 步骤3：编译模型（损失函数用交叉熵，优化器用Adam）
model.compile(loss='categorical_crossentropy', optimizer='adam')

# 步骤4：训练模型（假设训练100轮）
model.fit(X, y, epochs=100, batch_size=32)

# 步骤5：生成旋律（输入初始3个时间步，预测第4个，然后循环）
def generate_melody(initial_sequence, length=10):
    melody = initial_sequence.copy()
    for _ in range(length):
        # 输入当前最后3个时间步
        input = melody[-3:].reshape(1, 3, 128)
        # 预测下一个音符概率
        next_note_probs = model.predict(input)[0]
        # 采样得到具体音高（这里用argmax选概率最高的）
        next_note = np.argmax(next_note_probs)
        # 生成新的钢琴卷帘向量（对应音高位置设为1）
        new_vector = np.zeros(128)
        new_vector[next_note] = 1
        melody = np.append(melody, [new_vector], axis=0)
    return melody

# 测试生成（初始序列是随机3个时间步）
initial = np.random.rand(3, 128)
generated = generate_melody(initial, length=10)

2. Transformer：用“注意力”抓重点的作曲者

原理

Transformer的核心是自注意力机制（Self-Attention），它能让模型在生成每个音符时，“关注”序列中最相关的部分（比如主歌的旋律比伴奏更重要）。自注意力的计算步骤：

1. 给输入序列的每个元素（音符）生成三个向量：查询（Query）、键（Key）、值（Value）；
2. 计算每个Query与所有Key的相似度（点积），得到“注意力分数”（关注哪些位置）；
3. 用Softmax归一化分数，得到注意力权重；
4. 用权重加权求和Value，得到输出（聚焦关键信息后的结果）。

数学公式：
$$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$$
其中 ( d_k ) 是Key的维度（防止点积过大导致梯度消失）。

类比：听音乐时，你可能自动忽略背景噪音，只关注主唱的声音——Transformer的注意力机制就是这样“抓重点”。

具体操作步骤（关键代码片段）

Transformer在音乐生成中常用“因果注意力”（只能看左边的音符，不能看未来），以下是关键层的实现：

from tensorflow.keras.layers import Layer
import tensorflow as tf

class CausalSelfAttention(Layer):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.d_model = d_model
        self.num_heads = num_heads
        self.depth = d_model // num_heads

        # 生成Q、K、V的线性层
        self.wq = Dense(d_model)
        self.wk = Dense(d_model)
        self.wv = Dense(d_model)

        # 输出线性层
        self.dense = Dense(d_model)

    def split_heads(self, x, batch_size):
        # 将x拆分为(num_heads, depth)
        x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))
        return tf.transpose(x, perm=[0, 2, 1, 3])

    def call(self, x):
        batch_size = tf.shape(x)[0]
        seq_len = tf.shape(x)[1]

        # 生成Q、K、V
        q = self.wq(x)  # (batch_size, seq_len, d_model)
        k = self.wk(x)
        v = self.wv(x)

        # 拆分多头
        q = self.split_heads(q, batch_size)  # (batch_size, num_heads, seq_len, depth)
        k = self.split_heads(k, batch_size)
        v = self.split_heads(v, batch_size)

        # 计算注意力分数（因果掩码：未来位置设为-∞，避免看未来）
        matmul_qk = tf.matmul(q, k, transpose_b=True)  # (batch_size, num_heads, seq_len, seq_len)
        dk = tf.cast(tf.shape(k)[-1], tf.float32)
        scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)

        # 因果掩码（下三角矩阵，上三角为-∞）
        mask = 1 - tf.linalg.band_part(tf.ones((seq_len, seq_len)), -1, 0)
        scaled_attention_logits += (mask * -1e9)

        # Softmax归一化
        attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)  # (batch_size, num_heads, seq_len, seq_len)

        # 加权求和Value
        output = tf.matmul(attention_weights, v)  # (batch_size, num_heads, seq_len, depth)
        output = tf.transpose(output, perm=[0, 2, 1, 3])  # (batch_size, seq_len, num_heads, depth)
        output = tf.reshape(output, (batch_size, seq_len, self.d_model))  # (batch_size, seq_len, d_model)

        # 输出线性层
        output = self.dense(output)
        return output

3. GAN（生成对抗网络）：互相“较劲”的作曲者与乐评人

原理

GAN由两个模型组成：

• 生成器（Generator）：输入随机噪声，生成假旋律（目标：让判别器误以为是真的）；
• 判别器（Discriminator）：输入真/假旋律，输出“真”的概率（目标：准确区分真假）。

训练时，生成器和判别器“对抗训练”：生成器努力骗过判别器，判别器努力不被骗，最终生成器能生成以假乱真的旋律。

损失函数公式：
$$\underset{G}{\min }\underset{D}{\max }V(D,G)={\mathbb{E}}_{x\sim p_{data}(x)}[\log D(x)]+{\mathbb{E}}_{z\sim p_z(z)}[\log (1-D(G(z)))]$$
其中 ( x ) 是真实数据，( z ) 是随机噪声，( G(z) ) 是生成的假数据。

类比：生成器像造假钞的，判别器像验钞机。造假钞的想造得更真，验钞机想更准，最后假钞能骗过验钞机时，生成器就成功了。

具体操作步骤（简化代码）

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dense, LeakyReLU

# 生成器：输入噪声，输出假旋律（钢琴卷帘向量）
def build_generator(latent_dim, output_dim=128):
    model = Sequential()
    model.add(Dense(256, input_dim=latent_dim))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(output_dim, activation='sigmoid'))  # 输出0-1的概率（钢琴卷帘的“按下”概率）
    return model

# 判别器：输入旋律，输出“真”的概率
def build_discriminator(input_dim=128):
    model = Sequential()
    model.add(Dense(512, input_dim=input_dim))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(256))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(1, activation='sigmoid'))  # 输出0（假）到1（真）的概率
    model.compile(loss='binary_crossentropy', optimizer='adam')
    return model

# 组合GAN：生成器+冻结的判别器
def build_gan(generator, discriminator):
    discriminator.trainable = False  # 训练生成器时不更新判别器
    gan_input = Input(shape=(latent_dim,))
    x = generator(gan_input)
    gan_output = discriminator(x)
    model = Model(gan_input, gan_output)
    model.compile(loss='binary_crossentropy', optimizer='adam')
    return model

# 训练参数
latent_dim = 100  # 噪声维度
output_dim = 128  # 钢琴卷帘维度（128个音高）
epochs = 10000
batch_size = 64

# 构建模型
generator = build_generator(latent_dim, output_dim)
discriminator = build_discriminator(output_dim)
gan = build_gan(generator, discriminator)

# 加载真实数据（假设已预处理为钢琴卷帘矩阵）
real_data = np.load('piano_rolls.npy')  # 形状：(num_samples, output_dim)

# 训练循环
for epoch in range(epochs):
    # 训练判别器：用真数据和假数据
    # 真数据标签为1，假数据标签为0
    idx = np.random.randint(0, real_data.shape[0], batch_size)
    real_batch = real_data[idx]
    real_labels = np.ones((batch_size, 1)) * 0.9  # 标签平滑（避免过自信）

    noise = np.random.normal(0, 1, (batch_size, latent_dim))
    fake_batch = generator.predict(noise)
    fake_labels = np.zeros((batch_size, 1))

    # 训练判别器
    d_loss_real = discriminator.train_on_batch(real_batch, real_labels)
    d_loss_fake = discriminator.train_on_batch(fake_batch, fake_labels)
    d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

    # 训练生成器：目标是让判别器将假数据判为1
    noise = np.random.normal(0, 1, (batch_size, latent_dim))
    valid_labels = np.ones((batch_size, 1))  # 生成器希望判别器认为假数据是真的
    g_loss = gan.train_on_batch(noise, valid_labels)

    # 打印进度
    if epoch % 100 == 0:
        print(f"Epoch {epoch}, D Loss: {d_loss}, G Loss: {g_loss}")

---

数学模型和公式 & 详细讲解 & 举例说明

RNN的状态转移

RNN的核心是状态 ( h_t )，它由前一状态 ( h_{t-1} ) 和当前输入 ( x_t ) 共同决定：
$$h_t=\tanh (W_{hh}{h}_{t-1}+W_{xh}{x}_t+b_h)$$
这里用了双曲正切函数 ( \tanh )（输出范围[-1,1]，防止数值爆炸）。

举例：假设 ( h_{t-1} = [0.5, -0.3] )（记住前一个音符的“开心”和“悲伤”程度），( x_t = [1, 0] )（当前音符是C大调），权重 ( W_{hh} = [[0.2, 0.1], [0.4, -0.1]] )，( W_{xh} = [[0.3, -0.2], [0.5, 0.1]] )，偏置 ( b_h = [0.1, -0.1] )，则：
$$W_{hh}{h}_{t-1}=[0.2\ast 0.5+0.1\ast (-0.3),0.4\ast 0.5+(-0.1)\ast (-0.3)]=[0.1-0.03,0.2+0.03]=[0.07,0.23]$$
$$W_{xh}{x}_t=[0.3\ast 1+(-0.2)\ast 0,0.5\ast 1+0.1\ast 0]=[0.3,0.5]$$
$$h_t=\tanh ([0.07+0.3+0.1,0.23+0.5-0.1])=\tanh ([0.47,0.63])\approx [0.44,0.56]$$
新的状态 ( h_t ) 综合了之前的记忆和当前输入，用于预测下一个音符。

Transformer的注意力分数

注意力分数衡量“当前位置”与“其他位置”的相关性。例如，生成第5个音符时，模型会计算它与前4个音符的相关性：

• 如果前4个音符是“1-3-5-1”（C大三和弦），第5个音符可能与第1个（“1”）最相关（分数最高），因此注意力权重更大。

GAN的损失函数

生成器的目标是最小化 ( \log(1 - D(G(z))) )（让判别器更难发现假数据），判别器的目标是最大化 ( \log D(x) + \log(1 - D(G(z))) )（准确区分真假）。

举例：如果生成器生成了一个很假的旋律（D(G(z))=0.1），则 ( \log(1 - 0.1) ≈ -0.105 )，损失较小；如果生成器生成了一个很真的旋律（D(G(z))=0.9），则 ( \log(1 - 0.9) ≈ -2.303 )，损失变大——这说明生成器需要调整参数，让D(G(z))更接近1（即生成更真的旋律）。

---

项目实战：代码实际案例和详细解释说明

开发环境搭建

1. 安装Python：推荐Python 3.8+（下载地址）。
2. 安装依赖库：

   pip install tensorflow==2.12.0  # 深度学习框架
   pip install music21==8.1.0       # 处理MIDI文件
   pip install numpy==1.24.3        # 数值计算
   pip install matplotlib==3.7.1    # 可视化钢琴卷帘
   

3. 准备MIDI数据集：推荐使用Lakh MIDI数据集（包含17万+MIDI文件）。

源代码详细实现和代码解读

我们以RNN为例，实现一个从MIDI文件到生成旋律的完整流程。

步骤1：MIDI文件预处理（转钢琴卷帘）

用music21库读取MIDI，提取音符并转换为钢琴卷帘矩阵。

from music21 import converter, note, chord
import numpy as np

def midi_to_piano_roll(midi_path, window_size=0.25):
    # 读取MIDI文件
    midi = converter.parse(midi_path)
    notes = []

    # 遍历所有音符和和弦
    for element in midi.flat.notes:
        if isinstance(element, note.Note):
            # 单音：记录音高和时长
            notes.append((element.pitch.midi, element.duration.quarterLength))
        elif isinstance(element, chord.Chord):
            # 和弦：每个音单独记录
            for pitch in element.pitches:
                notes.append((pitch.midi, element.duration.quarterLength))

    # 转换为时间序列（按0.25秒为一个时间步）
    max_time = sum(duration for _, duration in notes)
    num_steps = int(max_time / window_size) + 1
    piano_roll = np.zeros((num_steps, 128))  # 128个音高，0-127

    current_time = 0
    for (pitch, duration) in notes:
        start_step = int(current_time / window_size)
        end_step = int((current_time + duration) / window_size)
        # 在时间步[start_step, end_step)内标记音高
        for step in range(start_step, end_step):
            if step < num_steps:
                piano_roll[step, pitch] = 1  # 1表示该音高被按下
        current_time += duration

    return piano_roll

# 测试：读取一个MIDI文件并转换
piano_roll = midi_to_piano_roll('example.mid')
print(f"钢琴卷帘形状：{piano_roll.shape}")  # 输出：(时间步数, 128)

步骤2：构建RNN模型并训练

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

# 准备训练数据：前n个时间步预测第n+1个时间步
def create_sequences(piano_roll, seq_length=3):
    X, y = [], []
    for i in range(len(piano_roll) - seq_length):
        X.append(piano_roll[i:i+seq_length])  # 输入：前seq_length个时间步
        y.append(piano_roll[i+seq_length])     # 输出：下一个时间步
    return np.array(X), np.array(y)

# 假设piano_roll是单个MIDI的钢琴卷帘，实际应合并多个MIDI
X, y = create_sequences(piano_roll, seq_length=3)

# 搭建模型（LSTM是RNN的改进版，更擅长长序列记忆）
model = Sequential()
model.add(LSTM(256, input_shape=(X.shape[1], X.shape[2]), return_sequences=True))
model.add(Dropout(0.3))  # 防止过拟合
model.add(LSTM(256))
model.add(Dropout(0.3))
model.add(Dense(128, activation='softmax'))  # 输出每个音高的概率

model.compile(loss='categorical_crossentropy', optimizer='adam')

# 训练模型（实际应使用多个MIDI文件，这里简化为单个）
model.fit(X, y, epochs=50, batch_size=32)

步骤3：生成新旋律并转换回MIDI

from music21 import stream, note

def generate_midi(model, initial_sequence, length=32, window_size=0.25):
    generated_roll = initial_sequence.copy()
    for _ in range(length):
        # 输入最后seq_length个时间步
        input_seq = generated_roll[-3:].reshape(1, 3, 128)
        # 预测下一个时间步的音高概率
        pred_probs = model.predict(input_seq, verbose=0)[0]
        # 采样音高（这里用温度采样增加随机性）
        temperature = 0.7  # 温度越低越确定，越高越随机
        pred_probs = np.log(pred_probs) / temperature
        pred_probs = np.exp(pred_probs) / np.sum(np.exp(pred_probs))
        next_pitch = np.random.choice(128, p=pred_probs)
        # 生成新时间步（仅标记选中的音高）
        new_step = np.zeros(128)
        new_step[next_pitch] = 1
        generated_roll = np.append(generated_roll, [new_step], axis=0)

    # 钢琴卷帘转MIDI
    s = stream.Stream()
    current_time = 0
    for step in range(len(generated_roll)):
        pitches = np.where(generated_roll[step] == 1)[0]
        for pitch in pitches:
            n = note.Note(pitch)
            n.duration.quarterLength = window_size  # 每个时间步0.25秒
            n.offset = current_time  # 音符起始时间
            s.insert(n)
        current_time += window_size
    return s

# 生成初始序列（取真实数据的前3个时间步）
initial = piano_roll[:3]
generated_stream = generate_midi(model, initial, length=32)
generated_stream.write('midi', 'generated_melody.mid')  # 保存为MIDI文件

代码解读与分析

• 预处理：将MIDI转换为钢琴卷帘矩阵，每个时间步记录128个音高的“按下”状态（1表示按下，0表示未按下）。
• 序列创建：用前3个时间步预测第4个，帮助模型学习“短期依赖”（比如小旋律片段的规律）。
• 模型结构：两层LSTM捕捉长短期依赖，Dropout层防止过拟合（避免模型只记住训练数据，无法生成新旋律）。
• 生成逻辑：使用“温度采样”（Temperature Sampling）控制生成的随机性——温度低时选择概率最高的音高（更保守），温度高时随机选择（更有创意）。

---

实际应用场景

AI作曲已从实验室走向实际应用，以下是几个典型场景：

1. 游戏/影视背景音乐生成

游戏需要大量适配不同场景的音乐（战斗、解谜、休息），AI可以根据场景关键词（“紧张”“舒缓”）生成定制音乐，降低制作成本。例如，游戏《Cyberpunk 2077》就使用了AI生成的环境音效。

2. 个性化音乐推荐

音乐平台（如Spotify）可以分析用户听歌习惯，用AI生成“只属于你的”个性化旋律，作为推荐列表的补充。

3. 辅助音乐创作

作曲家可以用AI生成“灵感片段”，比如输入“C大调、4/4拍、抒情”，AI生成一段旋律，作曲家在此基础上修改完善。Google的Magenta就是典型工具。

4. 教育领域

音乐初学者可以通过AI生成的旋律学习作曲规律（比如“副歌通常用大调”），AI还能自动评估练习曲的优缺点（“这里和弦转换不够流畅”）。

---

工具和资源推荐

1. 开源框架

• Magenta（Google）：专注音乐/艺术生成的AI框架，内置RNN、Transformer等模型，支持MIDI输入输出（官网）。
• OpenAI Jukebox：能生成分钟级、带歌词的歌曲，支持风格（摇滚、爵士）和艺术家模仿（论文）。
• DDSP（Google）：基于信号处理的生成模型，能更精细控制音色（GitHub）。

2. 数据集

• Lakh MIDI Dataset：17万+MIDI文件，覆盖多种风格（下载）。
• MAESTRO：800+小时古典钢琴MIDI，带音符级时间标签（官网）。

3. 学习资源

• 书籍：《生成式人工智能：AIGC技术原理与应用实践》（全面讲解AIGC技术）。
• 课程：Coursera《Natural Language Processing with Sequence Models》（RNN/Transformer的详细讲解）。

---

未来发展趋势与挑战

趋势1：多模态生成

未来AI作曲可能结合歌词、情绪、视频画面等多模态信息。例如，输入一段电影画面（悲伤的离别场景），AI生成“缓慢、小调、钢琴为主”的背景音乐。

趋势2：可控性提升

目前AI生成的旋律可能“好听但没主题”，未来模型将支持更细粒度的控制（“前8小节升调，后8小节加入小提琴”）。

挑战1：版权与伦理

AI生成的音乐版权归属（是用户、开发者还是AI？）、是否会导致音乐创作“同质化”（大家都用相似的AI模型）是亟待解决的问题。

挑战2：模型可解释性

AI生成某个旋律的原因（“为什么选这个音？”）难以解释，这对音乐教育和艺术批判是个挑战。

---

总结：学到了什么？

核心概念回顾

• 音乐表征：AI用MIDI/钢琴卷帘“读”音乐，就像用数字配方“读”蛋糕做法。
• 生成模型：RNN（记歌词）、Transformer（抓重点）、GAN（互相较劲）是AI的“作曲大脑”。
• 损失函数：AI的“纠错老师”，指导模型调整参数。

概念关系回顾

音乐表征是原材料，生成模型是加工机器，损失函数是质检工具——三者协同工作，让AI从“学作曲”到“会作曲”。

---

思考题：动动小脑筋

1. 如果让AI生成一首“中国风”的旋律，你会在数据预处理或模型设计上做哪些调整？（提示：中国风常用五声音阶）
2. 你认为AI作曲会取代人类作曲家吗？为什么？（可以从“情感表达”“创造性”等角度思考）
3. 尝试用Magenta框架生成一段旋律（教程），并分享你的体验（比如“生成的旋律有什么特点？”）。

---

附录：常见问题与解答

Q：AI生成的音乐有版权吗？
A：目前多数国家认为AI生成的内容不具备版权（因为“作者”需是人类），但用户对AI生成内容的修改版本可能拥有版权。

Q：AI作曲需要懂音乐理论吗？
A：不需要！AI通过学习大量音乐数据自动掌握规律，但懂音乐理论可以更好地指导AI（比如指定“用C大调”）。

Q：AI生成的旋律会重复吗？
A：会！如果训练数据有限，AI可能生成重复片段。解决方法是增加数据多样性，或在生成时加入随机性（如温度采样）。

---

扩展阅读 & 参考资料

• 论文：《MuseGAN: Multi-track Sequential Generative Adversarial Networks for Symbolic Music Generation》（MuseGAN模型详解）。
• 博客：《How AI Composes Music: A Deep Dive into Generative Models》（Medium，AI作曲技术深度解析）。
• 工具文档：《Magenta Documentation》（官方教程，含代码示例）。