devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Transformer | DETR目标检测中的位置编码position_encoding代码详解_positionembeddingsine

作者：知新_RL | 2024-04-06 10:53:18

赞

踩

positionembeddingsine

本文主要描述的是DETR论文中的position_encoding，详细DETR论文解析可参考

 论文篇 | 2020-Facebook-DETR ：利用Transformers端到端的目标检测=＞翻译及理解（持续更新中）_夏天｜여름이다的博客-CSDN博客_dert目标检测

Transformer不像RNN可以根据位置顺序接受和处理单词，所以为了得到词的位置信息，将位置信息添加到每个词的嵌入向量中，这称为位置编码。DETR中提供了两种编码方式，一种是正弦编码（PositionEmbeddingSine），一种是可以学习的编码(PositionEmbeddingLearned)，默认为正弦编码。

 如图，在用作输入的嵌入向量作为transformer的输入之前，将位置编码的值相加，将嵌入向量作为编码器的输入之前添加位置编码值的过程如下：

 Transformer使用以下俩个函数来创建一个带有位置信息的值：

 transformer把sine和cosine函数的值加入embedding向量，加上词序信息。embedding向量和位置编码的相加，是通过句子矩阵和位置编码矩阵的相加运算完成的，俩个矩阵是通过聚集embedding形成的向量。

 - pos: 表示嵌入向量在输入句子中的位置

- i ：是嵌入向量中维度的索引

- d model:是transformer的一个超参数，是所有层的输出维度。在上图中为4，在论文《Attention is all you need》中为512.

根据上面的表达式，如果嵌入向量中每个维度的索引为偶数，则使用正弦函数的值，如果索引为奇数则使用余弦函数。

位置编码可视化

  1. import numpy as np
  2. import matplotlib.pylab as plt
  3.  
  4.  
  5. def getPositionEncoding(seq_len, d, n=10000):
  6.     P = np.zeros(((seq_len, d)), dtype=float)
  7.     for k in range(seq_len):
  8.         for i in np.arange(int(d/2)):
  9.             denominator = np.power(n, 2*i/d)
  10.             P[k, 2*i] = np.sin((k/denominator))
  11.             P[k, 2*i+1] = np.cos(k/denominator)
  12.     return P
  13.  
  14. P = getPositionEncoding(seq_len=100, d=512, n=10000)
  15.  
  16.  
  17. print(P)
  18.  
  19.  
  20. cat = plt.matshow(P)
  21. plt.gcf().colorbar(cat)
  22. plt.show()

结果

1.正弦编码

取出mask，对mask进行取反，因为编码方式为二维编码，我们对行、和列分别进行累加，作为每一个维度的编码，并进行归一化，转化为角度。同时我们假设编码的每一维度都由一个128维的向量组成。然后，我们按照如下正弦编码方式进行编码,对奇数求余弦，偶数求正弦。编码后，x_emding,y_emding的维度均为batch*h*w*128 。

Transformer使用以下俩个函数来创建一个带有位置信息的值：

位置编码PE和词向量的维度需要保持一致，才能之后相加。其中pos是词的输入的位置，i是维度，

  1. import torch
  2.  
  3. # 1d绝对sin_cos编码
  4. def create_1d_absolute_sin_cos_embedding(pos_len, dim):
  5.     assert dim % 2 == 0, "wrong dimension!"
  6.     position_emb = torch.zeros(pos_len, dim, dtype=torch.float)
  7.     # i矩阵
  8.     i_matrix = torch.arange(dim//2, dtype=torch.float)
  9.     i_matrix /= dim / 2
  10.     i_matrix = torch.pow(10000, i_matrix)
  11.     i_matrix = 1 / i_matrix
  12.     i_matrix = i_matrix.to(torch.long)
  13.     # pos矩阵
  14.     pos_vec = torch.arange(pos_len).to(torch.long)
  15.     # 矩阵相乘，pos变成列向量，i_matrix变成行向量
  16.     out = pos_vec[:, None] @ i_matrix[None, :]
  17.     # 奇/偶数列
  18.     emb_cos = torch.cos(out)
  19.     emb_sin = torch.sin(out)
  20.     # 赋值
  21.     position_emb[:, 0::2] = emb_sin
  22.     position_emb[:, 1::2] = emb_cos
  23.     return position_emb
  24.  
  25.  
  26. if __name__ == '__main__':
  27.     print(create_1d_absolute_sin_cos_embedding(4, 4))

- torch.arange()：转为1维向量

- torch.pow() ：实现张量和标量之间逐元素求指数操作,或者在可广播的张量之间逐元素求指数操作.

- torch.long：将tensor投射为long类型

2.DETR目标检测中的position_encoding.py

DETR中的Positional Embedding是一个固定值，Positional Embedding的代码如下，针对二维特征图的特点，DETR实现了自己的二维位置编码方式。

  1. # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
  2. """
  3. Various positional encodings for the transformer.
  4. """
  5. import math
  6. import torch
  7. from torch import nn
  8.  
  9. from util.misc import NestedTensor
  10.  
  11.  
  12. class PositionEmbeddingSine(nn.Module):
  13.     """
  14.     This is a more standard version of the position embedding, very similar to the one
  15.     used by the Attention is all you need paper, generalized to work on images.
  16.     """
  17.     def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):
  18.         super().__init__()
  19.         self.num_pos_feats = num_pos_feats
  20.         self.temperature = temperature
  21.         self.normalize = normalize
  22.         if scale is not None and normalize is False:
  23.             raise ValueError("normalize should be True if scale is passed")
  24.         if scale is None:
  25.             scale = 2 * math.pi
  26.         self.scale = scale
  27.  
  28.     def forward(self, tensor_list: NestedTensor):
  29.         x = tensor_list.tensors
  30.         mask = tensor_list.mask
  31.         assert mask is not None
  32.         not_mask = ~mask
  33.         y_embed = not_mask.cumsum(1, dtype=torch.float32)
  34.         x_embed = not_mask.cumsum(2, dtype=torch.float32)
  35.         if self.normalize:
  36.             eps = 1e-6
  37.             y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
  38.             x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
  39.  
  40.         dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
  41.         dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
  42.  
  43.         pos_x = x_embed[:, :, :, None] / dim_t
  44.         pos_y = y_embed[:, :, :, None] / dim_t
  45.         pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3)
  46.         pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3)
  47.         pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
  48.         return pos
  49.  
  50.  
  51. class PositionEmbeddingLearned(nn.Module):
  52.     """
  53.     Absolute pos embedding, learned.
  54.     """
  55.     def __init__(self, num_pos_feats=256):
  56.         super().__init__()
  57.         self.row_embed = nn.Embedding(50, num_pos_feats)
  58.         self.col_embed = nn.Embedding(50, num_pos_feats)
  59.         self.reset_parameters()
  60.  
  61.     def reset_parameters(self):
  62.         nn.init.uniform_(self.row_embed.weight)
  63.         nn.init.uniform_(self.col_embed.weight)
  64.  
  65.     def forward(self, tensor_list: NestedTensor):
  66.         x = tensor_list.tensors
  67.         h, w = x.shape[-2:]
  68.         i = torch.arange(w, device=x.device)
  69.         j = torch.arange(h, device=x.device)
  70.         x_emb = self.col_embed(i)
  71.         y_emb = self.row_embed(j)
  72.         pos = torch.cat([
  73.             x_emb.unsqueeze(0).repeat(h, 1, 1),
  74.             y_emb.unsqueeze(1).repeat(1, w, 1),
  75.         ], dim=-1).permute(2, 0, 1).unsqueeze(0).repeat(x.shape[0], 1, 1, 1)
  76.         return pos
  77.  
  78.  
  79. def build_position_encoding(args):
  80.     N_steps = args.hidden_dim // 2
  81.     if args.position_embedding in ('v2', 'sine'):
  82.         # TODO find a better way of exposing other arguments
  83.         position_embedding = PositionEmbeddingSine(N_steps, normalize=True)
  84.     elif args.position_embedding in ('v3', 'learned'):
  85.         position_embedding = PositionEmbeddingLearned(N_steps)
  86.     else:
  87.         raise ValueError(f"not supported {args.position_embedding}")
  88.  
  89.     return position_embedding

 为了使得网络感知到不同输入的位置信息，最直观的方式就是给第一个Feature赋值1 ，第二个Feature赋值2 ，但是这种赋值方式对于较大的输入是不友好的，因此有人提出使用正弦函数将值控制在−1和1 之间，但是正弦函数又具备周期性，可能会造成不同位置值相同的情况。因此作者将正弦函数扩展到d维向量，不同通道具备不同的波长.如上文公式。

换句话来说，pos是词向量在序列中的位置，而 i 是channel的index。对照代码，可以看出DETR是为二维特征图的 x 和 y 方向各自计算了一个位置编码，每个维度的位置编码长度为num_pos_feats（该数值实际上为hidden_dim的一半），对x或y，计算奇数位置的正弦，计算偶数位置的余弦，然后将pos_x和pos_y拼接起来得到一个NHWD的数组，再经过permute(0,3,1,2)，形状变为NDHW，其中D等于hidden_dim。这个hidden_dim是Transformer输入向量的维度，在实现上，要等于CNN backbone输出的特征图的维度。所以pos code和CNN输出特征的形状是完全一样的。

 其中的细节代码

- math.pi:是 python 中 math 函数库里的一个内建函数,主要表示圆周率。

  1. #1：math.pi
  2. import math
  3. print(math.pi)
  4. scale = 2 * math.pi
  5. print(scale)

结果：

​

 - NestedTensor 嵌套张量

嵌套张量与常规张量非常相似，除了形状：

  • 对于正则张量，每个维度都有一个大小

  • 对于嵌套张量，并非所有维度都有规则大小；其中一些是锯齿状的

嵌套张量是表示各个域中顺序数据的自然解决方案：

  • 在 NLP 中，句子可以有可变长度，因此一批句子形成一个嵌套张量

  • 在 CV 中，图像可以具有可变的形状，因此一批图像形成一个嵌套张量

实例：嵌套张量在transformer中

  1. #Transformers中使用的多头注意力组件
  2. import math
  3. import torch
  4. import torch.nn.functional as F
  5.  
  6. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  7. #嵌套张量初始化
  8. nt = torch.nested_tensor([torch.randn((2, 6)), torch.randn((3, 6))], device=device)
  9. print(nt)
  10. #通过将每个底层张量填充为相同的形状，嵌套张量可以转换为常规张量。
  11. pt = torch.nested.to_padded_tensor(nt, padding=0.0)
  12. print(pt)
  13. """
  14. Args参数:
  15.     query: query of shape 形状的查询 (N, L_t, E_q)
  16.     key: key of shape key的形状 (N, L_s, E_k)
  17.     value: value of shape value的形状(N, L_s, E_v)
  18.     nheads: number of heads in multi-head attention多头注意力中的头数
  19.     W_q: Weight for query input projection of shape (E_total, E_q)形状的查询输入投影的权重 
  20.     W_k: Weight for key input projection of shape (E_total, E_k)形状的关键输入投影的权重
  21.     W_v: Weight for value input projection of shape (E_total, E_v)形状的价值输入投影的权重
  22.     W_out: Weight for output projection of shape (E_out, E_total)形状的输出投影的权重
  23.     b_q (optional): Bias for query input projection of shape E_total. Default: None    b_q（可选）。形状E_total的查询输入投影的偏置。默认值。无
  24.     b_k (optional): Bias for key input projection of shape E_total. Default: None       b_k (可选): 形状E_total的关键输入投影的偏置。默认值。无
  25.     b_v (optional): Bias for value input projection of shape E_total. Default: None     b_v (可选): 形状E_total的值输入投影的偏置。默认值。无
  26.     b_out (optional): Bias for output projection of shape E_out. Default: None         b_out（可选）。形状E_out的输出投影的偏置。默认值。无
  27.     dropout_p: dropout probability. Default: 0.0   dropout_p: dropout概率。默认值：0.0
  28.     where:
  29.         N is the batch size  N是批次大小
  30.         L_t is the target sequence length (jagged)   L_t是目标序列的长度(锯齿状)
  31.         L_s is the source sequence length (jagged)  L_s是源序列的长度(锯齿状)
  32.         E_q is the embedding size for query     E_q是查询的嵌入大小
  33.         E_k is the embedding size for key       E_k是键的嵌入大小
  34.         E_v is the embedding size for value     E_v是值的嵌入大小
  35.         E_total is the embedding size for all heads combined          E_total is the embedding size for all heads  
  36.         E_out is the output embedding size     E_out是输出嵌入的大小
  37. Returns返回:
  38.     attn_output: Output of shape (N, L_t, E_out)   attn_output: 形状的输出(N, L_t, E_out)
  39. """
  40. def mha_nested(query, key, value, nheads,
  41. W_q, W_k, W_v, W_out,
  42. b_q=None, b_k=None, b_v=None, b_out=None,
  43. dropout_p=0.0):
  44.     N = query.size(0)
  45.     E_total = W_q.size(0)
  46.     assert E_total % nheads == 0, "Embedding dim is not divisible by nheads"#嵌入的dim不能被nheads分割，必须是8的倍数
  47.     E_head = E_total // nheads
  48.  
  49.     # apply input projection
  50.     # (N, L_t, E_q) -> (N, L_t, E_total)
  51.     query = F.linear(query, W_q, b_q)
  52.     # (N, L_s, E_k) -> (N, L_s, E_total)
  53.     key = F.linear(key, W_k, b_k)
  54.     # (N, L_s, E_v) -> (N, L_s, E_total)
  55.     value = F.linear(value, W_v, b_v)
  56.  
  57.     # reshape query, key, value to separate by head
  58.     # (N, L_t, E_total) -> (N, L_t, nheads, E_head) -> (N, nheads, L_t, E_head)
  59.     query = query.reshape(-1, -1, nheads, E_head).transpose(1, 2)
  60.     # (N, L_s, E_total) -> (N, L_s, nheads, E_head) -> (N, nheads, L_s, E_head)
  61.     key = key.reshape(-1, -1, nheads, E_head).transpose(1, 2)
  62.     # (N, L_s, E_total) -> (N, L_s, nheads, E_head) -> (N, nheads, L_s, E_head)
  63.     value = value.reshape(-1, -1, nheads, E_head).transpose(1, 2)
  64.  
  65.     # query matmul key^T
  66.     # (N, nheads, L_t, E_head) x (N, nheads, L_s, E_head)^T -> (N, nheads, L_t, L_s)
  67.     keyT = key.transpose(-1, -2)
  68.     attn_weights = torch.matmul(query, keyT)
  69.  
  70.     # scale down
  71.     attn_weights = attn_weights * (1.0 / math.sqrt(E_head))
  72.  
  73.     # softmax
  74.     attn_weights = F.softmax(attn_weights, dim=-1)
  75.  
  76.     # dropout
  77.     if dropout_p > 0.0:
  78.         attn_weights = F.dropout(attn_weights, p=dropout_p)
  79.  
  80.     # attention_weights matmul value
  81.     # (N, nheads, L_t, L_s) x (N, nheads, L_s, E_head) -> (N, nheads, L_t, E_head)
  82.     attn_output = torch.matmul(attn_weights, value)
  83.  
  84.     # merge heads
  85.     # (N, nheads, L_t, E_head) -> (N, L_t, nheads, E_head) -> (N, L_t, E_total)
  86.     attn_output = attn_output.transpose(1, 2).reshape(N, -1, E_total)
  87.  
  88.     # apply output projection
  89.     # (N, L_t, E_total) -> (N, L_t, E_out)
  90.     attn_output = F.linear(attn_output, W_out, b_out)
  91.  
  92.     return attn_output

 - mask是一个位置掩码数组，对于一个没有经过zero_pad的图像，它的mask是一个全为0的数组。

参考文献

【1】2017-Attention Is All You Need-https://proceedings.neurips.cc/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf

【2】1) 트랜스포머(Transformer) - 딥 러닝을 이용한 자연어 처리 입문

【3】 理解DETR - 知乎

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号