5大AI生成模型详解（三）AR 自回归模型

最新推荐文章于 2025-03-27 16:22:48 发布

AI Agent开发

最新推荐文章于 2025-03-27 16:22:48 发布

阅读量1.7k

点赞数 15

文章标签：人工智能回归数据挖掘 AI大模型大模型 AI 学习

本文链接：https://blog.csdn.net/m0_56255097/article/details/142262657

版权

三、AR（自回归模型）

算法原理：

自回归模型，一种基于序列数据的生成模型，其核心在于通过预测序列中下一个元素的值来生成数据。给定序列(x_1, x_2, …, x_n)，该模型致力于学习条件概率分布P(x_t | x_{t-1}, …, x_1)，其中(t)表示序列中的当前位置。

自回归模型可通过循环神经网络（RNN）或Transformer等结构实现，其显著特点在于能精准捕捉序列数据的时序依赖关系，并生成时序一致的样本。

在深度学习的早期阶段，卷积神经网络（CNN）在图像识别和自然语言处理领域取得了显著的成功。然而，随着任务复杂度的增加，序列到序列（Seq2Seq）模型和循环神经网络（RNN）成为处理序列数据的常用方法。

尽管RNN及其变体在某些任务上表现良好，但它们在处理长序列时容易遇到梯度消失和模型退化问题。为了解决这些问题，Transformer模型被提出。而后的GPT、Bert等大模型都是基于Transformer实现了卓越的性能！
在这里插入图片描述

模型原理：

Transformer模型精巧地结合了编码器和解码器两大部分，每一部分均由若干相同构造的“层”堆叠而成。这些层巧妙地将自注意力子层与线性前馈神经网络子层结合在一起。自注意力子层巧妙地运用点积注意力机制，为每个位置的输入序列编织独特的表示，而线性前馈神经网络子层则汲取自注意力层的智慧，产出富含信息的输出表示。值得一提的是，编码器和解码器各自装备了一个位置编码层，专门捕捉输入序列中的位置脉络。

模型训练：

Transformer模型的修炼之道依赖于反向传播算法和优化算法，如随机梯度下降。在修炼过程中，它细致地计算损失函数对权重的梯度，并运用优化算法微调这些权重，以追求损失函数的最小化。为了加速修炼进度和提高模型的通用能力，修炼者们还常常采纳正则化技术、集成学习等策略。

优点：

梯度消失与模型退化之困得以解决：Transformer模型凭借其独特的自注意力机制，能够游刃有余地捕捉序列中的长期依赖关系，从而摆脱了梯度消失和模型退化的桎梏。
并行计算能力卓越：Transformer模型的计算架构具备天然的并行性，使得在GPU上能够风驰电掣地进行训练和推断。
多任务表现出色：凭借强大的特征学习和表示能力，Transformer模型在机器翻译、文本分类、语音识别等多项任务中展现了卓越的性能。

缺点：

计算资源需求庞大：由于Transformer模型的计算可并行性，训练和推断过程需要庞大的计算资源支持。
对初始化权重敏感：Transformer模型对初始化权重的选择极为挑剔，不当的初始化可能导致训练过程不稳定或出现过拟合问题。
长期依赖关系处理受限：尽管Transformer模型已有效解决梯度消失和模型退化问题，但在处理超长序列时仍面临挑战。

应用场景：

Transformer模型在自然语言处理领域的应用可谓广泛，涵盖机器翻译、文本分类、文本生成等诸多方面。此外，Transformer模型还在图像识别、语音识别等领域大放异彩。

Python示例代码（简化版）：

import torch
import torch.nn as nn
import torch.optim as optim
#该示例仅用于说明Transformer的基本结构和原理。实际的Transformer模型（如GPT或BERT）要复杂得多，并且需要更多的预处理步骤，如分词、填充、掩码等。
class Transformer(nn.Module):
    def __init__(self, d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward=2048):
        super(Transformer, self).__init__()
        self.model_type = 'Transformer'

        # encoder layers
        self.src_mask = None
        self.pos_encoder = PositionalEncoding(d_model, max_len=5000)
        encoder_layers = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layers, num_encoder_layers)

        # decoder layers
        decoder_layers = nn.TransformerDecoderLayer(d_model, nhead, dim_feedforward)
        self.transformer_decoder = nn.TransformerDecoder(decoder_layers, num_decoder_layers)

        # decoder
        self.decoder = nn.Linear(d_model, d_model)

        self.init_weights()

    def init_weights(self):
        initrange = 0.1
        self.decoder.weight.data.uniform_(-initrange, initrange)

    def forward(self, src, tgt, teacher_forcing_ratio=0.5):
        batch_size = tgt.size(0)
        tgt_len = tgt.size(1)
        tgt_vocab_size = self.decoder.out_features

        # forward pass through encoder
        src = self.pos_encoder(src)
        output = self.transformer_encoder(src)

        # prepare decoder input with teacher forcing
        target_input = tgt[:, :-1].contiguous()
        target_input = target_input.view(batch_size * tgt_len, -1)
        target_input = torch.autograd.Variable(target_input)

        # forward pass through decoder
        output2 = self.transformer_decoder(target_input, output)
        output2 = output2.view(batch_size, tgt_len, -1)

        # generate predictions
        prediction = self.decoder(output2)
        prediction = prediction.view(batch_size * tgt_len, tgt_vocab_size)

        return prediction[:, -1], prediction


class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000):
        super(PositionalEncoding, self).__init__()

        # Compute the positional encodings once in log space.
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len).unsqueeze(1).float()
        div_term = torch.exp(torch.arange(0, d_model, 2).float() *
                             -(torch.log(torch.tensor(10000.0)) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + self.pe[:, :x.size(1)]
        return x


# 超参数
d_model = 512
nhead = 8
num_encoder_layers = 6
num_decoder_layers = 6
dim_feedforward = 2048

# 实例化模型
model = Transformer(d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward)

# 随机生成数据
src = torch.randn(10, 32, 512)
tgt = torch.randn(10, 32, 512)

# 前向传播
prediction, predictions = model(src, tgt)

print(prediction)