从RNN到Transformer：生成式AI自回归模型的全面剖析

个人主页：chian-ocean

文章专栏

生成式AI中的自回归模型详解

在生成式AI的飞速发展中，自回归模型作为核心技术之一，成为文本生成、语音合成、图像生成等领域的重要支柱。本文将全面探讨自回归模型的原理、架构、实际应用，并结合代码示例分析其在自然语言处理（NLP）中的实现。

1. 什么是自回归模型？

自回归模型的定义

自回归模型是一种基于历史信息预测未来的生成模型。它假设当前的输出可以完全由之前的输出推导而来。这种机制被广泛应用于时间序列分析，而在生成式AI中，它的核心理念体现在逐步生成目标内容（如文本、音频或图像）。

在自然语言生成任务中，自回归模型会基于前面的单词或字符，逐步预测序列中的下一个元素。一个典型的公式是：

[
P(x) = P(x_1) P(x_2 | x_1) P(x_3 | x_1, x_2) \dots P(x_n | x_1, x_2, \dots, x_{n-1})
]

其中：

( P(x_i | x_1, x_2, \dots, x_{i-1}) ) 表示在给定前序元素的条件下，生成第 ( i ) 个元素的概率。

2. 自回归模型在生成式AI中的架构

2.1 RNN与自回归生成

在生成式AI的发展初期，循环神经网络（RNN）被广泛用于构建自回归生成模型。它通过隐藏状态 ( h_t ) 来捕获序列中的历史信息：

[
h_t = f(h_{t-1}, x_t)
]

生成过程中，RNN依赖每一步的历史状态和当前输入来预测下一步的结果。

import torch
import torch.nn as nn

class RNNGenerator(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim):
        super(RNNGenerator, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.rnn = nn.RNN(embedding_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, vocab_size)

    def forward(self, x, hidden):
        embeds = self.embedding(x)
        out, hidden = self.rnn(embeds, hidden)
        out = self.fc(out)
        return out, hidden

# 初始化模型
vocab_size = 10000
embedding_dim = 128
hidden_dim = 256
model = RNNGenerator(vocab_size, embedding_dim, hidden_dim)

然而，RNN模型存在梯度消失和长距离依赖问题，这限制了其在复杂生成任务中的表现。

2.2 Transformer架构的引入

Transformer模型在自回归生成中的应用突破了RNN的限制，成为当前生成式AI的主流架构。Transformer通过注意力机制捕获全局上下文信息，并支持并行计算，极大地提高了生成速度和质量。

自回归生成的核心：掩码多头注意力

在自回归生成中，Transformer的解码器模块通过掩码多头注意力机制确保每一步的生成只依赖于之前的元素：

[
\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)V
]

其中，掩码机制将未生成的部分屏蔽，以避免泄漏未来信息。

import torch.nn.functional as F

class TransformerDecoder(nn.Module):
    def __init__(self, vocab_size, embedding_dim, num_heads, num_layers):
        super(TransformerDecoder, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.layers = nn.ModuleList([
            nn.TransformerDecoderLayer(d_model=embedding_dim, nhead=num_heads)
            for _ in range(num_layers)
        ])
        self.fc = nn.Linear(embedding_dim, vocab_size)

    def forward(self, x, memory, tgt_mask):
        x = self.embedding(x)
        for layer in self.layers:
            x = layer(x, memory, tgt_mask=tgt_mask)
        return self.fc(x)

# 生成掩码矩阵
def generate_tgt_mask(size):
    mask = torch.triu(torch.ones(size, size), diagonal=1)
    mask = mask.masked_fill(mask == 1, float('-inf'))
    return mask

3. 自回归模型的实际应用

3.1 文本生成

自回归模型在文本生成中通过逐词生成句子。以下是使用Transformer架构进行文本生成的简化示例：

def generate_text(model, start_token, max_len, vocab):
    model.eval()
    generated = [start_token]
    for _ in range(max_len):
        input_seq = torch.tensor(generated).unsqueeze(0)
        tgt_mask = generate_tgt_mask(len(generated))
        logits = model(input_seq, None, tgt_mask)
        next_token = logits.argmax(-1).item()
        generated.append(next_token)
        if next_token == vocab['<eos>']:
            break
    return ' '.join([vocab.itos[idx] for idx in generated])

3.2 图像生成

在图像生成领域，自回归模型（如PixelRNN、PixelCNN）逐像素生成图像，每个像素值依赖于之前生成的像素。

class PixelCNN(nn.Module):
    def __init__(self, input_channels, hidden_dim, kernel_size):
        super(PixelCNN, self).__init__()
        self.conv1 = nn.Conv2d(input_channels, hidden_dim, kernel_size, padding=kernel_size//2)
        self.conv2 = nn.Conv2d(hidden_dim, hidden_dim, kernel_size, padding=kernel_size//2)
        self.out = nn.Conv2d(hidden_dim, input_channels, kernel_size=1)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.relu(self.conv2(x))
        return self.out(x)

PixelCNN通过条件概率的方式预测每个像素的值，适合于高分辨率图像的生成。

4. 自回归模型的局限性

尽管自回归模型在生成任务中表现出色，但其仍存在一些问题：

生成效率低下：逐步生成的方式导致推理速度较慢，尤其是处理长序列时。
错误累积问题：早期生成的错误可能会随着生成过程放大，导致生成质量下降。
上下文长度限制：对于非常长的序列，模型可能无法捕获远距离依赖。

5. 解决方案与改进方向

5.1 非自回归生成

非自回归生成通过并行方式生成所有输出元素，显著提高了生成速度。例如，模型可以在预测时同时输出整段文本。

# 非自回归Transformer
class NonAutoregressiveTransformer(nn.Module):
    def __init__(self, vocab_size, embedding_dim):
        super(NonAutoregressiveTransformer, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.encoder = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(d_model=embedding_dim, nhead=8), num_layers=6)
        self.decoder = nn.Linear(embedding_dim, vocab_size)

    def forward(self, x):
        x = self.embedding(x)
        encoded = self.encoder(x)
        return self.decoder(encoded)