人工智能uu

这个屌丝很懒，什么也没留下！

热门标签

【深度学习】Vision Transformer 学习笔记_visio transformer中的 depth参数

作者：人工智能uu | 2024-08-06 22:53:20

踩

visio transformer中的 depth参数

参考文献

[1][Vision Transformer详解]http://t.csdn.cn/cz9pt

[2][VIT模型论文+代码(源码)从零详细解读] https://www.bilibili.com/video/BV1Uu411o7oY/?share_source=copy_web&vd_source=10c62421a881dc5bd3fb5ed45ab4005b

[3][MLP]https://zhuanlan.zhihu.com/p/63184325

[4][Normalization方法]http://t.csdn.cn/60Spb

[5][注意力机制]https://fanrenyi.com/blog/467

Vison Transformer（VIT）模型结构

VIT模型结构图:

根据上文《相关介绍》可知，VIT是迁移原本为NLP设计的Transformer模型，因此VIT中的图像输入应该转化为NLP中的序列信息（如：一句话中的词语之间是有先后顺序的），于是在文中加入了拆分图片（类似得到词语）、位置编码（给“词语”顺序），从而实现了输入的转化,进而通过Transformer完成后续流程。

以上图分类模型为例进行说明：

图片分类分为五步——

①完整图片切分为多个patch.

②patch转化为embedding.

③加入位置编码Position Embedding.

④迁移Transformer.

⑥运用MLP Head进行分类.

关于图像分类:cls不是必须的,参见[2]

模型中组件介绍

由VIT模型结构图中Transformer Encoder可知,存在Norm,Multi-Head Attention,MLP,它们分表表示什么含义呢,下面我们逐一解说!

Norm

通常我们得到的样本数据都是多个特征的，数据样本的不同特征可能会有不同的尺度，而深度学习中是通过误差反向传播来修正模型,不同尺度对误差影响差异过大,容易导致各特征的影响差异因数据的尺度增大,因此常常通过归一化的方法来解决这一个问题;

常见归一化方法展示:

BN:对不同样本里面的同一个特征通道进行归一化处理，逐特征维度归一化;

LN:取同一个样本的不同通道做归一化，逐样本归一化;

IN：仅仅对每一个样本的每一个通道做归一化;

GN：介于LN和IN之间的一种方法，对每个样本的多个通道进行归一化。

各方法适用于什么情况，请参见[4]

而Transformer中使用的Layer Normalization.

Multi-Head Attention

!!!多头注意力机制是VIT中的非常重要的部分,应该着重理解其含义!!!（也别想得太复杂）

以下即为多头注意力机制流程，请仔细看图中英文部分，对于运用模型来说，知道注意力机制的作用和以下数据流程（方便理解代码）即可，即明白x到z考虑到了注意力，实现方式即为中间的矩阵运算（单头则理解为headss为1）

如果需要更细致的了解，请参见视频讲解https://www.bilibili.com/video/BV1PP4y1T7Yu/?spm_id_from=333.880.my_history.page.click&vd_source=88979ab8842f2aab90e9f2eae985cc21

MLP

MLP即为多层感知机模型,一种经典的全连接网络构成的神经网络,其结构图如下!

MLP结构图:

VIT代码实现

代码来自于https://github.com/lucidrains/vit-pytorch ，接下来将讲解其中代码，一定要理解前文的原理，因为代码实现就是完成矩阵运算流程，特别关注原理中各块对应的矩阵运算如何进行！

1、导入需要的包

einops是一个用于操作张量的库，它的出现可以替代我们平时使用的reshape、view、transpose和permute等操作，相信接触过深度学习的同学一定对这些函数比较的熟悉。

einops相较于上面说的那些函数，最显著的区别就是逻辑更加的清晰，用网上的一句话来说的话，就是可以避免view、transpose等函数的神秘主义。


import torch  
from torch import nn  #使用pytorch框架
 
from einops import rearrange, repeat 
from einops.layers.torch import Rearrange

2、Helpers

定义后面需要使用的函数


def pair(t):
    return t if isinstance(t, tuple) else (t, t)

3、classes

定义类，__init__中类似定义各个元素，forward定义流程


class PreNorm(nn.Module):
    def __init__(self, dim, fn):
        super().__init__()
        self.norm = nn.LayerNorm(dim)
        self.fn = fn
    def forward(self, x, **kwargs):    
        return self.fn(self.norm(x), **kwargs)  
    #表示Transformer中先进行Norm，再进行某变换，即对应图中MHA（多头）与MLP


class FeedForward(nn.Module):
    def __init__(self, dim, hidden_dim, dropout = 0.):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(dim, hidden_dim),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, dim),
            nn.Dropout(dropout)
        )
    def forward(self, x):
        return self.net(x)
    #这里构造的MLP网络结构，即两层全连接网络

注意力机制的计算流程


#参考上图理解
class Attention(nn.Module):
    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
        super().__init__()
        inner_dim = dim_head *  heads
        project_out = not (heads == 1 and dim_head == dim) 
        #判断单头还是多头注意力机制
 
        self.heads = heads
        self.scale = dim_head ** -0.5   
        #看一下注意力机制的计算公式，这里即为根号d，用于放缩
 
        self.attend = nn.Softmax(dim = -1)
        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
 
        self.to_out = nn.Sequential(
            nn.Linear(inner_dim, dim),
            nn.Dropout(dropout)
        ) if project_out else nn.Identity()
        # nn.Identity()表示恒等变形，参见blog：https://blog.csdn.net/OrdinaryMatthew/article/details/126741133
 
    def forward(self, x):
        qkv = self.to_qkv(x).chunk(3, dim = -1)
        # torch.chunk(tensor, chunk_num, dim)与torch.cat()原理相反，它是将tensor按dim（行或列）分割成chunk_num个tensor块，返回的是一个元组。
        # torch.chunk参见：http://t.csdn.cn/73ksG
        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
        # map函数表示对元组内各个原始进行相同的函数变换
 
        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
 
        attn = self.attend(dots)
 
        out = torch.matmul(attn, v)
        out = rearrange(out, 'b h n d -> b n (h d)')
        return self.to_out(out)


# 计算流程已在网络框架中Transformer Encoder体现
class Transformer(nn.Module):
    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
        super().__init__()
        self.layers = nn.ModuleList([])
        for _ in range(depth):
            self.layers.append(nn.ModuleList([
                PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)),
                PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))
            ]))
    def forward(self, x):
        for attn, ff in self.layers:
            x = attn(x) + x
            x = ff(x) + x
        return x
    # depth表示有多少个Transformer Encoder，forward连接多个Transformer Encoder

4、VIT主体代码


class ViT(nn.Module):
    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, pool = 'cls', channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0.):
        super().__init__()
        image_height, image_width = pair(image_size) ## 224*224
        patch_height, patch_width = pair(patch_size) ## 16 * 16
 
        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
 
        num_patches = (image_height // patch_height) * (image_width // patch_width)
        patch_dim = channels * patch_height * patch_width
        assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
 
        self.to_patch_embedding = nn.Sequential(
            Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
            nn.Linear(patch_dim, dim),
        )
 
        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
        # 位置编码原来随机生成的啊，并且可更新
        # nn.Parameter()添加的参数会被添加到Parameters列表中，会被送入优化器中随训练一起学习更新，详情参见 https://blog.csdn.net/hxxjxw/article/details/107904012
        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
        self.dropout = nn.Dropout(emb_dropout)
 
        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
 
        self.pool = pool
        self.to_latent = nn.Identity()
        # 恒等映射有什么意义？
 
        self.mlp_head = nn.Sequential(
            nn.LayerNorm(dim),
            nn.Linear(dim, num_classes)
        )
 
    def forward(self, img):
        x = self.to_patch_embedding(img) ## img 1 3 224 224  输出形状x : 1 196 1024 
        b, n, _ = x.shape ## 
 
        #cls_tokens = repeat(self.cls_token, '() n d -> b n d', b = b)  #这里这个（）没看懂耶，也可以写成如下形式，（）可能是自动计算的意思吧
        cls_tokens = repeat(self.cls_token, '1 n d -> b n d', b = b)    #einops中维度变换的表示方法叫做爱因斯坦表示，感兴趣可以自行了解
 
        x = torch.cat((cls_tokens, x), dim=1)
        x += self.pos_embedding[:, :(n + 1)]
        x = self.dropout(x)
 
        x = self.transformer(x)
 
        x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
 
        x = self.to_latent(x)
        return self.mlp_head(x)

对于一些细节的语法，除了查找资料，自己测试也是一个好方法

比如：对self.pos_embedding[:, :(n + 1)]的索引方法很好奇，明明维度是3，为什么所有时只有两部分，通过以下测试我们就可以得到答案——按照维度从前往后取，没有涉及到的后方维度就全部获取。(提供一种解读代码的常用手段)

5、在样例中检验代码能否跑通


vision_transformer = ViT(
        image_size=256,patch_size=32,
        num_classes=4,dim=1024,
        depth=1,heads=2,mlp_dim=2048
        )
x = torch.zeros(1,3, 256, 256)
out = vision_transformer(x)
print(out.shape)

后续

到此，VIT模型已经跑通，但是此模型相比CNN并没有绝对的优势，可以参见https://www.bilibili.com/video/BV1L3411x7hw/?spm_id_from=333.999.0.0&vd_source=88979ab8842f2aab90e9f2eae985cc21

于是之后借鉴CNN的特点，设计了Swin transformer，论文解读见https://www.bilibili.com/video/BV13L4y1475U/?spm_id_from=333.999.0.0&vd_source=88979ab8842f2aab90e9f2eae985cc21

还有一些融合CNN与transformer的混合模型.....

下期预告：Swin Transformer

（笔者已规划好分享框架，但更新不会严格按照体系来分享——目前自己也有科研项目，我会尽力更新完并成体系！！！冲冲冲）

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/939702