• DETR纯代码分享（九）transformer.py

    一、定义DETR Transformer用于DETR模型

    1. """
    2. DETR Transformer class.
    4. Copy-paste from torch.nn.Transformer with modifications:
    5.     * positional encodings are passed in MHattention
    6.     * extra LN at the end of encoder is removed
    7.     * decoder returns a stack of activations from all decoding layers
    8. """
    9. import copy
    10. from typing import Optional, List
    11.  
    12. import torch
    13. import torch.nn.functional as F
    14. from torch import nn, Tensor

    这段代码是一个用于实现DETR模型中的Transformer类的定义。DETR是一个用于目标检测的神经网络模型，它将目标检测任务转化为一个序列到序列（Sequence-to-Sequence）问题。下面是对这段代码的解释：

    1. DETR Transformer class: 这是一个类的定义，表示DETR模型中的Transformer部分。该类用于实现Transformer的结构和功能。

    2. Copy-paste from torch.nn.Transformer with modifications: 该注释表明该类的定义是从PyTorch的torch.nn.Transformer类进行复制并进行了一些修改。

    3. positional encodings are passed in MHattention: 在标准的Transformer模型中，位置编码是在Encoder和Decoder之前添加的。然而，在这里的DETR模型中，位置编码是在Multi-Head Attention（MHattention）中传递的，这是一种修改。

    4. extra LN at the end of encoder is removed: 在标准的Transformer中，通常在Encoder的最后添加了一个Layer Normalization（LN）层，但在DETR中，这个额外的LN层已被移除。

    5. decoder returns a stack of activations from all decoding layers: 这表示在DETR的Decoder部分，不仅返回最后一层的输出，还返回了所有解码层的激活（输出）堆栈。这个修改可能有助于在目标检测任务中捕获多尺度特征。

    总之，这段代码定义了DETR模型中的Transformer类，其中包含了一些修改，以适应目标检测任务的需要。它是DETR模型的关键组件之一，用于处理序列到序列的输入数据，从而实现目标检测任务。

    二、定义Transformer模型

    1. class Transformer(nn.Module):
    2.  
    3.     def __init__(self, d_model=512, nhead=8, num_encoder_layers=6,
    4.                  num_decoder_layers=6, dim_feedforward=2048, dropout=0.1,
    5.                  activation="relu", normalize_before=False,
    6.                  return_intermediate_dec=False):
    7.         super().__init__()
    8.  
    9.         encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward,
    10.                                                 dropout, activation, normalize_before)
    11.         encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
    12.         self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
    13.  
    14.         decoder_layer = TransformerDecoderLayer(d_model, nhead, dim_feedforward,
    15.                                                 dropout, activation, normalize_before)
    16.         decoder_norm = nn.LayerNorm(d_model)
    17.         self.decoder = TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm,
    18.                                           return_intermediate=return_intermediate_dec)
    19.  
    20.         self._reset_parameters()
    21.  
    22.         self.d_model = d_model
    23.         self.nhead = nhead
    24.  
    25.     def _reset_parameters(self):
    26.         for p in self.parameters():
    27.             if p.dim() > 1:
    28.                 nn.init.xavier_uniform_(p)
    29.  
    30.     def forward(self, src, mask, query_embed, pos_embed):
    31.         # flatten NxCxHxW to HWxNxC
    32.         bs, c, h, w = src.shape
    33.         src = src.flatten(2).permute(2, 0, 1)
    34.         pos_embed = pos_embed.flatten(2).permute(2, 0, 1)
    35.         query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
    36.         mask = mask.flatten(1)
    37.  
    38.         tgt = torch.zeros_like(query_embed)
    39.         memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)
    40.         hs = self.decoder(tgt, memory, memory_key_padding_mask=mask,
    41.                           pos=pos_embed, query_pos=query_embed)
    42.         return hs.transpose(1, 2), memory.permute(1, 2, 0).view(bs, c, h, w)

    这段代码定义了一个Transformer模型。

    1、__init__()
    1. class Transformer(nn.Module):
    2.  
    3.     def __init__(self, d_model=512, nhead=8, num_encoder_layers=6,
    4.                  num_decoder_layers=6, dim_feedforward=2048, dropout=0.1,
    5.                  activation="relu", normalize_before=False,
    6.                  return_intermediate_dec=False):
    7.         super().__init__()
    8.  
    9.         encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward,
    10.                                                 dropout, activation, normalize_before)
    11.         encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
    12.         self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
    13.  
    14.         decoder_layer = TransformerDecoderLayer(d_model, nhead, dim_feedforward,
    15.                                                 dropout, activation, normalize_before)
    16.         decoder_norm = nn.LayerNorm(d_model)
    17.         self.decoder = TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm,
    18.                                           return_intermediate=return_intermediate_dec)
    19.  
    20.         self._reset_parameters()
    21.  
    22.         self.d_model = d_model
    23.         self.nhead = nhead

    这段代码定义了一个自定义的Transformer模型，它包含编码器（Encoder）和解码器（Decoder）部分。以下是每行代码的详细解释：

    1. def __init__(self, d_model=512, nhead=8, num_encoder_layers=6, num_decoder_layers=6, dim_feedforward=2048, dropout=0.1, activation="relu", normalize_before=False, return_intermediate_dec=False):：这是构造函数，用于初始化Transformer模型的各种参数。

      • d_model：模型的输入和输出特征维度，默认为512。
      • nhead：多头自注意力机制中的注意头数，默认为8。
      • num_encoder_layers：编码器层数，默认为6。
      • num_decoder_layers：解码器层数，默认为6。
      • dim_feedforward：前馈神经网络的中间层维度，默认为2048。
      • dropout：Dropout概率，默认为0.1。
      • activation：激活函数类型，默认为"relu"。
      • normalize_before：指定是否在每个子层之前应用层标准化，默认为False。
      • return_intermediate_dec：指定是否返回解码器的中间层输出，默认为False。

    2. encoder_layer：创建了一个Transformer编码器层（TransformerEncoderLayer）的实例，该层包含自注意力机制和前馈神经网络。具体实现见本文（五、TransformerEncoderLayer）

      • d_model：特征维度。
      • nhead：注意头数。
      • dim_feedforward：前馈神经网络中间层的维度。
      • dropout：Dropout概率。
      • activation：激活函数类型。
      • normalize_before：是否应用层标准化。

    3. encoder_norm：根据normalize_before参数决定是否创建编码器层的层标准化层（nn.LayerNorm）。

    4. self.encoder：创建了一个Transformer编码器（TransformerEncoder）的实例，该编码器由多个编码器层组成，这些层在编码输入序列时进行堆叠。

      • 参数包括编码器层、层数和编码器层的层标准化层。具体实现见本文（三、TransformerEncoder类）

    5. decoder_layer：创建了一个Transformer解码器层（TransformerDecoderLayer）的实例，该层包含自注意力机制、编码-解码注意力机制和前馈神经网络。

      • 参数与编码器层相似。具体实现见本文（六、TransformerDecoderLayer）

    6. decoder_norm：创建了解码器层的层标准化层。

    7. self.decoder：创建了一个Transformer解码器（TransformerDecoder）的实例，该解码器由多个解码器层组成，这些层在解码序列时进行堆叠。

      • 参数包括解码器层、层数、解码器层的层标准化层和是否返回解码器的中间层输出。具体实现见本文（四、TransformerDecoder类）

    8. self._reset_parameters()：初始化模型的参数。对于权重参数，使用Xavier均匀分布进行初始化。

    9. self.d_model = d_model 和 self.nhead = nhead：保存模型的特征维度和注意头数供后续使用。

    2、 _reset_parameters()
    1.     def _reset_parameters(self):
    2.         for p in self.parameters():
    3.             if p.dim() > 1:
    4.                 nn.init.xavier_uniform_(p)

    这是Transformer模型类中的一个私有方法 _reset_parameters，用于初始化模型的参数。具体实现如下：

    1. for p in self.parameters()：遍历模型的所有参数。

    2. if p.dim() > 1：检查参数的维度是否大于1，以排除偏置项（维度为1的参数）。

    3. nn.init.xavier_uniform_(p)：对于维度大于1的参数，使用Xavier均匀分布初始化它们的值。Xavier初始化有助于确保参数的初始值适合深度神经网络的训练，有助于加速收敛和训练的稳定性。这种初始化方法是常用的初始化策略之一。

    总之，_reset_parameters 方法的目的是为了确保模型的参数以适当的方式进行初始化，以便更容易训练和提高模型性能。这有助于模型在训练过程中更快地收敛到合适的解。

    3、forward()
    1.     def forward(self, src, mask, query_embed, pos_embed):
    2.         # flatten NxCxHxW to HWxNxC
    3.         bs, c, h, w = src.shape
    4.         src = src.flatten(2).permute(2, 0, 1)
    5.         pos_embed = pos_embed.flatten(2).permute(2, 0, 1)
    6.         query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
    7.         mask = mask.flatten(1)
    8.  
    9.         tgt = torch.zeros_like(query_embed)
    10.         memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)
    11.         hs = self.decoder(tgt, memory, memory_key_padding_mask=mask,
    12.                           pos=pos_embed, query_pos=query_embed)
    13.         return hs.transpose(1, 2), memory.permute(1, 2, 0).view(bs, c, h, w)

    这是Transformer模型的前向传播方法 forward，该方法实现了Transformer的前向计算过程。以下是每行代码的详细解释：

    1. bs, c, h, w = src.shape：获取输入src的形状信息，其中bs是批次大小（batch size），c是通道数（channels），h和w分别是高度和宽度。

    2. src = src.flatten(2).permute(2, 0, 1)：首先使用 flatten(2) 操作将输入src从四维张量（NxCxHxW）变换为三维张量（HWxNxC），然后使用 permute(2, 0, 1) 操作重新排列维度，将其变为（序列长度x批次大小x特征维度）的形状。分为两个部分：首先是src.flatten(2) 这个操作，其中的参数 2 表示要展平的维度，即在第三维度（即 height 维度）上执行展平操作。效果是将 src 中的每个通道的高度维度展平，结果是一个形状为 (batch_size, channels, height * width) 的三维张量；然后是.permute(2, 0, 1)，将(batch_size, channels, height * width)变成(h * w，bs, channels)

    3. pos_embed = pos_embed.flatten(2).permute(2, 0, 1)：对位置编码pos_embed执行类似的操作，将其变为与输入相同的形状。(h * w，bs, channels)

    4. query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)：将query_embed的维度从（ N,  channels）扩展为（N, 1, channels），然后使用 repeat(1, bs, 1) 将其复制bs次，以匹配批次大小，使其变为（ N, bs, channels）的形状。 N是查询数量，d是嵌入维度

    5. mask = mask.flatten(1)：将掩码mask从二维形状（bs, seq_len）展平为一维形状（bs * seq_len），以适应Transformer的输入要求。

    6. tgt = torch.zeros_like(query_embed)：创建一个与query_embed具有相同形状的全零张量作为目标。（ N, bs, channels）

    7. memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)：将编码器（self.encoder）应用于输入src，并传递掩码 src_key_padding_mask 以屏蔽填充位置。位置编码 pos_embed 也被传递给编码器。  encoder的输出 (h * w，bs, channels)

    8. hs = self.decoder(tgt, memory, memory_key_padding_mask=mask, pos=pos_embed, query_pos=query_embed)：将解码器（self.decoder）应用于目标 tgt 和编码器的输出 memory，同时传递了掩码 memory_key_padding_mask、位置编码 pos_embed 以及查询位置编码 query_pos。    decoder的输出      （ N, bs, channels）的形状

    9. return hs.transpose(1, 2), memory.permute(1, 2, 0).view(bs, c, h, w)：将解码器的输出 hs 进行维度转置，使其变为（n, channels, bs），然后将编码器的输出 memory 进行维度变换，将其形状重新排列为（bs, channels, h, w ）。最后，返回这两个张量作为模型的输出。

    总之，该前向传播方法实现了Transformer模型的完整前向计算过程，包括编码器和解码器的操作。这是一个用于图像分析任务的变种Transformer模型。

    三、TransformerEncoder类

    1. class TransformerEncoder(nn.Module):
    2.  
    3.     def __init__(self, encoder_layer, num_layers, norm=None):
    4.         super().__init__()
    5.         self.layers = _get_clones(encoder_layer, num_layers)
    6.         self.num_layers = num_layers
    7.         self.norm = norm
    8.  
    9.     def forward(self, src,
    10.                 mask: Optional[Tensor] = None,
    11.                 src_key_padding_mask: Optional[Tensor] = None,
    12.                 pos: Optional[Tensor] = None):
    13.         output = src
    14.  
    15.         for layer in self.layers:
    16.             output = layer(output, src_mask=mask,
    17.                            src_key_padding_mask=src_key_padding_mask, pos=pos)
    18.  
    19.         if self.norm is not None:
    20.             output = self.norm(output)
    21.  
    22.         return output

    这是TransformerEncoder类的实现，它表示Transformer模型中的编码器部分。总之，TransformerEncoder类实现了Transformer模型的编码器部分，可以对输入序列进行多层编码处理，并可选地进行归一化处理。

    1、__init__()
    1. class TransformerEncoder(nn.Module):
    2.  
    3.     def __init__(self, encoder_layer, num_layers, norm=None):
    4.         super().__init__()
    5.         self.layers = _get_clones(encoder_layer, num_layers)
    6.         self.num_layers = num_layers
    7.         self.norm = norm

    这段代码定义了TransformerEncoder类的构造函数，用于初始化编码器对象。以下是每行代码的详细解释：

    1. def __init__(self, encoder_layer, num_layers, norm=None):：这是构造函数的定义，它接受以下参数：

      • encoder_layer：表示单个编码器层的实例，通常是 TransformerEncoderLayer 类的对象。
      • num_layers：表示编码器中包含多少个这样的编码器层，即要重复多少次 encoder_layer。
      • norm：可选参数，表示是否包含规范化层（Normalization Layer）。

    2. super().__init__()：调用父类的构造函数，确保正确地初始化nn.Module的基本功能。

    3. self.layers = _get_clones(encoder_layer, num_layers)：这行代码创建了一个包含多个编码器层的列表，这些层是通过克隆（复制）给定的encoder_layer创建的，克隆的数量由num_layers参数指定。这样，self.layers 中存储了多个编码器层的实例，用于构建多层编码器。

    4. self.num_layers = num_layers：存储编码器的层数，以备将来的引用。

    5. self.norm = norm：存储规范化层（Normalization Layer）的实例。这是一个可选参数，如果提供了规范化层，编码器在每个层之后都会进行规范化操作。

    总之，这段代码初始化了TransformerEncoder类的实例，创建了多个编码器层的列表，存储了编码器的层数和规范化层。这些成员变量将在编码器的前向传播中使用。

    2、forward()
    1.     def forward(self, src,
    2.                 mask: Optional[Tensor] = None,
    3.                 src_key_padding_mask: Optional[Tensor] = None,
    4.                 pos: Optional[Tensor] = None):
    5.         output = src
    6.  
    7.         for layer in self.layers:
    8.             output = layer(output, src_mask=mask,
    9.                            src_key_padding_mask=src_key_padding_mask, pos=pos)
    10.  
    11.         if self.norm is not None:
    12.             output = self.norm(output)
    13.  
    14.         return output

    这段代码定义了TransformerEncoder类的前向传播方法forward，该方法实现了编码器的前向计算。以下是每行代码的详细解释：

    1. def forward(self, src, mask: Optional[Tensor] = None, src_key_padding_mask: Optional[Tensor] = None, pos: Optional[Tensor] = None):：这是前向传播方法的定义，它接受以下参数：

      • src：表示输入序列的张量，即待编码的数据。
      • mask：可选参数，表示注意力掩码，用于控制哪些位置的信息被关注，哪些位置被忽略。
      • src_key_padding_mask：可选参数，表示对输入序列的填充位置进行掩码，以便在计算注意力时忽略这些位置的信息。
      • pos：可选参数，表示位置编码，用于引入序列元素的位置信息。

    2. output = src：将输入张量src赋值给output，这是初始的输出。

    3. for layer in self.layers:：这是一个循环，用于迭代遍历多个编码器层。

    4. output = layer(output, src_mask=mask, src_key_padding_mask=src_key_padding_mask, pos=pos)：在每个循环迭代中，将当前的output作为输入传递给编码器层layer，并同时传递掩码信息mask、填充位置掩码信息src_key_padding_mask以及位置编码pos。编码器层将执行自注意力机制和前馈神经网络等操作，然后更新output以包含更丰富的编码信息。

    5. if self.norm is not None:：检查是否存在规范化层。

    6. output = self.norm(output)：如果存在规范化层，对最终的output进行规范化操作，以确保输出的数值稳定性和可训练性。

    7. return output：返回最终的编码结果作为输出。这个输出包含了输入序列的编码表示，已经通过多个编码器层的处理。

    总之，这段代码实现了编码器的前向传播过程，通过多个编码器层对输入数据进行编码，并返回编码后的表示作为输出。每个编码器层都接受输入、注意力掩码、填充位置掩码和位置编码，然后更新输出。最终，如果存在规范化层，还会对输出进行规范化处理。

    四、TransformerDecoder类

    1. class TransformerDecoder(nn.Module):
    2.  
    3.     def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
    4.         super().__init__()
    5.         self.layers = _get_clones(decoder_layer, num_layers)
    6.         self.num_layers = num_layers
    7.         self.norm = norm
    8.         self.return_intermediate = return_intermediate
    9.  
    10.     def forward(self, tgt, memory,
    11.                 tgt_mask: Optional[Tensor] = None,
    12.                 memory_mask: Optional[Tensor] = None,
    13.                 tgt_key_padding_mask: Optional[Tensor] = None,
    14.                 memory_key_padding_mask: Optional[Tensor] = None,
    15.                 pos: Optional[Tensor] = None,
    16.                 query_pos: Optional[Tensor] = None):
    17.         output = tgt
    18.  
    19.         intermediate = []
    20.  
    21.         for layer in self.layers:
    22.             output = layer(output, memory, tgt_mask=tgt_mask,
    23.                            memory_mask=memory_mask,
    24.                            tgt_key_padding_mask=tgt_key_padding_mask,
    25.                            memory_key_padding_mask=memory_key_padding_mask,
    26.                            pos=pos, query_pos=query_pos)
    27.             if self.return_intermediate:
    28.                 intermediate.append(self.norm(output))
    29.  
    30.         if self.norm is not None:
    31.             output = self.norm(output)
    32.             if self.return_intermediate:
    33.                 intermediate.pop()
    34.                 intermediate.append(output)
    35.  
    36.         if self.return_intermediate:
    37.             return torch.stack(intermediate)
    38.  
    39.         return output.unsqueeze(0)

    这段代码定义了TransformerDecoder类，它表示Transformer的解码器部分。

    1、__init__()
    1. class TransformerDecoder(nn.Module):
    2.  
    3.     def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
    4.         super().__init__()
    5.         self.layers = _get_clones(decoder_layer, num_layers)
    6.         self.num_layers = num_layers
    7.         self.norm = norm
    8.         self.return_intermediate = return_intermediate

    这是TransformerDecoder类的初始化方法，用于创建一个Transformer解码器的实例。以下是每行代码的详细解释：

    1. def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):：初始化方法定义，接受以下参数：

      • decoder_layer：表示解码器层的类型，通常是TransformerDecoderLayer。
      • num_layers：表示解码器中要堆叠的解码器层数。
      • norm：可选参数，表示规范化层。
      • return_intermediate：可选参数，表示是否返回中间层的输出。

    2. super().__init__()：调用父类的构造函数，即nn.Module的构造函数，以确保正确初始化该类的基类部分。

    3. self.layers = _get_clones(decoder_layer, num_layers)：创建了一个包含多个解码器层的列表，这些层是由decoder_layer复制而来的，共有num_layers个。这样，可以堆叠多个解码器层以增加解码器的深度。

    4. self.num_layers = num_layers：记录解码器中的层数。

    5. self.norm = norm：存储规范化层。规范化层用于调整解码器层的输出，以确保输出的数值稳定性和可训练性。

    6. self.return_intermediate = return_intermediate：记录是否返回中间层的输出。如果设置为True，则在每个解码器层之后会保留中间层的输出，否则只返回最终解码器层的输出。

    总之，这个初始化方法用于配置解码器的结构，包括解码器层的堆叠、规范化层的设置以及是否返回中间层的输出。

    2、forward()
    1.     def forward(self, tgt, memory,
    2.                 tgt_mask: Optional[Tensor] = None,
    3.                 memory_mask: Optional[Tensor] = None,
    4.                 tgt_key_padding_mask: Optional[Tensor] = None,
    5.                 memory_key_padding_mask: Optional[Tensor] = None,
    6.                 pos: Optional[Tensor] = None,
    7.                 query_pos: Optional[Tensor] = None):
    8.         output = tgt
    9.  
    10.         intermediate = []

    这是TransformerDecoder类的前向传播方法，用于处理输入并生成解码器的输出。以下是每行代码的详细解释：

    1. def forward(self, tgt, memory, tgt_mask: Optional[Tensor] = None, memory_mask: Optional[Tensor] = None, tgt_key_padding_mask: Optional[Tensor] = None, memory_key_padding_mask: Optional[Tensor] = None, pos: Optional[Tensor] = None, query_pos: Optional[Tensor] = None):：前向传播方法的定义，接受多个参数，用于指定输入和各种掩码。

    2. output = tgt：将输入tgt赋值给output，这里的tgt通常表示目标序列（target sequence）。

    3. intermediate = []：创建一个空列表intermediate，用于存储中间层的输出。这个列表将用于保存每个解码器层的中间层输出，如果self.return_intermediate为True。

    总之，前向传播方法将输入目标序列tgt与记忆序列memory一起传递给解码器的层。在每个解码器层中，它执行解码操作，并根据需要应用掩码。如果self.return_intermediate为True，则还会保存每个解码器层的中间输出到intermediate列表中。最后，输出结果将是解码器的最终输出或中间输出的堆叠，具体取决于是否需要返回中间层输出。

    3、循环遍历解码器的多个层
    1.         for layer in self.layers:
    2.             output = layer(output, memory, tgt_mask=tgt_mask,
    3.                            memory_mask=memory_mask,
    4.                            tgt_key_padding_mask=tgt_key_padding_mask,
    5.                            memory_key_padding_mask=memory_key_padding_mask,
    6.                            pos=pos, query_pos=query_pos)
    7.             if self.return_intermediate:
    8.                 intermediate.append(self.norm(output))

    这部分代码是循环遍历解码器的多个层，遍历了解码器中的每个层（layer）。在Transformer模型中，通常会有多个相同结构的解码器层，每个层都独立处理输入数据。

    1. for layer in self.layers:：通过遍历self.layers中的每个解码器层

    2. output = layer(output, memory, tgt_mask=tgt_mask, memory_mask=memory_mask, tgt_key_padding_mask=tgt_key_padding_mask, memory_key_padding_mask=memory_key_padding_mask, pos=pos, query_pos=query_pos)：对当前解码器层(layer)进行前向传播。这里传递了多个参数：（1）memory：通常是编码器的输出，用于与解码器进行注意力计算。（2）tgt_mask 和 memory_mask：用于在自注意力机制中屏蔽（mask）某些位置，以防止模型关注到这些位置。（3）tgt_key_padding_mask 和 memory_key_padding_mask：用于指示哪些位置是填充（padding）的，不应该参与注意力计算。pos 和 query_pos：位置编码信息。

    3. if self.return_intermediate:：检查是否需要返回中间层的输出，即self.return_intermediate是否为True。

    4. intermediate.append(self.norm(output))：如果 self.return_intermediate 为True，并且解码器层的输出需要被标准化（归一化），则将当前层的输出 output 经过标准化后添加到 intermediate 列表中。这将保留每个解码器层的中间输出。

    4、norm及intermediate
    1.         if self.norm is not None:
    2.             output = self.norm(output)
    3.             if self.return_intermediate:
    4.                 intermediate.pop()
    5.                 intermediate.append(output)
    6.  
    7.         if self.return_intermediate:
    8.             return torch.stack(intermediate)
    9.  
    10.         return output.unsqueeze(0)

    这是另一个条件语句，检查是否设置了 self.norm。

    1. if self.norm is not None：检查是否存在标准化层。如果self.norm不为None，表示需要对输出进行标准化。

    2. output = self.norm(output)：self.norm 通常是解码器层后的正规化（归一化）层，用于归一化整个解码器的输出。

    3. if self.return_intermediate：再次检查是否需要返回中间层的输出。

    4. intermediate.pop()：如果需要返回中间层的输出，这里会从intermediate列表中移除最后一个元素，因为我们已经在前面的代码行中将当前的标准化后的输出添加到了intermediate中。

    5. intermediate.append(output)：将标准化后的输出再次添加到intermediate列表中，以确保最终列表中包含的是标准化后的输出。

    6. if self.return_intermediate：再次检查是否需要返回中间层的输出。

    7. return torch.stack(intermediate)：则返回每个解码器层的中间输出的堆叠。这将返回一个形状为(num_layers, batch_size, sequence_length, d_model)的张量，其中num_layers是解码器层数。这是为了在训练过程中分析每个层的输出。每个中间输出都包含了解码器处理输入数据的某一阶段的信息。

    8. return output.unsqueeze(0)：如果 self.return_intermediate 为False，表示只返回最后一个解码器层的输出。解码器的最终输出被添加一个额外的维度以满足形状要求。这里使用unsqueeze(0)将输出的维度从(batch_size, sequence_length, d_model)扩展为(1, batch_size, sequence_length, d_model)，以符合模型的预期输出形状。

    五、TransformerEncoderLayer

    1. class TransformerEncoderLayer(nn.Module):
    2.  
    3.     def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
    4.                  activation="relu", normalize_before=False):
    5.         super().__init__()
    6.         self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
    7.         # Implementation of Feedforward model
    8.         self.linear1 = nn.Linear(d_model, dim_feedforward)
    9.         self.dropout = nn.Dropout(dropout)
    10.         self.linear2 = nn.Linear(dim_feedforward, d_model)
    11.  
    12.         self.norm1 = nn.LayerNorm(d_model)
    13.         self.norm2 = nn.LayerNorm(d_model)
    14.         self.dropout1 = nn.Dropout(dropout)
    15.         self.dropout2 = nn.Dropout(dropout)
    16.  
    17.         self.activation = _get_activation_fn(activation)
    18.         self.normalize_before = normalize_before
    19.  
    20.     def with_pos_embed(self, tensor, pos: Optional[Tensor]):
    21.         return tensor if pos is None else tensor + pos
    22.  
    23.     def forward_post(self,
    24.                      src,
    25.                      src_mask: Optional[Tensor] = None,
    26.                      src_key_padding_mask: Optional[Tensor] = None,
    27.                      pos: Optional[Tensor] = None):
    28.         q = k = self.with_pos_embed(src, pos)
    29.         src2 = self.self_attn(q, k, value=src, attn_mask=src_mask,
    30.                               key_padding_mask=src_key_padding_mask)[0]
    31.         src = src + self.dropout1(src2)
    32.         src = self.norm1(src)
    33.         src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
    34.         src = src + self.dropout2(src2)
    35.         src = self.norm2(src)
    36.         return src
    37.  
    38.     def forward_pre(self, src,
    39.                     src_mask: Optional[Tensor] = None,
    40.                     src_key_padding_mask: Optional[Tensor] = None,
    41.                     pos: Optional[Tensor] = None):
    42.         src2 = self.norm1(src)
    43.         q = k = self.with_pos_embed(src2, pos)
    44.         src2 = self.self_attn(q, k, value=src2, attn_mask=src_mask,
    45.                               key_padding_mask=src_key_padding_mask)[0]
    46.         src = src + self.dropout1(src2)
    47.         src2 = self.norm2(src)
    48.         src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))
    49.         src = src + self.dropout2(src2)
    50.         return src
    51.  
    52.     def forward(self, src,
    53.                 src_mask: Optional[Tensor] = None,
    54.                 src_key_padding_mask: Optional[Tensor] = None,
    55.                 pos: Optional[Tensor] = None):
    56.         if self.normalize_before:
    57.             return self.forward_pre(src, src_mask, src_key_padding_mask, pos)
    58.         return self.forward_post(src, src_mask, src_key_padding_mask, pos)

    这是Transformer编码器层的代码。

    1、__init__()
    1. class TransformerEncoderLayer(nn.Module):
    2.  
    3.     def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
    4.                  activation="relu", normalize_before=False):
    5.         super().__init__()
    6.         self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
    7.         # Implementation of Feedforward model
    8.         self.linear1 = nn.Linear(d_model, dim_feedforward)
    9.         self.dropout = nn.Dropout(dropout)
    10.         self.linear2 = nn.Linear(dim_feedforward, d_model)
    11.  
    12.         self.norm1 = nn.LayerNorm(d_model)
    13.         self.norm2 = nn.LayerNorm(d_model)
    14.         self.dropout1 = nn.Dropout(dropout)
    15.         self.dropout2 = nn.Dropout(dropout)
    16.  
    17.         self.activation = _get_activation_fn(activation)
    18.         self.normalize_before = normalize_before

    这是Transformer编码器层的初始化方法，它设置了该层的各个组件和参数。

    1. super().__init__()：调用父类（nn.Module）的初始化方法。

    2. self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)：创建了一个多头自注意力机制层。这一层将输入的特征进行自注意力计算。

    3. self.linear1 = nn.Linear(d_model, dim_feedforward)：创建了一个线性变换层，用于将输入特征映射到一个中间维度（dim_feedforward）的空间。

    4. self.dropout = nn.Dropout(dropout)：创建了一个Dropout层，用于在训练过程中进行随机失活以防止过拟合。

    5. self.linear2 = nn.Linear(dim_feedforward, d_model)：创建了另一个线性变换层，将中间维度的特征映射回原始维度（d_model）。

    6. self.norm1 = nn.LayerNorm(d_model) 和 self.norm2 = nn.LayerNorm(d_model)：分别创建了两个层归一化层，用于归一化输入特征。

    7. self.dropout1 = nn.Dropout(dropout) 和 self.dropout2 = nn.Dropout(dropout)：创建了两个Dropout层，用于在自注意力和前馈神经网络之间的层之间进行随机失活。

    8. self.activation = _get_activation_fn(activation)：根据指定的激活函数类型创建了激活函数。

    9. self.normalize_before = normalize_before：记录是否在自注意力和前馈神经网络之前应用层归一化。这是一个布尔值。

    这个初始化方法设置了Transformer编码器层的各个组件，用于处理输入特征。根据 normalize_before 参数的不同设置，它可以选择在不同的位置应用层归一化。

    2、with_pos_embed（）
    1.     def with_pos_embed(self, tensor, pos: Optional[Tensor]):
    2.         return tensor if pos is None else tensor + pos

    这是Transformer编码器层中的一个辅助函数，用于将位置编码（pos）与输入特征张量（tensor）相加（如果pos不为None的话），以考虑位置信息。在（七）backbone.py中，经过Joiner()类得到的，features和pos还是分离的，在这把它们相加在一起。

    • def with_pos_embed(self, tensor, pos: Optional[Tensor]):：这是一个方法定义，它接受两个参数，tensor 和 pos。tensor 是输入特征张量，pos 是位置编码张量，它们可以是可选的张量对象（Optional[Tensor] 表示参数可以是张量，也可以是None）。

    • return tensor if pos is None else tensor + pos：这行代码实现了函数的逻辑。它首先检查 pos 是否为None。如果 pos 为None，就返回输入的 tensor，表示不考虑位置编码。如果 pos 不为None，就执行 tensor + pos 的操作，将位置编码与输入特征相加，以获得包含位置信息的特征张量。

    这个函数的作用是将位置编码与输入特征相结合，以考虑对象在序列中的位置。这在自注意力机制中特别有用，因为它帮助模型更好地理解输入序列中的元素之间的相对位置关系。这是Transformer模型中用于处理序列数据的重要组成部分。

    左边为forward_pre()，右边为forward_post()

    3、 forward_post（）
    1.     def forward_post(self,
    2.                      src,
    3.                      src_mask: Optional[Tensor] = None,
    4.                      src_key_padding_mask: Optional[Tensor] = None,
    5.                      pos: Optional[Tensor] = None):
    6.         q = k = self.with_pos_embed(src, pos)
    7.         src2 = self.self_attn(q, k, value=src, attn_mask=src_mask,
    8.                               key_padding_mask=src_key_padding_mask)[0]
    9.         src = src + self.dropout1(src2)
    10.         src = self.norm1(src)
    11.         src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
    12.         src = src + self.dropout2(src2)
    13.         src = self.norm2(src)
    14.         return src

    先注意力再norm

    这段代码是Transformer编码器层中的前向传播方法 forward_post 的实现，用于处理输入序列。

    每个操作后的形状都应该与输入数据 src 的形状相同，这有助于确保模型在每个处理阶段保持相同的数据形状，以便进行后续的计算和处理

    • def forward_post(self, src, src_mask: Optional[Tensor] = None, src_key_padding_mask: Optional[Tensor] = None, pos: Optional[Tensor] = None)：这是一个方法定义，它接受四个参数，分别是 src、src_mask、src_key_padding_mask 和 pos。（1）src 是输入特征张量，（2）src_mask 是用于自注意力机制的掩码（可选），（3）src_key_padding_mask 是用于屏蔽填充位置的掩码（可选），（4）pos 是位置编码张量（可选）。

    • q = k = self.with_pos_embed(src, pos)：这行代码使用 with_pos_embed 方法将位置编码 pos 添加到输入特征 src 中，生成查询（q）和键（k）。 

    • src2 = self.self_attn(q, k, value=src, attn_mask=src_mask, key_padding_mask=src_key_padding_mask)[0]：这行代码执行自注意力机制操作。它使用查询（q）和键（k）计算注意力分布，并将该分布应用于值（value）张量 src。attn_mask 用于屏蔽不需要考虑的位置，key_padding_mask 用于屏蔽填充位置。注意力机制的输出被解包为元组，并且我们只取第一个元素，即注意力加权的结果。（src 的每个位置现在包含了该位置与整个输入序列中其他位置的相关性的信息。）

    • q：查询（query）向量，通常表示当前位置的信息。k：键（key）向量，用于计算注意力权重。

    • value=src：值（value）向量，包含了整个输入序列的信息。

    • attn_mask=src_mask：用于屏蔽（mask）注意力的掩码，通常用于防止模型关注特定位置。

    • key_padding_mask=src_key_padding_mask：用于遮蔽注意力中的键（key）的掩码，通常用于指示哪些位置是填充（padding）的。

    • 自注意力操作计算了注意力权重，并将这些权重应用于值 src 上，得到了经过自注意力操作的输出 src2。src2 包含了加权的信息，其中每个位置都受到其他位置的注意力影响。

    • src = src + self.dropout1(src2)：这行代码将注意力加权的结果与输入特征张量相加，以便引入注意力信息。self.dropout1 是一个丢弃层，用于防止过拟合。

    • src = self.norm1(src)：这行代码执行第一个层归一化操作，将特征张量 src 进行标准化，以便加速训练。

    • src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))：这行代码执行前馈神经网络（Feedforward Network）操作，对特征张量进行非线性变换。具体来说，它首先应用线性变换 self.linear1，然后使用激活函数 self.activation 进行非线性映射，最后应用线性变换 self.linear2。

    • src = src + self.dropout2(src2)：这行代码将前馈神经网络的输出与输入特征张量相加，以引入更多的非线性变换。self.dropout2 是另一个丢弃层，用于防止过拟合。

    • src = self.norm2(src)：这行代码执行第二个层归一化操作，将特征张量 src 进行标准化。

    • return src：最后，该方法返回处理后的特征张量 src 作为输出。

    总之，这个方法实现了Transformer编码器层的前向传播，包括自注意力机制和前馈神经网络操作，以便对输入序列进行特征提取和表示学习。

    4、forward_pre()

    先norm再注意力

    1.     def forward_pre(self, src,
    2.                     src_mask: Optional[Tensor] = None,
    3.                     src_key_padding_mask: Optional[Tensor] = None,
    4.                     pos: Optional[Tensor] = None):
    5.         src2 = self.norm1(src)
    6.         q = k = self.with_pos_embed(src2, pos)
    7.         src2 = self.self_attn(q, k, value=src2, attn_mask=src_mask,
    8.                               key_padding_mask=src_key_padding_mask)[0]
    9.         src = src + self.dropout1(src2)
    10.         src2 = self.norm2(src)
    11.         src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))
    12.         src = src + self.dropout2(src2)
    13.         return src

    这段代码是Transformer编码器层中的前向传播方法 forward_pre 的实现，用于处理输入序列。

    • def forward_pre(self, src, src_mask: Optional[Tensor] = None, src_key_padding_mask: Optional[Tensor] = None, pos: Optional[Tensor] = None):：这是一个方法定义，它接受四个参数，分别是 src、src_mask、src_key_padding_mask 和 pos。src 是输入特征张量，src_mask 是用于自注意力机制的掩码（可选），src_key_padding_mask 是用于屏蔽填充位置的掩码（可选），pos 是位置编码张量（可选）。

    • src2 = self.norm1(src)：这行代码执行第一个层归一化操作，将特征张量 src 进行标准化，以便加速训练。这是在自注意力之前执行的。

    • q = k = self.with_pos_embed(src2, pos)：这行代码使用 with_pos_embed 方法将位置编码 pos 添加到输入特征 src2 中，生成查询（q）和键（k）。

    • src2 = self.self_attn(q, k, value=src2, attn_mask=src_mask, key_padding_mask=src_key_padding_mask)[0]：这行代码执行自注意力机制操作。它使用查询（q）和键（k）计算注意力分布，并将该分布应用于值（value）张量 src2。attn_mask 用于屏蔽不需要考虑的位置，key_padding_mask 用于屏蔽填充位置。注意力机制的输出被解包为元组，并且我们只取第一个元素，即注意力加权的结果。

    • src = src + self.dropout1(src2)：这行代码将注意力加权的结果与输入特征张量相加，以便引入注意力信息。self.dropout1 是一个丢弃层，用于防止过拟合。

    • src2 = self.norm2(src)：这行代码执行第二个层归一化操作，将特征张量 src 进行标准化。

    • src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))：这行代码执行前馈神经网络（Feedforward Network）操作，对特征张量进行非线性变换。具体来说，它首先应用线性变换 self.linear1，然后使用激活函数 self.activation 进行非线性映射，最后应用线性变换 self.linear2。

    • src = src + self.dropout2(src2)：这行代码将前馈神经网络的输出与输入特征张量相加，以引入更多的非线性变换。self.dropout2 是另一个丢弃层，用于防止过拟合。

    • return src：最后，该方法返回处理后的特征张量 src 作为输出。

    总之，这个方法实现了Transformer编码器层的前向传播，包括自注意力机制和前馈神经网络操作，以便对输入序列进行特征提取和表示学习。这里的不同之处在于层归一化的位置，它是在自注意力之前执行的。

    5、forward()
    1.     def forward(self, src,
    2.                 src_mask: Optional[Tensor] = None,
    3.                 src_key_padding_mask: Optional[Tensor] = None,
    4.                 pos: Optional[Tensor] = None):
    5.         if self.normalize_before:
    6.             return self.forward_pre(src, src_mask, src_key_padding_mask, pos)
    7.         return self.forward_post(src, src_mask, src_key_padding_mask, pos)

    这段代码是 `TransformerEncoderLayer` 类的 `forward` 方法的实现，根据 `normalize_before` 参数决定是执行 `forward_pre` 还是 `forward_post` 方法。

    - `def forward(self, src, src_mask: Optional[Tensor] = None, src_key_padding_mask: Optional[Tensor] = None, pos: Optional[Tensor] = None):`：这是方法定义，接受四个输入参数，包括 `src`（输入特征张量）、`src_mask`（自注意力掩码，可选）、`src_key_padding_mask`（键值填充掩码，可选）和 `pos`（位置编码，可选）。

    - `if self.normalize_before:`：这是一个条件语句，检查 `normalize_before` 是否为真（即是否启用了归一化操作在自注意力之前）。如果为真，则执行以下代码块。

      - `return self.forward_pre(src, src_mask, src_key_padding_mask, pos)`：这行代码调用 `forward_pre` 方法，执行自注意力和前馈神经网络等操作，并将结果返回。

    - 如果 `normalize_before` 为假，表示不需要在自注意力之前执行归一化操作，那么代码将执行以下操作。

      - `return self.forward_post(src, src_mask, src_key_padding_mask, pos)`：这行代码调用 `forward_post` 方法，执行自注意力和前馈神经网络等操作，并将结果返回。

    总之，这个 `forward` 方法根据 `normalize_before` 参数的值，选择性地执行 `forward_pre` 或 `forward_post` 方法来进行特征提取和处理。这种设计允许用户根据需求选择在自注意力之前或之后应用归一化操作。

    六、TransformerDecoder层

    1. class TransformerDecoderLayer(nn.Module):
    2.  
    3.     def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
    4.                  activation="relu", normalize_before=False):
    5.         super().__init__()
    6.         self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
    7.         self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
    8.         # Implementation of Feedforward model
    9.         self.linear1 = nn.Linear(d_model, dim_feedforward)
    10.         self.dropout = nn.Dropout(dropout)
    11.         self.linear2 = nn.Linear(dim_feedforward, d_model)
    12.  
    13.         self.norm1 = nn.LayerNorm(d_model)
    14.         self.norm2 = nn.LayerNorm(d_model)
    15.         self.norm3 = nn.LayerNorm(d_model)
    16.         self.dropout1 = nn.Dropout(dropout)
    17.         self.dropout2 = nn.Dropout(dropout)
    18.         self.dropout3 = nn.Dropout(dropout)
    19.  
    20.         self.activation = _get_activation_fn(activation)
    21.         self.normalize_before = normalize_before
    22.  
    23.     def with_pos_embed(self, tensor, pos: Optional[Tensor]):
    24.         return tensor if pos is None else tensor + pos
    25.  
    26.     def forward_post(self, tgt, memory,
    27.                      tgt_mask: Optional[Tensor] = None,
    28.                      memory_mask: Optional[Tensor] = None,
    29.                      tgt_key_padding_mask: Optional[Tensor] = None,
    30.                      memory_key_padding_mask: Optional[Tensor] = None,
    31.                      pos: Optional[Tensor] = None,
    32.                      query_pos: Optional[Tensor] = None):
    33.         q = k = self.with_pos_embed(tgt, query_pos)
    34.         tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask,
    35.                               key_padding_mask=tgt_key_padding_mask)[0]
    36.         tgt = tgt + self.dropout1(tgt2)
    37.         tgt = self.norm1(tgt)
    38.         tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos),
    39.                                    key=self.with_pos_embed(memory, pos),
    40.                                    value=memory, attn_mask=memory_mask,
    41.                                    key_padding_mask=memory_key_padding_mask)[0]
    42.         tgt = tgt + self.dropout2(tgt2)
    43.         tgt = self.norm2(tgt)
    44.         tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
    45.         tgt = tgt + self.dropout3(tgt2)
    46.         tgt = self.norm3(tgt)
    47.         return tgt
    48.  
    49.     def forward_pre(self, tgt, memory,
    50.                     tgt_mask: Optional[Tensor] = None,
    51.                     memory_mask: Optional[Tensor] = None,
    52.                     tgt_key_padding_mask: Optional[Tensor] = None,
    53.                     memory_key_padding_mask: Optional[Tensor] = None,
    54.                     pos: Optional[Tensor] = None,
    55.                     query_pos: Optional[Tensor] = None):
    56.         tgt2 = self.norm1(tgt)
    57.         q = k = self.with_pos_embed(tgt2, query_pos)
    58.         tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask,
    59.                               key_padding_mask=tgt_key_padding_mask)[0]
    60.         tgt = tgt + self.dropout1(tgt2)
    61.         tgt2 = self.norm2(tgt)
    62.         tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos),
    63.                                    key=self.with_pos_embed(memory, pos),
    64.                                    value=memory, attn_mask=memory_mask,
    65.                                    key_padding_mask=memory_key_padding_mask)[0]
    66.         tgt = tgt + self.dropout2(tgt2)
    67.         tgt2 = self.norm3(tgt)
    68.         tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
    69.         tgt = tgt + self.dropout3(tgt2)
    70.         return tgt
    71.  
    72.     def forward(self, tgt, memory,
    73.                 tgt_mask: Optional[Tensor] = None,
    74.                 memory_mask: Optional[Tensor] = None,
    75.                 tgt_key_padding_mask: Optional[Tensor] = None,
    76.                 memory_key_padding_mask: Optional[Tensor] = None,
    77.                 pos: Optional[Tensor] = None,
    78.                 query_pos: Optional[Tensor] = None):
    79.         if self.normalize_before:
    80.             return self.forward_pre(tgt, memory, tgt_mask, memory_mask,
    81.                                     tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)
    82.         return self.forward_post(tgt, memory, tgt_mask, memory_mask,
    83.                                  tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)

    这段代码实现了 TransformerDecoderLayer 类，它是 Transformer 解码器中的一个层，总的来说，TransformerDecoderLayer 是 Transformer 解码器的一个层，包括自注意力、多头自注意力和前馈神经网络，以及归一化和 Dropout 操作。这个层可以用于构建 Transformer 解码器。

    1、__init__()
    1. class TransformerDecoderLayer(nn.Module):
    2.  
    3.     def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
    4.                  activation="relu", normalize_before=False):
    5.         super().__init__()
    6.         self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
    7.         self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
    8.         # Implementation of Feedforward model
    9.         self.linear1 = nn.Linear(d_model, dim_feedforward)
    10.         self.dropout = nn.Dropout(dropout)
    11.         self.linear2 = nn.Linear(dim_feedforward, d_model)
    12.  
    13.         self.norm1 = nn.LayerNorm(d_model)
    14.         self.norm2 = nn.LayerNorm(d_model)
    15.         self.norm3 = nn.LayerNorm(d_model)
    16.         self.dropout1 = nn.Dropout(dropout)
    17.         self.dropout2 = nn.Dropout(dropout)
    18.         self.dropout3 = nn.Dropout(dropout)
    19.  
    20.         self.activation = _get_activation_fn(activation)
    21.         self.normalize_before = normalize_before

    这段代码定义了 `TransformerDecoderLayer` 类，该类是 Transformer 解码器中的一个层，包含以下参数和组件：

    - `d_model`：模型的维度大小，通常是输入嵌入的维度和输出嵌入的维度，它表示了模型中特征的维度。

    - `nhead`：多头注意力机制的头数，决定了自注意力机制被划分为多少个子空间，每个头都学习不同的表示。

    - `dim_feedforward`：前馈神经网络隐藏层的维度，它是自注意力子层后的前馈神经网络的维度。

    - `dropout`：Dropout 概率，用于在模型训练时随机丢弃一部分神经元，以减少过拟合。

    - `activation`：激活函数的类型，通常为 ReLU。

    - `normalize_before`：一个布尔值，确定是否在自注意力和前馈神经网络之前执行归一化操作。

    接下来，该类创建了以下组件：

    - `self.self_attn` 和 `self.multihead_attn`：多头注意力机制，分别用于自注意力和多头自注意力操作。

    - `self.linear1` 和 `self.linear2`：两个线性层，用于前馈神经网络中的线性变换。

    - `self.norm1`、`self.norm2` 和 `self.norm3`：LayerNorm 归一化层，分别用于自注意力、多头自注意力和前馈神经网络。

    - `self.dropout1`、`self.dropout2` 和 `self.dropout3`：Dropout 层，用于自注意力、多头自注意力和前馈神经网络。

    - `self.activation`：激活函数，通常为 ReLU。

    接下来，该类定义了三个方法，分别用于执行不同步骤的前向传播操作：

    - `with_pos_embed` 方法接受一个输入张量 `tensor` 和一个位置编码张量 `pos`（可选），并返回二者相加的结果。这个方法用于将位置编码添加到输入张量中，以便在自注意力操作中使用。

    - `forward_post` 方法执行层的前向传播操作，包括自注意力、多头自注意力和前馈神经网络，以及归一化和 Dropout 操作。

    - `forward_pre` 方法执行层的前向传播操作，包括自注意力、多头自注意力和前馈神经网络，以及归一化和 Dropout 操作。

    最后，`forward` 方法根据 `normalize_before` 参数确定是调用 `forward_pre` 还是 `forward_post` 方法来执行前向传播。这取决于是否在自注意力之前执行归一化。

    2、with_pos_embed()
    1.     def with_pos_embed(self, tensor, pos: Optional[Tensor]):
    2.         return tensor if pos is None else tensor + pos

    这是 `TransformerDecoderLayer` 类中的一个方法，其作用是将位置编码（`pos`）添加到输入张量（`tensor`）中，如果位置编码为 `None`，则直接返回输入张量。

    具体来说，该方法首先检查传入的位置编码 `pos` 是否为 `None`。如果 `pos` 是 `None`，则说明不需要添加位置编码，直接返回原始输入张量 `tensor`。如果 `pos` 不是 `None`，则将输入张量 `tensor` 和位置编码张量 `pos` 进行逐元素相加，从而实现了将位置编码与输入张量相叠加的操作。

    这个方法的目的是为了在自注意力操作中使用位置编码，以便模型能够根据输入的位置信息更好地理解序列数据。在 Transformer 模型中，位置编码通常会与输入嵌入相加，以为模型提供关于每个输入位置的信息。

     左边为forward_pre()，右边为forward_post()

    3、forward_post()
    1.     def forward_post(self, tgt, memory,
    2.                      tgt_mask: Optional[Tensor] = None,
    3.                      memory_mask: Optional[Tensor] = None,
    4.                      tgt_key_padding_mask: Optional[Tensor] = None,
    5.                      memory_key_padding_mask: Optional[Tensor] = None,
    6.                      pos: Optional[Tensor] = None,
    7.                      query_pos: Optional[Tensor] = None):
    8.         q = k = self.with_pos_embed(tgt, query_pos)
    9.         tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask,
    10.                               key_padding_mask=tgt_key_padding_mask)[0]
    11.         tgt = tgt + self.dropout1(tgt2)
    12.         tgt = self.norm1(tgt)
    13.         tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos),
    14.                                    key=self.with_pos_embed(memory, pos),
    15.                                    value=memory, attn_mask=memory_mask,
    16.                                    key_padding_mask=memory_key_padding_mask)[0]
    17.         tgt = tgt + self.dropout2(tgt2)
    18.         tgt = self.norm2(tgt)
    19.         tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
    20.         tgt = tgt + self.dropout3(tgt2)
    21.         tgt = self.norm3(tgt)
    22.         return tgt

    这是 `TransformerDecoderLayer` 类中的一个方法，表示 Transformer 解码器层的前向传播操作。该方法接受多个输入参数，包括 `tgt`（目标序列的表示）、`memory`（编码器的输出，通常作为上下文信息）、`tgt_mask`、`memory_mask`、`tgt_key_padding_mask`、`memory_key_padding_mask`、`pos` 和 `query_pos`（位置编码信息）。

    下面是每行代码的详细解释：

    1. `q = k = self.with_pos_embed(tgt, query_pos)`

    将位置编码 `query_pos` 添加到目标序列 `tgt` 中，以便在自注意力机制中使用。这里同时给 `q` 和 `k` 赋相同的值，因为它们在自注意力中充当查询和键。

    2. `tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask)[0]`

    使用自注意力机制（`self_attn`）计算目标序列 `tgt` 中的注意力，其中 `tgt_mask` 用于屏蔽未来信息，`tgt_key_padding_mask` 用于屏蔽填充的标记。这将生成更新后的目标序列表示 `tgt2`。

    3. `tgt = tgt + self.dropout1(tgt2)`

    将原始目标序列 `tgt` 与通过自注意力计算得到的 `tgt2` 相加，以引入自注意力的信息。`dropout1` 用于应用丢弃操作，以减少过拟合。

    4. `tgt = self.norm1(tgt)`

    应用 Layer Normalization 到更新后的目标序列 `tgt` 上，以规范化其特征。

    5. `tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos), key=self.with_pos_embed(memory, pos), value=memory, attn_mask=memory_mask, key_padding_mask=memory_key_padding_mask)[0]`

    使用多头注意力机制（`multihead_attn`）计算目标序列 `tgt` 与编码器输出 `memory` 之间的注意力，以捕获上下文信息。`query` 表示目标序列，`key` 表示编码器输出，`value` 表示编码器输出。`memory_mask` 和 `memory_key_padding_mask` 用于控制注意力的计算。

    6. `tgt = tgt + self.dropout2(tgt2)`

    将目标序列 `tgt` 与上一步计算得到的 `tgt2` 相加，以引入编码器的上下文信息。同样，`dropout2` 用于丢弃操作。

    7. `tgt = self.norm2(tgt)`

    再次应用 Layer Normalization 到更新后的目标序列 `tgt` 上。

    8. `tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))`

    通过两个线性层和激活函数执行前馈神经网络（Feedforward Neural Network）操作。这有助于捕获更复杂的特征。

    9. `tgt = tgt + self.dropout3(tgt2)`

    将目标序列 `tgt` 与前馈神经网络的输出 `tgt2` 相加，以引入更高级的表示信息。`dropout3` 用于丢弃操作。

    10. `tgt = self.norm3(tgt)`

    最后一次应用 Layer Normalization 到更新后的目标序列 `tgt` 上。

    11. `return tgt`

    返回更新后的目标序列作为解码器层的输出。

    总之，这个方法实现了 Transformer 解码器层的前向传播，包括自注意力和多头注意力机制，以及前馈神经网络操作，用于生成解码器的输出。这些操作允许模型在生成目标序列时考虑输入序列和上下文信息。

    4、forward_pre()
    1.     def forward_pre(self, tgt, memory,
    2.                     tgt_mask: Optional[Tensor] = None,
    3.                     memory_mask: Optional[Tensor] = None,
    4.                     tgt_key_padding_mask: Optional[Tensor] = None,
    5.                     memory_key_padding_mask: Optional[Tensor] = None,
    6.                     pos: Optional[Tensor] = None,
    7.                     query_pos: Optional[Tensor] = None):
    8.         tgt2 = self.norm1(tgt)
    9.         q = k = self.with_pos_embed(tgt2, query_pos)
    10.         tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask,
    11.                               key_padding_mask=tgt_key_padding_mask)[0]
    12.         tgt = tgt + self.dropout1(tgt2)
    13.         tgt2 = self.norm2(tgt)
    14.         tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos),
    15.                                    key=self.with_pos_embed(memory, pos),
    16.                                    value=memory, attn_mask=memory_mask,
    17.                                    key_padding_mask=memory_key_padding_mask)[0]
    18.         tgt = tgt + self.dropout2(tgt2)
    19.         tgt2 = self.norm3(tgt)
    20.         tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
    21.         tgt = tgt + self.dropout3(tgt2)
    22.         return tgt

    这是 `TransformerDecoderLayer` 类中的另一个方法，表示 Transformer 解码器层的前向传播操作，但与之前的方法 `forward_post` 有所不同。这个方法在不同的顺序下应用了层归一化（Layer Normalization），自注意力（Self-Attention）和多头注意力（Multi-Head Attention）等操作。

    下面是每行代码的详细解释：

    1. `tgt2 = self.norm1(tgt)`

    首先，将输入目标序列 `tgt` 应用 Layer Normalization，以规范化其特征。

    2. `q = k = self.with_pos_embed(tgt2, query_pos)`

    然后，将位置编码 `query_pos` 添加到 `tgt2` 中，以供后续的自注意力和多头注意力机制使用。同时，`q` 和 `k` 都赋予相同的值，因为它们在自注意力中充当查询和键。

    3. `tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask)[0]`

    接下来，使用自注意力机制（`self_attn`）计算目标序列 `tgt2` 上的自注意力，其中 `tgt_mask` 用于屏蔽未来信息，`tgt_key_padding_mask` 用于屏蔽填充的标记。这将生成更新后的目标序列表示 `tgt2`。

    4. `tgt = tgt + self.dropout1(tgt2)`

    将原始目标序列 `tgt` 与通过自注意力计算得到的 `tgt2` 相加，以引入自注意力的信息。`dropout1` 用于应用丢弃操作，以减少过拟合。

    5. `tgt2 = self.norm2(tgt)`

    再次应用 Layer Normalization 到更新后的目标序列 `tgt` 上，以规范化其特征。

    6. `tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos), key=self.with_pos_embed(memory, pos), value=memory, attn_mask=memory_mask, key_padding_mask=memory_key_padding_mask)[0]`

    然后，使用多头注意力机制（`multihead_attn`）计算目标序列 `tgt2` 与编码器输出 `memory` 之间的注意力，以捕获上下文信息。`query` 表示目标序列，`key` 表示编码器输出，`value` 表示编码器输出。`memory_mask` 和 `memory_key_padding_mask` 用于控制注意力的计算。

    7. `tgt = tgt + self.dropout2(tgt2)`

    将目标序列 `tgt` 与上一步计算得到的 `tgt2` 相加，以引入编码器的上下文信息。同样，`dropout2` 用于丢弃操作。

    8. `tgt2 = self.norm3(tgt)`

    最后一次应用 Layer Normalization 到更新后的目标序列 `tgt` 上，以规范化其特征。

    9. `tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))`

    通过两个线性层和激活函数执行前馈神经网络（Feedforward Neural Network）操作。这有助于捕获更复杂的特征。

    10. `tgt = tgt + self.dropout3(tgt2)`

    将目标序列 `tgt` 与前馈神经网络的输出 `tgt2` 相加，以引入更高级的表示信息。`dropout3` 用于丢弃操作。

    11. `return tgt`

    返回更新后的目标序列作为解码器层的输出。

    总之，这个方法实现了 Transformer 解码器层的前向传播，但与 `forward_post` 方法相比，它在不同的顺序下应用了操作。这些操作允许模型在生成目标序列时考虑输入序列和上下文信息，但是它们的计算顺序不同。

    5、forward()
    1.     def forward(self, tgt, memory,
    2.                 tgt_mask: Optional[Tensor] = None,
    3.                 memory_mask: Optional[Tensor] = None,
    4.                 tgt_key_padding_mask: Optional[Tensor] = None,
    5.                 memory_key_padding_mask: Optional[Tensor] = None,
    6.                 pos: Optional[Tensor] = None,
    7.                 query_pos: Optional[Tensor] = None):
    8.         if self.normalize_before:
    9.             return self.forward_pre(tgt, memory, tgt_mask, memory_mask,
    10.                                     tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)
    11.         return self.forward_post(tgt, memory, tgt_mask, memory_mask,
    12.                                  tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)

    这个 `forward` 方法实际上是 `TransformerDecoderLayer` 的主要前向传播方法，它根据是否使用 "normalize_before" 标志来选择是执行 "forward_pre" 还是 "forward_post" 方法。

    以下是每行代码的详细解释：

    1. `if self.normalize_before:`：这是一个条件语句，检查 `normalize_before` 标志是否为真。如果 `normalize_before` 为真，它将执行 "forward_pre" 方法，否则将执行 "forward_post" 方法。

    2. `return self.forward_pre(tgt, memory, tgt_mask, memory_mask, tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)`：如果 `normalize_before` 为真，就调用 "forward_pre" 方法，将目标序列 `tgt`、编码器输出 `memory`、目标序列掩码 `tgt_mask`、编码器输出掩码 `memory_mask`、目标序列的键掩码 `tgt_key_padding_mask`、编码器输出的键掩码 `memory_key_padding_mask`、位置编码 `pos` 以及查询位置编码 `query_pos` 传递给 "forward_pre" 方法。然后，它返回 "forward_pre" 方法的结果。

    3. `return self.forward_post(tgt, memory, tgt_mask, memory_mask, tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)`：如果 `normalize_before` 为假，就调用 "forward_post" 方法，将相同的参数传递给 "forward_post" 方法。然后，它返回 "forward_post" 方法的结果。

    总之，这个 `forward` 方法基于 `normalize_before` 标志来选择适当的前向传播方法，并将相同的输入参数传递给选定的方法。这是为了根据模型的配置决定前向传播的计算顺序，以灵活地适应不同的模型结构。

    七、_get_clones()

    1. def _get_clones(module, N):
    2.     return nn.ModuleList([copy.deepcopy(module) for i in range(N)])

    这个函数 _get_clones 接受两个参数：module 和 N。它的作用是创建一个包含 N 个克隆副本的 PyTorch 模块列表，并返回该列表。

    以下是每行代码的详细解释：

    1. nn.ModuleList([copy.deepcopy(module) for i in range(N)])：这一行代码首先创建一个空的 PyTorch 模块列表 nn.ModuleList([])。然后，它使用列表推导式 copy.deepcopy(module) for i in range(N) 来创建 N 个 module 的深度克隆副本，并将它们添加到模块列表中。

    简而言之，这个函数的目的是创建一个包含多个相同模块的列表，以便在模型中多次使用相同的模块，例如在 Transformer 模型中的多层编码器或解码器中。这样可以确保每个模块都有独立的权重和参数，但它们具有相同的结构。这对于构建深度神经网络模型非常有用。

    八、build_transformer ()

    1. def build_transformer(args):
    2.     return Transformer(
    3.         d_model=args.hidden_dim,
    4.         dropout=args.dropout,
    5.         nhead=args.nheads,
    6.         dim_feedforward=args.dim_feedforward,
    7.         num_encoder_layers=args.enc_layers,
    8.         num_decoder_layers=args.dec_layers,
    9.         normalize_before=args.pre_norm,
    10.         return_intermediate_dec=True,
    11.     )

    这个函数 build_transformer 用于构建一个 Transformer 模型，其配置参数由传入的 args 参数决定。

    这个函数返回一个 Transformer 模型，其中各参数的含义如下：

    • d_model: Transformer 模型的隐藏维度，通常是模型中重要的超参数之一。

    • dropout: 模型中的丢弃率，用于正则化，以防止过拟合。

    • nhead: 多头自注意力机制中的头数。

    • dim_feedforward: Feedforward 网络的中间维度。

    • num_encoder_layers: 编码器的层数。

    • num_decoder_layers: 解码器的层数。

    • normalize_before: 是否在每个子层之前进行层归一化。

    • return_intermediate_dec: 是否返回解码器中每一层的输出，通常用于一些多任务学习或其他任务中。

    这个函数的目的是创建一个 Transformer 模型，并使用传入的参数配置该模型的各个部分。

    九、_get_activation_fn()

    1. def _get_activation_fn(activation):
    2.     """Return an activation function given a string"""
    3.     if activation == "relu":
    4.         return F.relu
    5.     if activation == "gelu":
    6.         return F.gelu
    7.     if activation == "glu":
    8.         return F.glu
    9.     raise RuntimeError(F"activation should be relu/gelu, not {activation}.")

    _get_activation_fn 函数用于根据输入的字符串 activation 返回相应的激活函数。激活函数是神经网络中的一种非线性函数，用于引入非线性变换，以增加模型的表示能力。这个函数支持返回三种激活函数，具体如下：

    • 如果 activation 参数的值是 "relu"，则返回 ReLU（Rectified Linear Unit）激活函数，表示为 F.relu。

    • 如果 activation 参数的值是 "gelu"，则返回 GELU（Gaussian Error Linear Unit）激活函数，表示为 F.gelu。

    • 如果 activation 参数的值是 "glu"，则返回 GLU（Gated Linear Unit）激活函数，表示为 F.glu。

    如果 activation 参数的值不是上述三者之一，函数会引发一个 RuntimeError 异常，指示传入的激活函数不受支持。

    这个函数的目的是为了方便地根据字符串指定的激活函数名称获取相应的激活函数对象，以在神经网络的各个层中使用。这有助于使代码更具可读性和可维护性，因为开发者可以直观地指定所需的激活函数。

  • 相关阅读:
    应用层 DNS Linux 下解析域名命令 dig 命令使用详解
    复杂任务中，流程的解耦设计
    面试官：BIO、NIO、AIO是什么，他们有什么区别？
    在页面上用卡片展示数据
    ZC-CLS381RGB颜色识别+8x8点阵指示（完）
    ESP32-C3入门教程 基础篇⑥——SPI通信点亮LCD显示屏
    什么是单片机最小系统？
    zookeeper集群安装
    uni-app vuex全局计时
    Java反射机制（一）
  • 原文地址：https://blog.csdn.net/sinat_41942180/article/details/132909484