其他
【综述专栏】3W字长文带你轻松入门视觉transformer
在科学研究中，从方法论上来讲，都应“先见森林，再见树木”。当前，人工智能学术研究方兴未艾，技术迅猛发展，可谓万木争荣，日新月异。对于AI从业者来说，在广袤的知识森林中，系统梳理脉络，才能更好地把握趋势。为此，我们精选国内外优秀的综述文章，开辟“综述专栏”，敬请关注。
地址：https://www.zhihu.com/people/huanghaian
01
02
2.1 早期seq2seq
不论输入和输出的语句长度是什么，中间的上下文向量长度都是固定的，一旦长度过长，仅仅靠一个固定长度的上下文向量明显不合理 仅仅利用上下文向量解码，会有信息瓶颈，长度过长时候信息可能会丢失
2.2 基于attention的seq2seq
假设世界上所有小吃都可以被标签化，例如微辣、特辣、变态辣、微甜、有嚼劲....，总共有1000个标签，现在我想要吃的小吃是[微辣、微甜、有嚼劲]，这三个单词就是我的Query 来到东门老街一共100家小吃店，每个店铺卖的东西不一样，但是肯定可以被标签化，例如第一家小吃被标签化后是[微辣、微咸],第二家小吃被标签化后是[特辣、微臭、特咸]，第三家小吃被标签化后是[特辣、微甜、特咸、有嚼劲]，其余店铺都可以被标签化，每个店铺的标签就是Keys,但是每家店铺由于卖的东西不一样，单品种类也不一样，所以被标签化后每一家的标签List不一样长 Values就是每家店铺对应的单品，例如第一家小吃的Values是[烤羊肉串、炒花生] 将Query和所有的Keys进行一一比对，相当于计算相似性，此时就可以知道我想买的小吃和每一家店铺的匹配情况，最后有了匹配列表，就可以去店铺里面买东西了(Values和相似性加权求和)。最终的情况可能是，我在第一家店铺买了烤羊肉串，然后在第10家店铺买了个玉米，最后在第15家店铺买了个烤面筋
# 假设q是(1,N,512),N就是最大标签化后的list长度，k是(1,M,512),M可以等于N，也可以不相等# (1,N,512) x (1,512,M)-->(1,N,M)attn = torch.matmul(q, k.transpose(2, 3))# softmax转化为概率，输出(1,N,M)，表示q中每个n和每个m的相关性attn=F.softmax(attn, dim=-1)# (1,N,M) x (1,M,512)-->(1,N,512)，V和k的shape相同output = torch.matmul(attn, v)注意力显著提高了机器翻译性能 注意力允许解码器以不同程度的权重利用到编码器的所有信息，可以绕过瓶颈 通过检查注意力分布，可以看到解码器在关注什么，可解释性强
2.3 基于transformer的seq2seq
不管是采用RNN、LSTM还是GRU都不利于并行训练和推理，因为相关算法只能从左向右依次计算或者从右向左依次计算 长依赖信息丢失问题，顺序计算过程中信息会丢失，虽然LSTM号称有缓解，但是无法彻底解决
2.4 transformer深入分析
2.4.1 编码器输入数据处理
网络自动学习 自己定义规则
self.pos_embedding = nn.Parameter(torch.randn(1, N, 512))将向量(N,512)采用如下函数进行处理
将向量的512维度切分为奇数行和偶数行 偶数行采用sin函数编码，奇数行采用cos函数编码 然后按照原始行号拼接
def get_position_angle_vec(position): # hid_j是0-511,d_hid是512，position表示单词位置0～N-1 return [position / np.power(10000, 2 * (hid_j // 2) / d_hid) for hid_j in range(d_hid)]
# 每个单词位置0～N-1都可以编码得到512长度的向量sinusoid_table = np.array([get_position_angle_vec(pos_i) for pos_i in range(n_position)])# 偶数列进行sinsinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2]) # dim 2i# 奇数列进行cossinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2]) # dim 2i+12.4.2 编码器前向过程
它扩展了模型专注于不同位置的能力。在上面的例子中，虽然每个编码都在z1中有或多或少的体现，但是它可能被实际的单词本身所支配。如果我们翻译一个句子，比如“The animal didn’t cross the street because it was too tired”，我们会想知道“it”指的是哪个词，这时模型的“多头”注意机制会起到作用。 它给出了注意力层的多个“表示子空间",对于“多头”注意机制，有多个查询/键/值权重矩阵集(Transformer使用8个注意力头，因此我们对于每个编码器/解码器有8个矩阵集合)。
class ScaledDotProductAttention(nn.Module): ''' Scaled Dot-Product Attention '''
def __init__(self, temperature, attn_dropout=0.1): super().__init__() self.temperature = temperature self.dropout = nn.Dropout(attn_dropout)
def forward(self, q, k, v, mask=None): # self.temperature是论文中的d_k ** 0.5，防止梯度过大 # QxK/sqrt(dk) attn = torch.matmul(q / self.temperature, k.transpose(2, 3))
if mask is not None: # 屏蔽不想要的输出 attn = attn.masked_fill(mask == 0, -1e9) # softmax+dropout attn = self.dropout(F.softmax(attn, dim=-1)) # 概率分布xV output = torch.matmul(attn, v)
return output, attnclass MultiHeadAttention(nn.Module): ''' Multi-Head Attention module '''
# n_head头的个数，默认是8 # d_model编码向量长度，例如本文说的512 # d_k, d_v的值一般会设置为 n_head * d_k=d_model， # 此时concat后正好和原始输入一样，当然不相同也可以，因为后面有fc层 # 相当于将可学习矩阵分成独立的n_head份 def __init__(self, n_head, d_model, d_k, d_v, dropout=0.1): super().__init__() # 假设n_head=8，d_k=64 self.n_head = n_head self.d_k = d_k self.d_v = d_v # d_model输入向量，n_head * d_k输出向量 # 可学习W^Q，W^K,W^V矩阵参数初始化 self.w_qs = nn.Linear(d_model, n_head * d_k, bias=False) self.w_ks = nn.Linear(d_model, n_head * d_k, bias=False) self.w_vs = nn.Linear(d_model, n_head * d_v, bias=False) # 最后的输出维度变换操作 self.fc = nn.Linear(n_head * d_v, d_model, bias=False) # 单头自注意力 self.attention = ScaledDotProductAttention(temperature=d_k ** 0.5) self.dropout = nn.Dropout(dropout) # 层归一化 self.layer_norm = nn.LayerNorm(d_model, eps=1e-6)
def forward(self, q, k, v, mask=None): # 假设qkv输入是(b,100,512),100是训练每个样本最大单词个数 # 一般qkv相等，即自注意力 residual = q # 将输入x和可学习矩阵相乘，得到(b,100,512)输出 # 其中512的含义其实是8x64，8个head，每个head的可学习矩阵为64维度 # q的输出是(b,100,8,64),kv也是一样 q = self.w_qs(q).view(sz_b, len_q, n_head, d_k) k = self.w_ks(k).view(sz_b, len_k, n_head, d_k) v = self.w_vs(v).view(sz_b, len_v, n_head, d_v)
# 变成(b,8,100,64)，方便后面计算，也就是8个头单独计算 q, k, v = q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)
if mask is not None: mask = mask.unsqueeze(1) # For head axis broadcasting. # 输出q是(b,8,100,64),维持不变,内部计算流程是： # q*k转置，除以d_k ** 0.5，输出维度是b,8,100,100即单词和单词直接的相似性 # 对最后一个维度进行softmax操作得到b,8,100,100 # 最后乘上V，得到b,8,100,64输出 q, attn = self.attention(q, k, v, mask=mask)
# b,100,8,64-->b,100,512 q = q.transpose(1, 2).contiguous().view(sz_b, len_q, -1) q = self.dropout(self.fc(q)) # 残差计算 q += residual # 层归一化，在512维度计算均值和方差，进行层归一化 q = self.layer_norm(q)
return q, attnclass PositionwiseFeedForward(nn.Module): ''' A two-feed-forward-layer module '''
def __init__(self, d_in, d_hid, dropout=0.1): super().__init__() # 两个fc层，对最后的512维度进行变换 self.w_1 = nn.Linear(d_in, d_hid) # position-wise self.w_2 = nn.Linear(d_hid, d_in) # position-wise self.layer_norm = nn.LayerNorm(d_in, eps=1e-6) self.dropout = nn.Dropout(dropout)
def forward(self, x): residual = x
x = self.w_2(F.relu(self.w_1(x))) x = self.dropout(x) x += residual
x = self.layer_norm(x)
return xclass EncoderLayer(nn.Module): def __init__(self, d_model, d_inner, n_head, d_k, d_v, dropout=0.1): super(EncoderLayer, self).__init__() self.slf_attn = MultiHeadAttention(n_head, d_model, d_k, d_v, dropout=dropout) self.pos_ffn = PositionwiseFeedForward(d_model, d_inner, dropout=dropout)
def forward(self, enc_input, slf_attn_mask=None): # Q K V是同一个，自注意力 # enc_input来自源单词嵌入向量或者前一个编码器输出 enc_output, enc_slf_attn = self.slf_attn( enc_input, enc_input, enc_input, mask=slf_attn_mask) enc_output = self.pos_ffn(enc_output) return enc_output, enc_slf_attnclass Encoder(nn.Module): def __init__( self, n_src_vocab, d_word_vec, n_layers, n_head, d_k, d_v, d_model, d_inner, pad_idx, dropout=0.1, n_position=200): # nlp领域的词嵌入向量生成过程(单词在词表里面的索引idx-->d_word_vec长度的向量) self.src_word_emb = nn.Embedding(n_src_vocab, d_word_vec, padding_idx=pad_idx) # 位置编码 self.position_enc = PositionalEncoding(d_word_vec, n_position=n_position) self.dropout = nn.Dropout(p=dropout) # n个编码器层 self.layer_stack = nn.ModuleList([ EncoderLayer(d_model, d_inner, n_head, d_k, d_v, dropout=dropout) for _ in range(n_layers)]) # 层归一化 self.layer_norm = nn.LayerNorm(d_model, eps=1e-6)
def forward(self, src_seq, src_mask, return_attns=False): # 对输入序列进行词嵌入，加上位置编码 enc_output = self.dropout(self.position_enc(self.src_word_emb(src_seq))) enc_output = self.layer_norm(enc_output) # 作为编码器层输入 for enc_layer in self.layer_stack: enc_output, _ = enc_layer(enc_output, slf_attn_mask=src_mask) return enc_output2.4.3 解码器输入数据处理
2.4.4 解码器前向过程
class ScaledDotProductAttention(nn.Module): ''' Scaled Dot-Product Attention '''
def __init__(self, temperature, attn_dropout=0.1): super().__init__() self.temperature = temperature self.dropout = nn.Dropout(attn_dropout)
def forward(self, q, k, v, mask=None): # 假设q是b,8,10,64(b是batch，8是head个数，10是样本最大单词长度， # 64是每个单词的编码向量) # attn输出维度是b,8,10,10 attn = torch.matmul(q / self.temperature, k.transpose(2, 3)) # 故mask维度也是b,8,10,10 # 忽略b,8，只关注10x10的矩阵，其是下三角矩阵，下三角位置全1，其余位置全0 if mask is not None: # 提前算出mask，将为0的地方变成极小值-1e9，把这些位置的值设置为忽略 # 目的是避免解码过程中利用到未来信息 attn = attn.masked_fill(mask == 0, -1e9) # softmax+dropout attn = self.dropout(F.softmax(attn, dim=-1)) output = torch.matmul(attn, v)
return output, attnclass DecoderLayer(nn.Module): ''' Compose with three layers '''
def __init__(self, d_model, d_inner, n_head, d_k, d_v, dropout=0.1): super(DecoderLayer, self).__init__() self.slf_attn = MultiHeadAttention(n_head, d_model, d_k, d_v, dropout=dropout) self.enc_attn = MultiHeadAttention(n_head, d_model, d_k, d_v, dropout=dropout) self.pos_ffn = PositionwiseFeedForward(d_model, d_inner, dropout=dropout)
def forward( self, dec_input, enc_output, slf_attn_mask=None, dec_enc_attn_mask=None): # 标准的自注意力，QKV=dec_input来自目标单词嵌入或者前一个解码器输出 dec_output, dec_slf_attn = self.slf_attn( dec_input, dec_input, dec_input, mask=slf_attn_mask) # KV来自最后一个编码层输出enc_output，Q来自带有mask的self.slf_attn输出 dec_output, dec_enc_attn = self.enc_attn( dec_output, enc_output, enc_output, mask=dec_enc_attn_mask) dec_output = self.pos_ffn(dec_output) return dec_output, dec_slf_attn, dec_enc_attnclass Decoder(nn.Module): def __init__( self, n_trg_vocab, d_word_vec, n_layers, n_head, d_k, d_v, d_model, d_inner, pad_idx, n_position=200, dropout=0.1): # 目标单词嵌入 self.trg_word_emb = nn.Embedding(n_trg_vocab, d_word_vec, padding_idx=pad_idx) # 位置嵌入向量 self.position_enc = PositionalEncoding(d_word_vec, n_position=n_position) self.dropout = nn.Dropout(p=dropout) # n个解码器 self.layer_stack = nn.ModuleList([ DecoderLayer(d_model, d_inner, n_head, d_k, d_v, dropout=dropout) for _ in range(n_layers)]) # 层归一化 self.layer_norm = nn.LayerNorm(d_model, eps=1e-6)
def forward(self, trg_seq, trg_mask, enc_output, src_mask, return_attns=False): # 目标单词嵌入+位置编码 dec_output = self.dropout(self.position_enc(self.trg_word_emb(trg_seq))) dec_output = self.layer_norm(dec_output) # 遍历每个解码器 for dec_layer in self.layer_stack: # 需要输入3个信息：目标单词嵌入+位置编码、最后一个编码器输出enc_output # 和dec_enc_attn_mask，解码时候不能看到未来单词信息 dec_output, dec_slf_attn, dec_enc_attn = dec_layer( dec_output, enc_output, slf_attn_mask=trg_mask, dec_enc_attn_mask=src_mask) return dec_output2.4.5 分类层
self.trg_word_prj = nn.Linear(d_model, n_trg_vocab, bias=False)dec_output, *_ = self.model.decoder(trg_seq, trg_mask, enc_output, src_mask)return F.softmax(self.model.trg_word_prj(dec_output), dim=-1)2.4.6 前向流程
将源单词进行嵌入，组成矩阵(加上位置编码矩阵)输入到n个编码器中，输出编码向量KV 第一个解码器先输入一个BOS_WORD单词嵌入向量，后续解码器接受该解码器输出，结合KV进行第一次解码 将第一次解码单词进行嵌入，联合BOS_WORD单词嵌入向量构成矩阵再次输入到解码器中进行第二次解码，得到解码单词 不断循环，每次的第一个解码器输入都不同，其包含了前面时间步长解码出的所有单词 直到输出EOS_WORD表示解码结束或者强制设置最大时间步长即可
03
3.1 分类vision transformer
3.1.1 图片分块和降维
x = rearrange(img, 'b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1=p, p2=p)这个写法是采用了爱因斯坦表达式，具体是采用了einops库实现，内部集成了各种算子，rearrange就是其中一个，非常高效。不懂这种语法的请自行百度。p就是patch大小，假设输入是b,3,256,256，则rearrange操作是先变成(b,3,8x32,8x32)，最后变成(b,8x8,32x32x3)即(b,64,3072)，将每张图片切分成64个小块，每个小块长度是32x32x3=3072，也就是说输入长度为64的图像序列，每个元素采用3072长度进行编码。
# 将3072变成dim，假设是1024self.patch_to_embedding = nn.Linear(patch_dim, dim)x = self.patch_to_embedding(x)# dim=1024self.cls_token = nn.Parameter(torch.randn(1, 1, dim))# 变成(b,64,1024)cls_tokens = repeat(self.cls_token, '() n d -> b n d', b=b)# 额外追加token，变成b,65,1024x = torch.cat((cls_tokens, x), dim=1)3.1.2 位置编码
# num_patches=64，dim=1024,+1是因为多了一个cls开启解码标志self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))x += self.pos_embedding[:, :(n + 1)]x = self.dropout(x)3.1.3 编码器前向过程
self.transformer = Transformer(dim, depth, heads, mlp_dim, dropout)3.1.4 分类head
self.mlp_head = nn.Sequential( nn.LayerNorm(dim), nn.Linear(dim, mlp_dim), nn.GELU(), nn.Dropout(dropout), nn.Linear(mlp_dim, num_classes) )
# 65个输出里面只需要第0个输出进行后续分类即可self.mlp_head(x[:, 0])class ViT(nn.Module): def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, channels=3, dropout=0.,emb_dropout=0.): super().__init__() # image_size输入图片大小 256 # patch_size 每个patch的大小 32 num_patches = (image_size // patch_size) ** 2 # 一共有多少个patch 8x8=64 patch_dim = channels * patch_size ** 2 # 3x32x32=3072 self.patch_size = patch_size # 32 # 1,64+1,1024,+1是因为token，可学习变量，不是固定编码 self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim)) # 图片维度太大了，需要先降维 self.patch_to_embedding = nn.Linear(patch_dim, dim) # 分类输出位置标志，否则分类输出不知道应该取哪个位置 self.cls_token = nn.Parameter(torch.randn(1, 1, dim)) self.dropout = nn.Dropout(emb_dropout) # 编码器 self.transformer = Transformer(dim, depth, heads, mlp_dim, dropout) # 输出头 self.mlp_head = nn.Sequential( nn.LayerNorm(dim), nn.Linear(dim, mlp_dim), nn.GELU(), nn.Dropout(dropout), nn.Linear(mlp_dim, num_classes) )
def forward(self, img, mask=None): p = self.patch_size
# 先把图片变成64个patch,输出shape=b,64,3072 x = rearrange(img, 'b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1=p, p2=p) # 输出 b,64,1024 x = self.patch_to_embedding(x) b, n, _ = x.shape # 输出 b,1,1024 cls_tokens = repeat(self.cls_token, '() n d -> b n d', b=b) # 额外追加token，变成b,65,1024 x = torch.cat((cls_tokens, x), dim=1) # 加上位置编码1,64+1,1024 x += self.pos_embedding[:, :(n + 1)] x = self.dropout(x)
x = self.transformer(x, mask) # 分类head,只需要x[0]即可 # x = self.to_cls_token(x[:, 0]) x = x[:, 0] return self.mlp_head(x)3.1.5 实验分析
3.2 目标检测detr
3.2.1 detr核心思想分析
无序集合输出的loss计算 针对目标检测的transformer改进
3.2.2 detr算法实现细节
3.2.2.1 无序集合输出的loss计算
# detr分类输出，num_queries=100，shape是(b,100,92)bs, num_queries = outputs["pred_logits"].shape[:2]# 得到概率输出(bx100,92)out_prob = outputs["pred_logits"].flatten(0, 1).softmax(-1) # 得到bbox分支输出(bx100,4)out_bbox = outputs["pred_boxes"].flatten(0, 1)
# 准备分类target shape=(m,)里面存储的是类别索引，m包括了整个batch内部的所有gt bboxtgt_ids = torch.cat([v["labels"] for v in targets]) # 准备bbox target shape=(m,4)，已经归一化了tgt_bbox = torch.cat([v["boxes"] for v in targets])
#核心#bx100,92->bx100,m，对于每个预测结果，把目前gt里面有的所有类别值提取出来，其余值不需要参与匹配#对应上述公式，类似于nll loss，但是更加简单cost_class = -out_prob[:, tgt_ids] #计算out_bbox和tgt_bbox两两之间的l1距离 bx100,mcost_bbox = torch.cdist(out_bbox, tgt_bbox, p=1)#额外多计算一个giou loss bx100,mcost_giou = -generalized_box_iou(box_cxcywh_to_xyxy(out_bbox), box_cxcywh_to_xyxy(tgt_bbox))
#得到最终的广义距离bx100,m，距离越小越可能是最优匹配C = self.cost_bbox * cost_bbox + self.cost_class * cost_class + self.cost_giou * cost_giou# bx100,m--> batch,100,mC = C.view(bs, num_queries, -1).cpu()
#计算每个batch内部有多少物体，后续计算时候按照单张图片进行匹配，没必要batch级别匹配,徒增计算sizes = [len(v["boxes"]) for v in targets]#匈牙利最优匹配，返回匹配索引indices = [linear_sum_assignment(c[i]) for i, c in enumerate(C.split(sizes, -1))]
return [(torch.as_tensor(i, dtype=torch.int64), torch.as_tensor(j, dtype=torch.int64)) for i, j in indices]def loss_labels(self, outputs, targets, indices, num_boxes, log=True): #shape是(b,100,92) src_logits = outputs['pred_logits'] #得到匹配后索引，作用在label上 idx = self._get_src_permutation_idx(indices) #得到匹配后的分类target target_classes_o = torch.cat([t["labels"][J] for t, (_, J) in zip(targets, indices)]) #加入背景(self.num_classes)，补齐bx100个 target_classes = torch.full(src_logits.shape[:2], self.num_classes, dtype=torch.int64, device=src_logits.device) #shape是(b,100,),存储的是索引，不是one-hot target_classes[idx] = target_classes_o #计算ce loss,self.empty_weight前景和背景权重是1和0.1,克服类别不平衡 loss_ce = F.cross_entropy(src_logits.transpose(1, 2), target_classes, self.empty_weight) losses = {'loss_ce': loss_ce} return lossesdef loss_boxes(self, outputs, targets, indices, num_boxes): idx = self._get_src_permutation_idx(indices) src_boxes = outputs['pred_boxes'][idx] target_boxes = torch.cat([t['boxes'][i] for t, (_, i) in zip(targets, indices)], dim=0) #l1 loss loss_bbox = F.l1_loss(src_boxes, target_boxes, reduction='none')
losses = {} losses['loss_bbox'] = loss_bbox.sum() / num_boxes #giou loss loss_giou = 1 - torch.diag(box_ops.generalized_box_iou( box_ops.box_cxcywh_to_xyxy(src_boxes), box_ops.box_cxcywh_to_xyxy(target_boxes))) losses['loss_giou'] = loss_giou.sum() / num_boxes return losses3.2.2.2 针对目标检测的transformer改进
resnet中所有BN都固定，即采用全局均值和方差 resnet的stem和第一个stage不进行参数更新，即parameter.requires_grad_(False) backbone的学习率小于transformer,lr_backbone=1e-05,其余为0.0001
self.input_proj = nn.Conv2d(backbone.num_channels, hidden_dim, kernel_size=1)# 输出是(b,256,h//32,w//32)src=self.input_proj(src)# 变成序列模式，(h'xw',b,256),256是每个词的编码长度src = src.flatten(2).permute(2, 0, 1)#输入是b,c,h,w#tensor_list的类型是NestedTensor，内部自动附加了mask，#用于表示动态shape，是pytorch中tensor新特性https://github.com/pytorch/nestedtensorx = tensor_list.tensors # 原始tensor数据# 附加的mask，shape是b,h,w 全是falsemask = tensor_list.mask 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
# 0~127 self.num_pos_feats=128,因为前面输入向量是256，编码是一半sin，一半cosdim_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)
pos_x = x_embed[:, :, :, None] / dim_tpos_y = y_embed[:, :, :, None] / dim_t# 输出shape=b,h,w,128pos_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输入编码器的位置编码需要考虑2d空间位置 位置编码向量需要加入到每个编码器中 在编码器内部位置编码仅仅和QK相加，V不做任何处理
class TransformerEncoder(nn.Module): def __init__(self, encoder_layer, num_layers, norm=None): super().__init__() # 编码器copy6份 self.layers = _get_clones(encoder_layer, num_layers) self.num_layers = num_layers self.norm = norm
def forward(self, src, mask: Optional[Tensor] = None, src_key_padding_mask: Optional[Tensor] = None, pos: Optional[Tensor] = None): # 内部包括6个编码器，顺序运行 # src是图像特征输入，shape=hxw,b,256 output = src for layer in self.layers: # 每个编码器都需要加入pos位置编码 # 第一个编码器输入来自图像特征，后面的编码器输入来自前一个编码器输出 output = layer(output, src_mask=mask, src_key_padding_mask=src_key_padding_mask, pos=pos) return outputdef forward_post(self, src, src_mask: Optional[Tensor] = None, src_key_padding_mask: Optional[Tensor] = None, pos: Optional[Tensor] = None): # 和标准做法有点不一样，src加上位置编码得到q和k，但是v依然还是src， # 也就是v和qk不一样 q = k = src+pos src2 = self.self_attn(q, k, value=src, attn_mask=src_mask, key_padding_mask=src_key_padding_mask)[0] src = src + self.dropout1(src2) src = self.norm1(src) src2 = self.linear2(self.dropout(self.activation(self.linear1(src)))) src = src + self.dropout2(src2) src = self.norm2(src) return src# num_queries=100,hidden_dim=256self.query_embed = nn.Embedding(num_queries, hidden_dim)额外引入可学习的Object queries，相当于可学习anchor，提供全局注意力 编码器采用的sincos位置编码向量也需要输入解码器中，并且每个解码器都输入 QKV处理逻辑不同 不需要顺序解码，一次即可输出N个无序集合
class TransformerDecoder(nn.Module): 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): # 首先query_pos是query_embed，可学习输出位置向量shape=100,b,256 # tgt = torch.zeros_like(query_embed),用于进行一次性解码输出 output = tgt # 存储每个解码器输出，后面中继监督需要 intermediate = [] # 编码每个解码器 for layer in self.layers: # 每个解码器都需要输入query_pos和pos # memory是最后一个编码器输出 # 每个解码器都接受output作为输入，然后输出新的output 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)) if self.return_intermediate: return torch.stack(intermediate) # 6个输出都返回 return output.unsqueeze(0)def forward_post(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): # query_pos首先是可学习的，其作用主要是在学习过程中提供目标对象和全局图像之间的关系 # 这个相当于全局注意力输入，是非常关键的 # query_pos是解码器特有 q = k = tgt+query_pos # 第一个自注意力模块 tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask)[0] tgt = tgt + self.dropout1(tgt2) tgt = self.norm1(tgt) # memory是最后一个编码器输出，pos是和编码器输入中完全相同的sincos位置嵌入向量 # 输入参数是最核心细节，query是tgt+query_pos，而key是memory+pos # v直接用memory tgt2 = self.multihead_attn(query=tgt+query_pos, key=memory+pos, value=memory, attn_mask=memory_mask, key_padding_mask=memory_key_padding_mask)[0] tgt = tgt + self.dropout2(tgt2) tgt = self.norm2(tgt) tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt)))) tgt = tgt + self.dropout3(tgt2) tgt = self.norm3(tgt) return tgtself.class_embed = nn.Linear(256, 92)self.bbox_embed = MLP(256, 256, 4, 3)
# hs是(6,b,100,256)，outputs_class输出(6,b,100,92)，表示6个分类分支outputs_class = self.class_embed(hs)# 输出(6,b,100,4)，表示6个bbox坐标回归分支outputs_coord = self.bbox_embed(hs).sigmoid() # 取最后一个解码器输出即可，分类输出(b,100,92)，bbox回归输出(b,100,4)out = {'pred_logits': outputs_class[-1], 'pred_boxes': outputs_coord[-1]}if self.aux_loss: # 除了最后一个输出外，其余编码器输出都算辅助loss out['aux_outputs'] = self._set_aux_loss(outputs_class, outputs_coord)将(b,3,800,1200)图片输入到resnet50中进行特征提取,输出shape=(b,1024,25,38) 通过1x1卷积降维，变成(b,256,25,38) 利用sincos函数计算位置编码 将图像特征和位置编码向量相加，作为编码器输入，输出编码后的向量，shape不变 初始化全0的(100,b,256)的输出嵌入向量，结合位置编码向量和query_embed，进行解码输出，解码器输出shape为(6,b,100,256)，后面的解码器接受该输出，然后再次结合置编码向量和query_embed进行输出，不断前向 将最后一个解码器输出输入到分类和回归head中，得到100个无序集合 对100个无序集合进行后处理，主要是提取前景类别和对应的bbox坐标，乘上(800,1200)即可得到最终坐标,后处理代码如下：
prob = F.softmax(out_logits, -1)scores, labels = prob[..., :-1].max(-1)# convert to [x0, y0, x1, y1] formatboxes = box_ops.box_cxcywh_to_xyxy(out_bbox)# and from relative [0, 1] to absolute [0, height] coordinatesimg_h, img_w = target_sizes.unbind(1)scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1)boxes = boxes * scale_fct[:, None, :]results = [{'scores': s, 'labels': l, 'boxes': b} for s, l, b in zip(scores, labels, boxes)]3.2.3 实验分析
probas = outputs['pred_logits'].softmax(-1)[0, :, :-1]# 只保留概率大于0.9的bboxkeep = probas.max(-1).values > 0.9# 还原到原图，然后绘制即可bboxes_scaled = rescale_bboxes(outputs['pred_boxes'][0, keep], im.size)plot_results(im, probas[keep], bboxes_scaled)# multihead_attn注册前向hook，output[1]指的就是softmax后输出model.transformer.decoder.layers[-1].multihead_attn.register_forward_hook( lambda self, input, output: dec_attn_weights.append(output[1]))# 假设输入是(1,3,800,1066)outputs = model(img)# 那么dec_attn_weights是(1,100,850=800//32x1066//32)# 这个就是QK相似性计算后然后softmax后的输出，即注意力权重dec_attn_weights = dec_attn_weights[0]
# 如果想看哪个bbox的权重，则输入idx即可dec_attn_weights[0, idx].view(800//32, 1066//32)model.transformer.encoder.layers[-1].self_attn.register_forward_hook( lambda self, input, output: enc_attn_weights.append(output[1]))outputs = model(img)# 最后一个编码器中的自注意力模块权重输出(b,h//32xw//32,h//32xw//32)，其实就是qk计算然后softmax后的值即(1,25x34=850,850)enc_attn_weights = enc_attn_weights[0]
# 变成(25, 34, 25, 34)sattn = enc_attn_weights[0].reshape(shape + shape)
# 想看哪个特征点位置的注意力idxs = [(200, 200), (280, 400), (200, 600), (440, 800), ]
for idx_o, ax in zip(idxs, axs): # 转化到特征图尺度 idx = (idx_o[0] // fact, idx_o[1] // fact) # 直接sattn[..., idx[0], idx[1]]即可 ax.imshow(sattn[..., idx[0], idx[1]], cmap='cividis', interpolation='nearest')3.2.4 小结
04
05
1. http://jalammar.github.io/illustrated-transformer/
2. https://zhuanlan.zhihu.com/p/54356280
3. https://zhuanlan.zhihu.com/p/44731789
4. https://looperxx.github.io/CS224n-2019-08-Machine Translation, Sequence-to-sequence and Attention/
5. https://github.com/lucidrains/vit-pytorch
6. https://github.com/jadore801120/attention-is-all-you-need-pytorch
7. https://github.com/facebookresearch/detr
本文目的在于学术交流，并不代表本公众号赞同其观点或对其内容真实性负责，版权归原作者所有，如有侵权请告知删除。
“综述专栏”历史文章
类脑运算：脉冲神经网络（Spiking Neural Network）叙述
对抗训练——终极数据增强？
浅谈微信AI在通用图像搜索领域的探索
贝叶斯神经网络BNN(推导+代码实现)
2020 Pose Estimation人体骨骼关键点检测综述笔记
多目标跟踪（MOT）入门
Anchor-free应用一览：目标检测、实例分割、多目标跟踪
语音转换Voice Conversion：特征分离技术
Domain Adaptation基础概念与相关文章解读
一日看尽长安花——NLP可解释研究梳理
损失函数理解汇总，结合PyTorch和TensorFlow2
点云距离度量：完全解析EMD距离(Earth Mover's Distance)
One Shot NAS总结
图神经网络与深度学习在智能交通中的应用：综述Survey
异质图神经网络学习笔记
更多综述专栏文章，
请点击文章底部“阅读原文”查看
分享、点赞、在看，给个三连击呗！