##22 深入理解Transformer模型_transformer多头注意力-CSDN博客

本文链接：https://blog.csdn.net/weixin_51352614/article/details/138428220

文章目录

前言

前言

在当今深度学习和自然语言处理(NLP)的领域中，Transformer模型已经成为了一种革命性的进步。自2017年由Vaswani等人在论文《Attention is All You Need》中首次提出以来，Transformer已经广泛应用于各种NLP任务，并且其变体，例如BERT、GPT等，也在其它领域取得了显著成绩。在本文中，我们将深入探讨Transformer模型的工作原理，实现方法，并通过PyTorch框架构建一个基本的Transformer模型。
在这里插入图片描述

1. Transformer模型概述

Transformer模型是一种基于自注意力机制（Self-Attention Mechanism）的架构，它摒弃了传统的递归神经网络(RNN)中的序列依赖操作，实现了更高效的并行计算和更好的长距离依赖捕捉能力。其核心特点是完全依靠注意力机制来处理序列的数据。

1.1 关键特性

自注意力机制：允许模型在处理输入的序列时，关注序列中的不同部分，更好地理解语境和语义。
位置编码：由于Transformer完全依赖于注意力机制，需要位置编码来保持序列中单词的顺序信息。
多头注意力：允许模型同时从不同的表示子空间学习信息。

2. Transformer 架构详解

2.1 编码器和解码器结构

Transformer 模型主要由编码器和解码器组成。每个编码器层包含两个子层：多头自注意力机制和简单的前馈神经网络。解码器也包含额外的第三层，用于处理编码器的输出。

2.1.1 多头自注意力机制

这一机制的核心是将注意力分成多个头，它们各自独立地学习输入数据的不同部分，然后将这些信息合并起来，这样可以捕捉到数据的多种复杂特征。

2.1.2 前馈神经网络

每个位置上的前馈网络都是相同的，但不共享参数，每个网络对应的是对输入序列的独立处理。

2.2 自注意力

自注意力机制的关键在于三个向量：查询（Query）、键（Key）和值（Value）。通过计算查询和所有键之间的点积来确定权重，然后用这些权重对值进行加权求和。

2.3 位置编码

位置编码用于注入序列中单词的相对或绝对位置信息。通常使用正弦和余弦函数的不同频率。

3. 在PyTorch中实现Transformer

3.1 准备环境

首先，需要安装PyTorch库，可以通过pip安装：

pip install torch torchvision

3.2 构建模型

在PyTorch中，可以利用torch.nn.Transformer模块来构建Transformer模型。这个模块提供了高度模块化的实现，你可以轻松地自定义自己的Transformer模型。

import torch
import torch.nn as nn

class TransformerModel(nn.Module):
    def __init__(self, ntoken, ninp, nhead, nhid, nlayers, dropout=0.5):
        super(TransformerModel, self).__init__()
        self.model_type = 'Transformer'
        self.src_mask = None
        self.pos_encoder = PositionalEncoding(ninp, dropout)
        encoder_layers = nn.TransformerEncoderLayer(ninp, nhead, nhid, dropout)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layers, nlayers)
        self.encoder = nn.Embedding(ntoken, ninp)
        self.ninp = ninp
        self.decoder = nn.Linear(ninp, ntoken)

        self.init_weights()

    def _generate_square_subsequent_mask(self, sz):
        mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
        mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
        return mask

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

    def forward(self, src, has_mask=True):
        if has_mask:
            device = src.device
            if self.src_mask is None or self.src_mask.size(0) != len(src):
                mask = self._generate_square_subsequent_mask(len(src)).to(device)
                self.src_mask = mask
        else:
            self.src_mask = None

        src = self.encoder(src) * math.sqrt(self.ninp)
        src = self.pos_encoder(src)
        output = self.transformer_encoder(src, self.src_mask)
        output = self.decoder(output)
        return output

3.3 训练模型

训练过程涉及到设置适当的损失函数，优化算法和适量的训练周期。这里，我们使用交叉熵损失和Adam优化器。

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):
    model.train()
    total_loss = 0
    for batch, i in enumerate(range(0, train_data.size(0) - 1, bptt)):
        data, targets = get_batch(train_data, i)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output.view(-1, ntokens), targets)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
        optimizer.step()
        total_loss += loss.item()
    print('Epoch:', epoch, ' Loss:', total_loss / len(train_data))