从DETR backbone 的NestedTensor 到DataLoader, Sampler,collate_fn，再到DETR transformer
1.背景：
在DETR中backbone中，resnet50 的构建继承了backbonebase的类，backbonebase的前向过程如下，这里引入了NestedTensor类。
# 前向中输入的是NestedTensor这个类的实例，实质就是将图像张量与对应的mask封装到一起。
def forward(self, tensor_list: NestedTensor):
xs = self.body(tensor_list.tensors)
out: Dict[str, NestedTensor] = {}
for name, x in xs.items():
m = tensor_list.mask
assert m is not None
# 将mask插值到与输出特征图一致
mask = F.interpolate(m[None].float(), size=x.shape[-2:]).to(torch.bool)[0]
out[name] = NestedTensor(x, mask)
return outNestedTensor，包括tensor和mask两个成员，tensor就是输入的图像。mask跟tensor同高宽但是单通道。
DETR把resnet作为backbone套到了另一个子网络里，这个子网络主要是把tensor list送进resnet网络，然后逐个提取出来其中的节点（也就是里面的Tensor），把每个节点的“mask”提出来做一次采样，然后再打包进自定义的“NestedTensor”中，按照“名称”：Tensor的方式存入输出的out。（这个NestedTensor一个Tensor里打包存了两个变量：x和mask）。
2. DETR网络下NestedTensor的前世今生示例：
2.1 输入
假如我们输入的是如下两张图片，也就说batch为2：
img1 = torch.rand(3, 200, 200),
img2 = torch.rand(3, 200, 250)
x = nested_tensor_from_tensor_list([torch.rand(3, 200, 200), torch.rand(3, 200, 250)])
这里会转成nested_tensor, 为什么要转为nested_tensor呢？
这个nestd_tensor的类型简单说就是把{tensor, mask}打包在一起, tensor就是我们的图片的值，那么mask是什么呢?
当一个batch中的图片大小不一样的时候，我们要把它们处理的整齐，简单说就是把图片都padding成最大的尺寸，padding的方式就是补零，那么batch中的每一张图都有一个mask矩阵，所以mask大小为[2, 200,250], 在img有值的地方是1，补零的地方是0，tensor大小为[2,3,200,250]是经过padding后的。
2.2 提取特征
DETR 提取特征，是把NestedTensor中的tensor, 也就是图片输入到特征提取器中。这里使用的是残差网络resnet-50，tensor经过backbone后的结果就是[2,2048,7,8],下面是残差网络最后一层的结构
(2): Bottleneck(
(conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
(bn1): FrozenBatchNorm2d()
(conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn2): FrozenBatchNorm2d()
(conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
(bn3): FrozenBatchNorm2d()
(relu): ReLU(inplace=True)
另外，关于NestedTensor中的mask, mask采用的方式F.interpolate，最后得到的结果是[2,7,8]，backboneBase的前向过程如下：
class BackboneBase(nn.Module):
def __init__(self, backbone: nn.Module, train_backbone: bool, num_channels: int, return_interm_layers: bool):
super().__init__()
for name, parameter in backbone.named_parameters():
if not train_backbone or 'layer2' not in name and 'layer3' not in name and 'layer4' not in name:
parameter.requires_grad_(False)
if return_interm_layers:
return_layers = {"layer1": "0", "layer2": "1", "layer3": "2", "layer4": "3"}
else:
return_layers = {'layer4': "0"}
self.body = IntermediateLayerGetter(backbone, return_layers=return_layers)
self.num_channels = num_channels
def forward(self, tensor_list: NestedTensor):
xs = self.body(tensor_list.tensors)
out: Dict[str, NestedTensor] = {}
for name, x in xs.items():
m = tensor_list.mask
assert m is not None
mask = F.interpolate(m[None].float(), size=x.shape[-2:]).to(torch.bool)[0]
out[name] = NestedTensor(x, mask)
return out
Featuremap的位置编码，position_embedding 的前向如下：
利用三角函数的方式获取position_embedding，输入是上面的NestedTensor={tensor,mask}, 输出最终pos的size为[1,2,256,7,8]
def forward(self, tensor_list: NestedTensor):
#tensor_list的类型是NestedTensor，内部自动附加了mask，用于表示动态shape，是pytorch中tensor新特性
x = tensor_list.tensors
mask = tensor_list.mask
assert mask is not None
not_mask = ~mask
#因为图像是2d的，所以位置编码也分为x,y方向
# 1 1 1 1 .. 2 2 2 2... 3 3 3...
y_embed = not_mask.cumsum(1, dtype=torch.float32)
# 1 2 3 4 ... 1 2 3 4...
x_embed = not_mask.cumsum(2, dtype=torch.float32)
if self.normalize:
eps = 1e-6
y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
#num_pos_feats = 128
## 0~127 self.num_pos_feats=128,因为前面输入向量是256，编码是一半sin，一半cos
dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
## 输出shape=b,h,w,128
pos_x = x_embed[:, :, :, None] / dim_t
pos_y = y_embed[:, :, :, None] / dim_t
pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3)
pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3)
pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
# 每个特征图的xy位置都编码成256的向量，其中前128是y方向编码，而128是x方向编码
return pos
## b,n=256,h,w
backbone+ position_embedding 中的NestedTensor流程如下：最终输出为
NestedTensor{tensor,mask},和pos。
tensor=[ 2, 2048,7,8]，mask=[2,7,8], pos=[1,2,256,7,8]
class Joiner(nn.Sequential):
def __init__(self, backbone, position_embedding):
super().__init__(backbone, position_embedding)
def forward(self, tensor_list: NestedTensor):
xs = self[0](tensor_list)
out: List[NestedTensor] = []
pos = []
for name, x in xs.items():
out.append(x)
# position encoding
pos.append(self[1](x).to(x.tensors.dtype))
return out, pos
以上是DETR中关于NestedTensor输入在resnet50 backbone以及position_embedding中的历程。
3.COCO格式数据集下的NestedTensor的来龙去脉（一）：
我们找到输入数据封装为NesteTensor类型的最初：
data_loader_train = DataLoader(dataset_train, batch_sampler=batch_sampler_train, collate_fn=utils.collate_fn, num_workers=args.num_workers)
data_loader_val = DataLoader(dataset_val, args.batch_size, sampler=sampler_val, drop_last=False, collate_fn=utils.collate_fn, num_workers=args.num_workers)在Dataloder中涉及两个重要的参数，Sample()和collate_fn()。
3.1 Dataloder：数据预处理DataLoader及各参数详解
pytorch关于数据处理的功能模块均在torch.utils.data 中，pytorch输入数据PipeLine一般遵循一个“三步走”的策略，操作顺序是这样的：
① 继承Dataset类，自定义数据处理类。必须重载实现len()、getitem()这两个方法。
其中__len__返回数据集样本的数量，而__getitem__应该编写支持数据集索引的函数，例如通过dataset[i]可以得到数据集中的第i+1个数据。在实现自定义类时，一般需要对图像数据做增强处理，和标签处理，__getitem__返回图像和对应label，图像增强的方法可以使用pytorch自带的torchvision.transforms内模块，也可以使用自定义或者其他第三方增强库。
② 导入 DataLoader类，传入参数(上面自定义类的对象) 创建一个DataLoader对象。
③ 循环遍历这个 DataLoader 对象。将img, label加载到模型中进行训练
dataset = MyDataset() # 第一步：构造Dataset对象
dataloader = DataLoader(dataset)# 第二步：通过DataLoader来构造迭代对象
num_epoches = 100
for epoch in range(num_epoches):# 第三步：逐步迭代数据
for img, label in dataloader:
# 训练代码pytorch内部默认的数据处理类有如下：
class Dataset(object):
class IterableDataset(Dataset):
class TensorDataset(Dataset): # 封装成tensor的数据集，每一个样本都通过索引张量来获得。
class ConcatDataset(Dataset): # 连接不同的数据集以构成更大的新数据集
class Subset(Dataset): # 获取指定一个索引序列对应的子数据集
class ChainDataset(IterableDataset):DataLoader类详解，数据加载器。组合了一个数据集和采样器，并提供关于数据的迭代。
class DataLoader(object):
Arguments:
dataset (Dataset): 是一个DataSet对象，表示需要加载的数据集.三步走第一步创建的对象
batch_size (int, optional): 每一个batch加载多少个样本，即指定batch_size，默认是 1
shuffle (bool, optional): 布尔值True或者是False ，表示每一个epoch之后是否对样本进行随机打乱，默认是False
------------------------------------------------------------------------------------
sampler (Sampler, optional): 自定义从数据集中抽取样本的策略，如果指定这个参数，那么shuffle必须为False
batch_sampler (Sampler, optional): 此参数很少使用，与sampler类似，但是一次只返回一个batch的indices（索引），需要注意的是，一旦指定了这个参数，那么batch_size,shuffle,sampler,drop_last就不能再制定了（互斥）
------------------------------------------------------------------------------------
num_workers (int, optional): 这个参数决定了有几个进程来处理data loading。0意味着所有的数据都会被load进主进程。（默认为0）
collate_fn (callable, optional): 将一个list的sample组成一个mini-batch的函数
pin_memory (bool, optional): 如果设置为True，那么data loader将会在返回它们之前，将tensors拷贝到CUDA中的固定内存（CUDA pinned memory）中.默认是False
------------------------------------------------------------------------------------
drop_last (bool, optional): 如果设置为True：这个是对最后的未完成的batch来说的，比如你的batch_size设置为64，而一个epoch只有100个样本，那么训练的时候后面的36个就被扔掉了，如果为False（默认），那么会继续正常执行，只是最后的batch_size会小一点。
------------------------------------------------------------------------------------
以上使用的是dataset, batch_size, shuffe, sampler, num_workers, collate_fn, pin_memory，这几个参数。
3.2 sampler参数
sampler参数其实就是一个“采样器”，表示从样本中究竟如何取样，pytorch采样器有如下几个
class Sampler(object):
class SequentialSampler(Sampler):# 顺序采样样本，始终按照同一个顺序。
class RandomSampler(Sampler): # 无放回地随机采样样本元素。
class SubsetRandomSampler(Sampler): # 无放回地按照给定的索引列表采样样本元素
class WeightedRandomSampler(Sampler): # 按照给定的概率来采样样本。
class BatchSampler(Sampler): # 在一个batch中封装一个其他的采样器。
# torch.utils.data.distributed.DistributedSampler
class DistributedSampler(Sampler): # 采样器可以约束数据加载进数据集的子集。
默认是采用的采样器如下：
if batch_sampler is None: # 没有手动传入batch_sampler参数时
if sampler is None: # 没有手动传入sampler参数时
if shuffle:
sampler = RandomSampler(dataset) # 随机采样
else:
sampler = SequentialSampler(dataset) # 顺序采样
batch_sampler = BatchSampler(sampler, batch_size, drop_last)
self.sampler = sampler
self.batch_sampler = batch_sampler
self.__initialized = True3.3 collate_fn 参数
当继承Dataset类自定义类时，__getitem__方法一般返回一组类似于（image，label）的一个样本，在创建DataLoader类的对象时，collate_fn函数会将batch_size个样本整理成一个batch样本，便于批量训练。
default_collate(batch)中的参数就是这里的 [self.dataset[i] for i in indices]，indices是从所有样本的索引中选取的batch_size个索引，表示本次批量获取这些样本进行训练。self.dataset[i]就是自定义Dataset子类中__getitem__返回的结果。
默认的函数default_collate(batch) 只能对大小相同image的batch_size个image整理，如[(img0, label0), (img1, label1),(img2, label2), ] 整理成([img0,img1,img2,], [label0,label1,label2,]), 这里要求多个img的size相同。
当我们的图像大小不同时，需要自定义函数callate_fn来将batch个图像整理成统一大小的，若读取的数据有(img, box, label)这种也需要自定义，因为默认只能处理(img,label)。当然你可以提前将数据集全部整理成统一大小的。
例：目标检测时的自定义collate_fn(),给每个图像添加索引
def collate_fn(self, batch):
paths, imgs, targets = list(zip(*batch))
# Remove empty placeholder targets
# 有可能__getitem__返回的图像是None, 所以需要过滤掉
targets = [boxes for boxes in targets if boxes is not None]
# Add sample index to targets
# boxes是每张图像上的目标框，但是每个图片上目标框数量不一样呢，所以需要给这些框添加上索引，对应到是哪个图像上的框。
for i, boxes in enumerate(targets):
boxes[:, 0] = i
targets = torch.cat(targets, 0)
# Selects new image size every tenth batch
if self.multiscale and self.batch_count % 10 == 0:
self.img_size = random.choice(range(self.min_size, self.max_size + 1, 32))
# Resize images to input shape
# 每个图像大小不同呢，所以resize到统一大小
imgs = torch.stack([resize(img, self.img_size) for img in imgs])
self.batch_count += 1
return paths, imgs, targets
其实也可结合使用默认的default_collate
from torch.utils.data.dataloader import default_collate # 导入这个函数
def collate_fn(batch):
"""
params:
batch :是一个列表，列表的长度是 batch_size
列表的每一个元素是 (x,y) 这样的元组tuple，元祖的两个元素分别是x,y
大致的格式如下 [(x1,y1),(x2,y2),(x3,y3)...(xn,yn)]
returns:
整理之后的新的batch
"""
# 这一部分是对 batch 进行重新 “校对、整理”的代码
return default_collate(batch) #返回校对之后的batch，一般就直接推荐使用default_collate
进行包装，因为它里面有很多功能，比如将numpy转化成tensor等操作，这是必须的。tip: 在使用pytorch时，当加载数据训练for i, batch in enumerate(train_loader):时，可能会出现TypeError: ‘NoneType’ object is not callable这个错误，若遇到更换pytorch版本即可.
4.COCO格式数据集下的NestedTensor的来龙去脉（二）：
collate_fn 方法来重新组装一个batch的数据：
它的作用是将一个batch的数据重新组装为自定义的形式，输入参数batch就是原始的一个batch数据，通常在Pytorch中的Dataloader中，会将一个batch的数据组装为((data1, label1), (data2, label2), ...)这样的形式，于是第一行代码的作用就是将其变为[(data1, data2, data3, ...),(label1, label2, label3,...)]这样的形式，然后取出batch[0]即一个batch的图像输入到nested_tensor _from_tensor_list()方法中进行处理，最后将返回结果替代原始的这一个batch图像数据。
def collate_fn(batch):
batch = list(zip(*batch))
batch[0] = nested_tensor_from_tensor_list(batch[0])
return tuple(batch)为了能够统一batch中所有图像的尺寸，以便形成一个batch，我们需要得到其中的最大尺度（在所有维度上），然后对尺度较小的图像进行填充（padding），同时设置mask以指示哪些部分是padding得来的，以便后续模型能够在有效区域内去学习目标，相当于加入了一部分先验知识。
nested_tensor_from_tensor_list(tensor_list: List[Tensor])实现如下：
def nested_tensor_from_tensor_list(tensor_list: List[Tensor]):
# TODO make this more general
#得到一个batch中所有图像张量每个维度的最大尺寸
if tensor_list[0].ndim == 3:
if torchvision._is_tracing():
# nested_tensor_from_tensor_list() does not export well to ONNX
# call _onnx_nested_tensor_from_tensor_list() instead
return _onnx_nested_tensor_from_tensor_list(tensor_list)
# TODO make it support different-sized images
max_size = _max_by_axis([list(img.shape) for img in tensor_list])
# min_size = tuple(min(s) for s in zip(*[img.shape for img in tensor_list]))
batch_shape = [len(tensor_list)] + max_size
b, c, h, w = batch_shape
dtype = tensor_list[0].dtype
device = tensor_list[0].device
tensor = torch.zeros(batch_shape, dtype=dtype, device=device)
#指示图像中哪些位置是padding部分
mask = torch.ones((b, h, w), dtype=torch.bool, device=device)
for img, pad_img, m in zip(tensor_list, tensor, mask):
pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
#原始图像中有效部分设为false，以区分padding
m[: img.shape[1], :img.shape[2]] = False
else:
raise ValueError('not supported')
return NestedTensor(tensor, mask)如何得到batch中每张图像在每个维度上的最大值。
def _max_by_axis(the_list):
# type: (List[List[int]]) -> List[int]
maxes = the_list[0]
for sublist in the_list[1:]:
for index, item in enumerate(sublist):
maxes[index] = max(maxes[index], item)
return maxes5. DETR网络结构一览：
The forward expects a NestedTensor, which consists of:
- samples.tensor: batched images, of shape [batch_size x 3 x H x W]
- samples.mask: a binary mask of shape [batch_size x H x W], containing 1 on padded pixels
class DETR(nn.Module):
""" This is the DETR module that performs object detection """
def __init__(self, backbone, transformer, num_classes, num_queries, aux_loss=False):
""" Initializes the model.
Parameters:
backbone: torch module of the backbone to be used. See backbone.py
transformer: torch module of the transformer architecture. See transformer.py
num_classes: number of object classes
num_queries: number of object queries, ie detection slot. This is the maximal number of objects
DETR can detect in a single image. For COCO, we recommend 100 queries.
aux_loss: True if auxiliary decoding losses (loss at each decoder layer) are to be used.
"""
super().__init__()
self.num_queries = num_queries
self.transformer = transformer
hidden_dim = transformer.d_model
self.class_embed = nn.Linear(hidden_dim, num_classes + 1)
self.bbox_embed = MLP(hidden_dim, hidden_dim, 4, 3)
self.query_embed = nn.Embedding(num_queries, hidden_dim)
self.input_proj = nn.Conv2d(backbone.num_channels, hidden_dim, kernel_size=1)
self.backbone = backbone
self.aux_loss = aux_loss
def forward(self, samples: NestedTensor):
""" The forward expects a NestedTensor, which consists of:
- samples.tensor: batched images, of shape [batch_size x 3 x H x W]
- samples.mask: a binary mask of shape [batch_size x H x W], containing 1 on padded pixels
It returns a dict with the following elements:
- "pred_logits": the classification logits (including no-object) for all queries.
Shape= [batch_size x num_queries x (num_classes + 1)]
- "pred_boxes": The normalized boxes coordinates for all queries, represented as
(center_x, center_y, height, width). These values are normalized in [0, 1],
relative to the size of each individual image (disregarding possible padding).
See PostProcess for information on how to retrieve the unnormalized bounding box.
- "aux_outputs": Optional, only returned when auxilary losses are activated. It is a list of
dictionnaries containing the two above keys for each decoder layer.
"""
if not isinstance(samples, NestedTensor):
samples = nested_tensor_from_tensor_list(samples)
features, pos = self.backbone(samples) # backbone是一个CNN用于特征提取
src, mask = features[-1].decompose() #??
assert mask is not None
hs = self.transformer(self.input_proj(src), mask, self.query_embed.weight, pos[-1])[0] # 这里是吧features的其中一部分信息作为src传进Transformer，input_proj是一个卷积层，用来收缩输入的维度，把维度控制到d_model的尺寸（model dimension）
outputs_class = self.class_embed(hs) # 为了把Transformer应用于目标检测问题上，作者引入了“类别嵌入网络”和“框嵌入网络”
outputs_coord = self.bbox_embed(hs).sigmoid() # 在框嵌入后加入一层sigmoid输出框坐标（原论文中提到是四点坐标，但是要考虑到原图片的尺寸）
out = {'pred_logits': outputs_class[-1], 'pred_boxes': outputs_coord[-1]}
if self.aux_loss:
out['aux_outputs'] = self._set_aux_loss(outputs_class, outputs_coord)
return out
@torch.jit.unused
def _set_aux_loss(self, outputs_class, outputs_coord):
# this is a workaround to make torchscript happy, as torchscript
# doesn't support dictionary with non-homogeneous values, such
# as a dict having both a Tensor and a list.
return [{'pred_logits': a, 'pred_boxes': b}
for a, b in zip(outputs_class[:-1], outputs_coord[:-1])]6.NestedTensor 在transformer中的摸爬滚打：
transformer encoder
接上第2节，输入NestdTensor 经backbone和positionembedding变为[tensor,mask,pos]后的故事：目前我们拥有src=[ 2, 2048,7,8]，mask=[2,7,8], pos=[1,2,256,7,8]
hs = transformer(self.input_proj(src), mask, self.query_embed.weight, pos[-1])[0]
# transformer 的输出是元组，分别为Decoder 和Encoder 的输出，因此这里取第一个代表的是Decoder的输出input_proj：一个卷积层，卷积核为1*1，将压缩通道的作用，将2048压缩到256，所以传入transformer的维度是压缩后的[2,256,7,8]。
self.input_proj = nn.Conv2d(num_channels, hidden_dim, kernel_size=1)
# input_proj是将CNN提取的特征维度映射到Transformer隐层的维度，src, mask = features[-1].decompose()
#取backbone最后一层featuremap， 然后将特征图映射为序列形式
看DETR的前向过程：
# 前向输入是一个NestedTensor类的对象
def forward(self, samples, postprocessors=None, targets=None, criterion=None):
# 首先将样本转换为NestedTensor 对象
if isinstance(samples, (list, torch.Tensor)):
samples = nested_tensor_from_tensor_list(samples)
#第一部分如下所示，先利用CNN提取特征，然后将特征图映射为序列形式，最后输入Transformer进行编、解码得到输出结果。
# *********************************************************************************
# 输入到cnn提取特征
features, pos = self.backbone(samples) #todo list
num = self.args.layer1_num
src, mask = features[num].decompose()
# 然后将特征图映射为序列形式
assert mask is not None
# transformer 的输出是元组，分别为Decoder 和Encoder 的输出，因此这里取第一个代表的是Decoder的输出[0]
hs = self.transformer(self.input_proj(src), mask, self.query_embed.weight, pos[num])[0]
# 将query_embedding 的权重作为参数输入到Transformer的前向过程，使用时与position encoding的方式相同，直接相加。
# 第二部分对输出的维度进行转化，与分类和回归任务所要求的相对应
# 生成分类与回归的预测结果
outputs_class = self.class_embed(hs)
outputs_coord = self.lines_embed(hs).sigmoid()
# 由于hs包含了Transformer中Decoder每层的输出，因此索引为-1 代表去最后一层的输出
out = {'pred_logits': outputs_class[-1], 'pred_lines': outputs_coord[-1]}
# 若指定要计算Decoder 每层预测输出对应的loss，则记录对应的输出结果
if self.aux_loss:
out['aux_outputs'] = self._set_aux_loss(outputs_class, outputs_coord)
return out接着看Transformer：
class Transformer(nn.Module):
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):
super().__init__()
# encode
# 单层
encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward,
dropout, activation, normalize_before)
encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
# 由6个单层组成整个encoder
self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
#decode
decoder_layer = TransformerDecoderLayer(d_model, nhead, dim_feedforward,
dropout, activation, normalize_before)
decoder_norm = nn.LayerNorm(d_model)
self.decoder = TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm,
return_intermediate=return_intermediate_dec)
在进行encoder之前先还有个处理：
bs, c, h, w = src.shape# 这个和我们上面说的一样[2,256,7,8]
src = src.flatten(2).permute(2, 0, 1) # src转为[56,2,256]
pos_embed = pos_embed.flatten(2).permute(2, 0, 1)# pos_embed 转为[56,2,256]
mask = mask.flatten(1) #mask 转为[2,56]
encoder的输入为：src, mask, pos_embed
q = k = self.with_pos_embed(src, pos)# pos + src
src2 = self.self_attn(q, k, value=src, key_padding_mask=mask)[0]
#做self_attention,这个不懂的需要补一下transfomer的知识
src = src + self.dropout1(src2)# 类似于残差网络的加法
src = self.norm1(src)# norm，这个不是batchnorm，很简单不在详述
src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))#两个ffn
src = src + self.dropout2(src2)# 同上残差加法
src = self.norm2(src)# norm
return src
单层的输出依然为src[56, 2, 256]，第二个单层的输入依然是：src, mask, pos_embed。循环往复6次结束encoder，得到输出memory, memory的size依然为[56, 2, 256].
Decoder的输入：
tgt = torch.zeros_like(query_embed)
hs = self.decoder(tgt, memory, memory_key_padding_mask=mask,
pos=pos_embed, query_pos=query_embed)
query_embed其实是一个varible，size=[100,2,256],由训练得到，结束后就固定下来了。
class TransformerDecoder(nn.Module):
def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
super().__init__()
self.layers = _get_clones(decoder_layer, num_layers)
self.num_layers = num_layers
self.norm = norm
self.return_intermediate = return_intermediate
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):
# tgt 是query embedding，shape是（num_queries,b,hidden_dim)
# query_pos 是对应tgt的位置编码，shanpe是和tgt一致
# memory是Encode的输出，shape是（h×w，b，hidden_dim)
# memory_key_padding_mask 对应encoder的src_key_padding_mask，也是EncoderLayer的key_padding_mask，shape是（b，h×w）
# pos对应输入到Encoder的位置编码，这里代表memory的位置编码，shape和memory一致。
output = tgt
intermediate = []
# intermediate = []中记录的是每一层输出后的归一化结果，而每一层的输入是前一层输出（没有归一化）的结果
for layer in self.layers:
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)
if self.return_intermediate:
intermediate.append(self.norm(output))
# self.norm 是通过初始化时传进来的参数norm（默认none）设置的，那么self.norm就有可能是none，故以下对此作了判断。
if self.norm is not None:
output = self.norm(output)
if self.return_intermediate:
intermediate.pop()
intermediate.append(output)
if self.return_intermediate:
return torch.stack(intermediate)
return output.unsqueeze(0)