transformer代码逐行注释

### 带有详细注释的Transformer代码实现

以下是基于PyTorch框架的一个简化版本的Transformer模型，其中包含了详细的中文注释帮助理解每一部分的功能：

import torch.nn as nn
import math


class Transformer(nn.Module):
    """定义一个简单的Transformer类"""

    def __init__(self, d_model=512, nhead=8, num_encoder_layers=6,
                 num_decoder_layers=6, dim_feedforward=2048, dropout=0.1):
        super(Transformer, self).__init__()
        
        # 初始化编码器层
        encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead,
                                                   dim_feedforward=dim_feedforward,
                                                   dropout=dropout)
        self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_encoder_layers)

        # 初始化解码器层
        decoder_layer = nn.TransformerDecoderLayer(d_model=d_model, nhead=nhead,
                                                  dim_feedforward=dim_feedforward,
                                                  dropout=dropout)
        self.decoder = nn.TransformerDecoder(decoder_layer, num_layers=num_decoder_layers)

        # 定义源嵌入矩阵和目标嵌入矩阵
        self.src_embedding = nn.Embedding(vocab_size, d_model)
        self.tgt_embedding = nn.Embedding(vocab_size, d_model)

        # 输出线性变换
        self.out_linear = nn.Linear(d_model, vocab_size)

        # 对输入数据应用位置编码
        self.positional_encoding = PositionalEncoding(d_model, max_len=max_seq_length)

        # 使用均匀分布初始化参数
        for p in self.parameters():
            if p.dim() > 1:
                nn.init.xavier_uniform_(p)


    def forward(self, src, tgt, src_mask=None, tgt_mask=None):[^2]
        """
        :param src: 输入序列 (batch_size, seq_len_src)
        :param tgt: 目标序列 (batch_size, seq_len_tgt)
        :param src_mask: 源序列掩码 (seq_len_src, seq_len_src)，可选
        :param tgt_mask: 目标序列掩码 (seq_len_tgt, seq_len_tgt)，可选
        """

        # 将索引转换成词向量并加上位置编码
        src_embedded = self.positional_encoding(self.src_embedding(src))
        tgt_embedded = self.positional_encoding(self.tgt_embedding(tgt))

        # 编码过程
        memory = self.encoder(src_embedded, mask=src_mask)

        # 解码过程
        output = self.decoder(tgt_embedded, memory, tgt_mask=tgt_mask, memory_mask=src_mask)

        # 应用最终的全连接层得到预测结果
        logits = self.out_linear(output)

        return logits


class PositionalEncoding(nn.Module):
    "Implement the PE function."

    def __init__(self, d_model, dropout=0.1, max_len=5000):
        super(PositionalEncoding, self).__init__()

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0., max_len).unsqueeze(1)
        div_term = torch.exp(torch.arange(0., d_model, 2) * -(math.log(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(0)]
        return x

此段代码实现了基础的Transformer架构，并通过`forward()`方法完成了前向传播的过程。注意这里的`vocab_size` 和 `max_seq_length` 需要在实例化对象之前设定好。