Vision Transformer原理及模型学习笔记
Vision Transformer是一种加入了self-attention的Sequence to Sequence model。它包括特征提取和分类两部分。
在特征提取部分，VIT所作的工作就是特征提取。特征提取部分在图片中的对应区域是Patch+Position Embedding和Transformer Encoder。
Patch+Position Embedding就是对输入进来的图片进行分块处理，每隔一定区域大小划分图片块，然后将划分后的图片块组合成序列。在获得序列信息之后，传入Transformer Encoder进行特征提取，这是Transformer特有的Mult-head Self-attention结构，通过自注意力机制，关注每个图片块的重要程度。
在分类部分，VIT所做的工作就是将提取到的特征进行分类。在进行特征提取的时候，我们会在图片序列中添加上classtoken，classtoken会作为一个单位的序列信息一起进行特征提取，在提取的过程中，classtoken会与其他的特征进行特征交互，融合其他图片序列的特征。最终，我们利用Mult-head Self-attention结构提取特征后的classtoken进行全连接分类。
Vision Transformer源码链接：VIT源码
vit的结构
Vision Transformer的结构如下图所示。
数据处理
输入的图片尺寸为![[H,W,C]](http://img.e-com-net.com/image/info8/824dbe2e38664aa09d91c0b22445e673.gif){kind=small}
，patch size为
，则分块的数目为
，然后将每一个图片块展开成一维向量，每个向量大小为
设输入图片尺寸为（480,480,3），patch size为16，分块的数目为(480x480)/(16x16)=900块。每个图片块展开成一维向量，向量大小为16x16x3=768。
序列化后就获得了一个（900，768）的特征层。再加上classtoken后就是一个（901，768）的特征层。再给所有特征加上位置信息，这样网络才有区分不同区域的能力。此时生成的pos_Embedding的shape也为（901，768），代表每一个特征的位置信息。添加位置信息的方式就是生成一个（901，768）的参数矩阵，这个参数矩阵是可训练的，再把这个参数矩阵加上（901，768）的特征层就可以了。
图中0*就是casstoken。
self.pos_embed = nn.Parameter(torch.zeros(1, num_patches, num_features))在上一步获得shape为（901，768）的序列信息后，将序列信息传入Transform Encoder进行特征提取，这是Transformer特有的Mult-head self-attention结果。通过自注意力机制，关注每个图片块的重要程度。
处理sequence最常用的就是RNN，它的输入是一串vector sequence，输出是另一串vector sequence。如果是singe directional的RNN，输出
时，默认
，
，
，
都已经看过了。如果是bi-directional的RNN，输出
时，默认，，，都已经看过了。但RNN有一个问题：不能并行化（hard to parallel）。例如在singe directional的RNN中要 算出，就必须 先看，再看，再看，再看，这个过程很难并行。
而self-attention，它的输入、输出和RNN一样，都是输入一串sequence，输出另外一串sequence，它和bi-directional一样，
- 每一个输出都看过了整个的输入sequence。但self-attention与RNN不同的是：它的 - 每一个输出都可以并行化计算。
self-attention
如上图所示，设input是
-
，这是一个sequence，-分别与一个矩阵
相乘得到embedding，即
-
，接着这个embedding进入self-attention层，每个-分别乘上三个不同的transformer 矩阵
、
、
，例如得到
、
、
接着将每个query 
都对每个key 
做attention，attention就是匹配这2个向量有多接近。比如要对、做attention，就是对这2个向量做scaled inner product，得到
，再用、
做attention，得到
；用
、
做attention，得到
；用、
做attention，得到
。
做scaled inner product的方法
其中d是q、k的维度，
的值会随着维度的增大而增大，所以要除以
，相当于一个归一化。
接下来就是对计算得到的所有
做softmax操作，得到 
。
接着将与
相乘，即
与相乘，
与
相乘，
与
相乘，
与
相乘，再把结果相加得到。在产生的整个过程中使用了整个sequence的资讯。如果要考虑局部的information，只需要学习相应的
，就不带有那个分支的信息了。如果要考虑全局的information，只需要学习相应的
，就带有所有分支的信息了。
同样的方法可以求出
、
、。
以上一连串的计算，self-attention layer做的事情和RNN是一样的，但是它可以并行化计算。
首先输入的embedding是![I=[a^{1},a^{2},a^{3},a^{4}]](http://img.e-com-net.com/image/info8/f2adadaeb64142b58c895f7fbe24764a.gif){kind=small}
，用
乘得到![Q=[q^{1},q^{2},q^{3},q^{4}]](http://img.e-com-net.com/image/info8/c04a4d42e4ef4341ad5faf7085a035b1.gif){kind=small}
，它的每一列代表一个向量。用乘
得到![K=[k^{1},k^{2},k^{3},k^{4}]](http://img.e-com-net.com/image/info8/70cbdc5410d04b79a0176f0613ebda1c.gif){kind=small}
，它的每一列代表一个向量。用乘得到![V=[v^{1},v^{2},v^{3},v^{4}]](http://img.e-com-net.com/image/info8/72edd2b5e7e9402b84571fac14042c2a.gif){kind=small}
，它的每一列代表一个向量。
输入矩阵![I\in R[d,N]](http://img.e-com-net.com/image/info8/c7cf1ecb459942ec9159007770fc6819.gif){kind=small}
分别乘上三个不同的矩阵
、
、
得到3个中间矩阵
、
、
![\in R[d,N]](http://img.e-com-net.com/image/info8/e062925fafa34062acb26123412e8d61.gif){kind=small}
，将转置之后与相乘得到attention矩阵![A\in R[N,N]](http://img.e-com-net.com/image/info8/e3ea86bc691644d4afd0919d0a687389.gif){kind=small}
，代表每一个位置两两之间的attention。再将它去softmax操作之后得到![\widehat{A}\in R[N,N]](http://img.e-com-net.com/image/info8/12e8094a6083488c885feb1bcf3c2bd3.gif){kind=small}
，最后将它乘以矩阵得到输出vect或![O\in R[d,N]](http://img.e-com-net.com/image/info8/b27ab5c3414f484496acb1de9fa38729.gif){kind=small}
Multi-head Self-attention
以2个head为例，由
生成
进一步乘以2个转移矩阵变为
、
，由生成
进一步乘以2个转移矩阵变为
、
， 由生成
进一步乘以2个转移矩阵变为
、
。接下来，做attention，得到加权和的权重
，再与做加权和，得到最终的
,同理得到
。现在有了![b^{i,1}(i=1,2,...,N)\in R[d,1]](http://img.e-com-net.com/image/info8/80c5b475bb174d76b930290acbc612f7.gif){kind=small}
，![b^{i,2}(i=1,2,...,N)\in R[d,1]](http://img.e-com-net.com/image/info8/9dbd82cf443c4ec184e51acd59d5b4b2.gif){kind=small}
，把它们连接起来，再通过一个transformation矩阵调整维度，使之与
维度一致。
Multi-Head Attention 包含多个 Self-Attention 层，首先将输入
分别传递到 2个不同的 Self-Attention 中，计算得到 2 个输出结果。得到2个输出矩阵之后，Multi-Head Attention 将它们拼接在一起 (Concat)，然后传入一个Linear层，得到 Multi-Head Attention 最终的输出 
。可以看到 Multi-Head Attention 输出的矩阵与其输入的矩阵的维度是一样的。
例如在第一步进行图像分割后，我们获得的特征层为（901，768）。在施加多头的时候，我们直接对（901，768）的最后一维度进行分割，比如我们想分割成12个头，那么矩阵的shape就变成（901，12，64）。然后对（901，12，64）进行转置，将12放到前面，获得（12，901，64）的特征层。之后忽略这个12，把它和batchsize维度同等对待，只对901，64进行处理，以上就是注意力机制的过程了。
注意力机制代码如下：
class Attention(nn.Module):
def __init__(self, dim, num_heads=12, qkv_bias=False, attn_drop=0., proj_drop=0.):
super().__init__()
self.num_heads = num_heads
self.scale = (dim // num_heads) ** -0.5
self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
self.attn_drop = nn.Dropout(attn_drop)
self.proj = nn.Linear(dim, dim)
self.proj_drop = nn.Dropout(proj_drop)
def forward(self, x):
B, N, C = x.shape
qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
q, k, v = qkv[0], qkv[1], qkv[2]
attn = (q @ k.transpose(-2, -1)) * self.scale
attn = attn.softmax(dim=-1)
attn = self.attn_drop(attn)
x = (attn @ v).transpose(1, 2).reshape(B, N, C)
x = self.proj(x)
x = self.proj_drop(x)
return x在完成MultiHeadSelfAttention的构建后，我们需要在其后加上两个全连接。就构建了整个TransformerBlock。
class Mlp(nn.Module):
""" MLP as used in Vision Transformer, MLP-Mixer and related networks
"""
def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=GELU, drop=0.):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features or in_features
drop_probs = (drop, drop)
self.fc1 = nn.Linear(in_features, hidden_features)
self.act = act_layer()
self.drop1 = nn.Dropout(drop_probs[0])
self.fc2 = nn.Linear(hidden_features, out_features)
self.drop2 = nn.Dropout(drop_probs[1])
def forward(self, x):
x = self.fc1(x)
x = self.act(x)
x = self.drop1(x)
x = self.fc2(x)
x = self.drop2(x)
return x
class Block(nn.Module):
def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, drop=0., attn_drop=0.,
drop_path=0., act_layer=GELU, norm_layer=nn.LayerNorm):
super().__init__()
self.norm1 = norm_layer(dim)
self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop)
self.norm2 = norm_layer(dim)
self.mlp = Mlp(in_features=dim, hidden_features=int(dim * mlp_ratio), act_layer=act_layer, drop=drop)
self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
def forward(self, x):
x = x + self.drop_path(self.attn(self.norm1(x)))
#-----------------------------------------------#
# 施加层标准化、多头注意力机制、残差结构
#-----------------------------------------------#
x = x + self.drop_path(self.mlp(self.norm2(x)))
#-----------------------------------------------#
# 施加层标准化、两次全连接、残差结构
#-----------------------------------------------#
return x整个VIT模型由一个Patch+Position Embedding加上多个TransformerBlock组成。典型的TransforerBlock的数量为12个。
self.blocks = nn.Sequential(
*[
Block(
dim = num_features,
num_heads = num_heads,
mlp_ratio = mlp_ratio,
qkv_bias = qkv_bias,
drop = drop_rate,
attn_drop = attn_drop_rate,
drop_path = dpr[i],
norm_layer = norm_layer,
act_layer = act_layer
)for i in range(depth)#depth == 12
]
)Vision Transformer的构建代码：
import math
from collections import OrderedDict
from functools import partial
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
#--------------------------------------#
# Gelu激活函数的实现
# 利用近似的数学公式
#--------------------------------------#
class GELU(nn.Module):
def __init__(self):
super(GELU, self).__init__()
def forward(self, x):
return 0.5 * x * (1 + torch.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * torch.pow(x,3))))
def drop_path(x, drop_prob: float = 0., training: bool = False):
if drop_prob == 0. or not training:
return x
keep_prob = 1 - drop_prob
shape = (x.shape[0],) + (1,) * (x.ndim - 1)
random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)
random_tensor.floor_()
output = x.div(keep_prob) * random_tensor
return output
class DropPath(nn.Module):
def __init__(self, drop_prob=None):
super(DropPath, self).__init__()
self.drop_prob = drop_prob
def forward(self, x):
return drop_path(x, self.drop_prob, self.training)
class PatchEmbed(nn.Module):
def __init__(self, input_shape=[480, 480], patch_size=16, in_chans=3, num_features=768, norm_layer=None, flatten=True):
super().__init__()
self.num_patches = (input_shape[0] // patch_size) * (input_shape[1] // patch_size)
self.flatten = flatten
self.proj = nn.Conv2d(in_chans, num_features, kernel_size=patch_size, stride=patch_size)
self.norm = norm_layer(num_features) if norm_layer else nn.Identity()
def forward(self, x):
x = self.proj(x)
if self.flatten:
x = x.flatten(2).transpose(1, 2) # BCHW -> BNC
x = self.norm(x)
return x
#--------------------------------------------------------------------------------------------------------------------#
# Attention机制
# 将输入的特征qkv特征进行划分，首先生成query, key, value。query是查询向量、key是键向量、v是值向量。
# 然后利用 查询向量query 点乘 转置后的键向量key，这一步可以通俗的理解为，利用查询向量去查询序列的特征，获得序列每个部分的重要程度score。
# 然后利用 score 点乘 value，这一步可以通俗的理解为，将序列每个部分的重要程度重新施加到序列的值上去。
#--------------------------------------------------------------------------------------------------------------------#
class Attention(nn.Module):
def __init__(self, dim, num_heads=12, qkv_bias=False, attn_drop=0., proj_drop=0.):
super().__init__()
self.num_heads = num_heads
self.scale = (dim // num_heads) ** -0.5
self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
self.attn_drop = nn.Dropout(attn_drop)
self.proj = nn.Linear(dim, dim)
self.proj_drop = nn.Dropout(proj_drop)
def forward(self, x):
B, N, C = x.shape
qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
q, k, v = qkv[0], qkv[1], qkv[2]
attn = (q @ k.transpose(-2, -1)) * self.scale
attn = attn.softmax(dim=-1)
attn = self.attn_drop(attn)
x = (attn @ v).transpose(1, 2).reshape(B, N, C)
x = self.proj(x)
x = self.proj_drop(x)
return x
class Mlp(nn.Module):
""" MLP as used in Vision Transformer, MLP-Mixer and related networks
"""
def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=GELU, drop=0.):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features or in_features
drop_probs = (drop, drop)
self.fc1 = nn.Linear(in_features, hidden_features)
self.act = act_layer()
self.drop1 = nn.Dropout(drop_probs[0])
self.fc2 = nn.Linear(hidden_features, out_features)
self.drop2 = nn.Dropout(drop_probs[1])
def forward(self, x):
x = self.fc1(x)
x = self.act(x)
x = self.drop1(x)
x = self.fc2(x)
x = self.drop2(x)
return x
class Block(nn.Module):
def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, drop=0., attn_drop=0.,
drop_path=0., act_layer=GELU, norm_layer=nn.LayerNorm):
super().__init__()
self.norm1 = norm_layer(dim)
self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop)
self.norm2 = norm_layer(dim)
self.mlp = Mlp(in_features=dim, hidden_features=int(dim * mlp_ratio), act_layer=act_layer, drop=drop)
self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
def forward(self, x):
x = x + self.drop_path(self.attn(self.norm1(x)))
x = x + self.drop_path(self.mlp(self.norm2(x)))
return x
class Conv2dReLU(nn.Sequential):
def __init__(
self,
in_channels,
out_channels,
kernel_size,
padding=0,
stride=1,
use_batchnorm=True,
):
conv = nn.Conv2d(
in_channels,
out_channels,
kernel_size,
stride=stride,
padding=padding,
bias=not (use_batchnorm),
)
relu = nn.ReLU(inplace=True)
bn = nn.BatchNorm2d(out_channels)
super(Conv2dReLU, self).__init__(conv, bn, relu)
class VisionTransformer(nn.Module):
def __init__(
self, input_shape=[480, 480], patch_size=16, in_chans=3, num_classes=2, num_features=768,
depth=12, num_heads=12, mlp_ratio=4., qkv_bias=True, drop_rate=0.1, attn_drop_rate=0.1, drop_path_rate=0.1,
norm_layer=partial(nn.LayerNorm, eps=1e-6), act_layer=GELU
):
super().__init__()
#-----------------------------------------------#
# 480, 480, 3 -> 196, 768
#-----------------------------------------------#
self.patch_embed = PatchEmbed(input_shape=input_shape, patch_size=patch_size, in_chans=in_chans, num_features=num_features)
num_patches = (480 // patch_size) * (480 // patch_size)
self.num_features = num_features
self.new_feature_shape = [int(input_shape[0] // patch_size), int(input_shape[1] // patch_size)]
self.old_feature_shape = [int(480 // patch_size), int(480 // patch_size)]
#--------------------------------------------------------------------------------------------------------------------#
# classtoken部分是transformer的分类特征。用于堆叠到序列化后的图片特征中，作为一个单位的序列特征进行特征提取。
#
# 在利用步长为16x16的卷积将输入图片划分成14x14的部分后，将14x14部分的特征平铺，一幅图片会存在序列长度为196的特征。
# 此时生成一个classtoken，将classtoken堆叠到序列长度为196的特征上，获得一个序列长度为197的特征。
# 在特征提取的过程中，classtoken会与图片特征进行特征的交互。最终分类时，我们取出classtoken的特征，利用全连接分类。
#--------------------------------------------------------------------------------------------------------------------#
# 196, 768 -> 197, 768
self.cls_token = nn.Parameter(torch.zeros(1, 1, num_features))
#--------------------------------------------------------------------------------------------------------------------#
# 为网络提取到的特征添加上位置信息。
# 以输入图片为480, 480, 3为例，我们获得的序列化后的图片特征为196, 768。加上classtoken后就是197, 768
# 此时生成的pos_Embedding的shape也为197, 768，代表每一个特征的位置信息。
#--------------------------------------------------------------------------------------------------------------------#
# 197, 768 -> 197, 768
self.pos_embed = nn.Parameter(torch.zeros(1, num_patches, num_features))
self.pos_drop = nn.Dropout(p=drop_rate)
#-----------------------------------------------#
# 197, 768 -> 197, 768 12次
#-----------------------------------------------#
dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]
self.blocks = nn.Sequential(
*[
Block(
dim = num_features,
num_heads = num_heads,
mlp_ratio = mlp_ratio,
qkv_bias = qkv_bias,
drop = drop_rate,
attn_drop = attn_drop_rate,
drop_path = dpr[i],
norm_layer = norm_layer,
act_layer = act_layer
)for i in range(depth)
]
)
self.norm = norm_layer(num_features)
self.head = nn.Linear(num_features, num_classes) if num_classes > 0 else nn.Identity()
n_patches = (480 // 16) * (480 // 16)
self.position_embeddings = nn.Parameter(torch.zeros(1, n_patches, 768))
self.conv_more = Conv2dReLU(
768,
2048,
kernel_size=3,
padding=1,
use_batchnorm=True,
)
def forward_features(self, x):
x = self.patch_embed(x)
# cls_token = self.cls_token.expand(x.shape[0], -1, -1)
# x = torch.cat((cls_token, x), dim=1)
#
# cls_token_pe = self.pos_embed[:, 0:1, :]
# img_token_pe = self.pos_embed[:, 1: , :]
# print(img_token_pe.shape)
#
# img_token_pe = img_token_pe.view(1, *self.old_feature_shape, -1).permute(0, 3, 1, 2)
# print(img_token_pe.shape)
# img_token_pe = F.interpolate(img_token_pe, size=self.new_feature_shape, mode='bicubic', align_corners=False)
# print(img_token_pe.shape)
# img_token_pe = img_token_pe.permute(0, 2, 3, 1).flatten(2)
# print(img_token_pe.shape)
# pos_embed = torch.cat([cls_token_pe, img_token_pe], dim=1)
# x = x.flatten(2)
# x = x.transpose(-1, -2)
x = x + self.position_embeddings
x = self.pos_drop(x)
x = self.blocks(x)
x = self.norm(x)
return x
def forward1(self,hidden_states):
B, n_patch, hidden = hidden_states.size() # reshape from (B, n_patch, hidden) to (B, h, w, hidden)
h, w = int(np.sqrt(n_patch)), int(np.sqrt(n_patch))
x = hidden_states.permute(0, 2, 1)
x = x.contiguous().view(B, hidden, h, w)
x = self.conv_more(x)
return x
def forward(self, x):
x = self.forward_features(x)
x = self.forward1(x)
# print(x.shape)
return x
def freeze_backbone(self):
backbone = [self.patch_embed, self.cls_token, self.pos_embed, self.pos_drop, self.blocks[:8]]
for module in backbone:
try:
for param in module.parameters():
param.requires_grad = False
except:
module.requires_grad = False
def Unfreeze_backbone(self):
backbone = [self.patch_embed, self.cls_token, self.pos_embed, self.pos_drop, self.blocks[:8]]
for module in backbone:
try:
for param in module.parameters():
param.requires_grad = True
except:
module.requires_grad = True
def vit(input_shape=[480, 480], pretrained=False, num_classes=2):
model = VisionTransformer(input_shape)
if pretrained:
model.load_state_dict(torch.load("model_data/vit-patch_16.pth"))
if num_classes!=1000:
model.head = nn.Linear(model.num_features, num_classes)
return model