Vision Transformer代码讲解及复现

最新推荐文章于 2024-08-18 13:51:27 发布
最新推荐文章于 2024-08-18 13:51:27 发布
阅读量2.3k 收藏 8
点赞数 2
分类专栏： paddle torch 文章标签： pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apodx/article/details/123941610
版权

VIT(Vision in Transformer)网络结构

1. Embedding层结构详解

在代码实现中，直接通过一个卷积层来实现。

在输入Transformer Encoder之前注意需要加上token以及Position Embedding。

import paddle
import paddle.nn as nn
from PIL import Image
import numpy as np
class PatchEmbedding(nn.Layer):
    def __init__(self,image_size,patch_size,in_channels,embed_dim,dropout=0.):
        super().__init__()

        self.embed_dim = embed_dim
        n_patches = (image_size//patch_size)*(image_size//patch_size)
        self.patch_embedding = nn.Conv2D(in_channels=in_channels,
                                    out_channels=embed_dim,
                                    kernel_size=patch_size,
                                    stride=patch_size,
                                    weight_attr=paddle.ParamAttr(initializer=nn.initializer.Constant(1.0)),
                                    bias_attr=False)
        self.dropout = nn.Dropout(dropout)
        # add class token
        self.class_token = paddle.create_parameter(shape=[1,1,embed_dim],
                                                    dtype='float32',
                                                    default_initializer=nn.initializer.Constant(0.))
        # add position embedding
        self.position_embedding = paddle.create_parameter(shape=[1,n_patches+1,embed_dim],dtype='float32',
                                    default_initializer=nn.initializer.TruncatedNormal(std=0.02))
    def forward(self,x):
        # [1,3,224,224]
        # [batch,channel,h,w]
        cls_token = self.class_token.expand([x.shape[0],-1,-1])
        x = self.patch_embedding(x)
        # [1,768, 32,32]
        # [batch,embed_dim,h,w]
        x = x.flatten(2)
        # [1,768, 32*32]
        # [batch,embed_dim,h*w]
        x = x.transpose([0,2,1])
        # [batch,h*w,embed_dim]
        x = paddle.concat([cls_token,x],axis=1)
        x = x + self.position_embedding
        return x

2. Transformer Encoder详解

  • Layer Norm，这种Normalization方法主要是针对NLP领域提出的，下图1也是比较形象的说明BN和LN的区别。
  • Multi-Head Attention，这个结构之前在讲Transformer中很详细的讲过。
  • Dropout/DropPath，在原论文的代码中是直接使用的Dropout层，但是在pytorch实现中使用的是Droppath。
  • MLP Block，全连接+GELU激活函数+Dropout组成也非常简单。

Multi-Head Attention

class Attention(nn.Layer):
    def __init__(self,embed_dim,num_heads,qkv_bias=False,qk_scale=None,dropout=0.,attention_dropout=0.):
        super().__init__()
        self.embed_dim = embed_dim
        self.num_heads = num_heads
        self.head_dim = embed_dim//num_heads
        self.all_head_dim = self.head_dim*num_heads
        self.qkv = nn.Linear(embed_dim,
                            self.all_head_dim*3,
                            bias_attr=False if qk_scale is False else None)
        self.scale = self.head_dim**-0.5 if qk_scale is None else qk_scale
        self.softmax = nn.Softmax(-1)
        self.proj = nn.Linear(self.all_head_dim,embed_dim)
        self.dropout = nn.Dropout(p=dropout)
    def transpose_multi_head(self,x):
        # [B,N,all_head_dim]*3
        # [8,16,4,24]
        new_shape = x.shape[:-1]+[self.num_heads,self.head_dim]
        x = x.reshape(new_shape)
        # [8,4,16,24]
        x = x.transpose([0,2,1,3])
        return x
    def forward(self,x):
        # 8,16,96
        B,N,_ = x.shape
        # 8,16,96*3
        # [8,16,96],[8,16,96],[8,16,96]
        qkv = self.qkv(x).chunk(3,-1)
        #[8,4,16,24]
        #[B,num_heads,num_pathches,head_dim]
        q,k,v = map(self.transpose_multi_head,qkv)
        attn = paddle.matmul(q,k,transpose_y=True)
        attn = self.softmax(attn*self.scale)
        #dropout
        #[B,num_heads,num_pathches,num_pathches]
        attn = self.dropout(attn)
        #[B,num_heads,num_pathches,head_dim]
        out = paddle.matmul(attn,v)
        out = out.transpose([0,2,1,3])
        # 8,16,4,24
        #[B,num_pathches,num_heads,head_dim]
        out = out.reshape([B,N,-1])
        out = self.proj(out)
        out = self.dropout(out)
        return out

MLP

class Mlp(nn.Layer):
    def __init__(self,embed_dim,mlp_ratio=4.0,dropout=0.):
        super().__init__()
        w_att_1,b_att_1 = self.init_weight()
        w_att_2,b_att_2 = self.init_weight()
        self.fc1 = nn.Linear(embed_dim,int(embed_dim*mlp_ratio),weight_attr=w_att_1,bias_attr=b_att_1)
        self.fc2 = nn.Linear(int(embed_dim*mlp_ratio),embed_dim,weight_attr=w_att_2,bias_attr=b_att_2)
        self.dropout = nn.Dropout(dropout)
        self.act = nn.GELU()
    def init_weight(self):
        weight_attr = paddle.ParamAttr(initializer=nn.initializer.TruncatedNormal(std=0.2))
        bias_attr = paddle.ParamAttr(initializer=nn.initializer.Constant(.0))
        return  weight_attr,bias_attr
    def forward(self,x):
        x = self.fc1(x)
        x = self.act(x)
        x = self.dropout(x)
        x = self.fc2(x)
        x = self.dropout(x)
        return x

Encoder Block

class EncoderLayer(nn.Layer):
    def __init__(self,embed_dim,num_head,mlp_ratio=4.0):
        super().__init__()
        w_att_1,b_att_1 = self.init_weight()
        w_att_2,b_att_2 = self.init_weight()
        self.attn = Attention(embed_dim,num_head)
        self.attn_norm = nn.LayerNorm(embed_dim,weight_attr=w_att_1,bias_attr=b_att_1)
        self.mlp = Mlp(embed_dim,mlp_ratio)
        self.mlp_norm = nn.LayerNorm(embed_dim,weight_attr=w_att_2,bias_attr=b_att_2)
    
    def init_weight(self):
        weight = paddle.ParamAttr(initializer=nn.initializer.Constant(1.0))
        bias = paddle.ParamAttr(initializer=nn.initializer.Constant(.0))
        return weight,bias
        
    def forward(self,x):
        h = x
        x = self.attn_norm(x)
        x = self.attn(x)
        x = h + x 
        h = x
        x = self.mlp_norm(x)
        x = self.mlp(x)
        x = h+x
        return x

class Encoder (nn.Layer):
    def __init__(self,embed_dim,num_head,depth):
        super().__init__()
        w_att_1,b_att_1 = self._init_weights()
        layer_list  = [EncoderLayer(embed_dim,num_head) for i in range(depth)]
        self.encoder = nn.LayerList(layer_list)
        self.encoder_norm = nn.LayerNorm(embed_dim,
                                         weight_attr=w_att_1,
                                         bias_attr=b_att_1,
                                         epsilon=1e-6)

    def _init_weights(self):
        weight_attr = paddle.ParamAttr(initializer=nn.initializer.Constant(1.0))
        bias_attr = paddle.ParamAttr(initializer=nn.initializer.Constant(0.0))
        return weight_attr, bias_attr
    def forward(self,x):
        for encoder in self.encoder:
            x = encoder(x)
        x = self.encoder_norm(x)
        return x 

class VisualTransformer(nn.Layer):
    def __init__(self,
                image_size = 224,
                patch_size = 16,
                in_channels = 3,
                num_classes = 1000,
                embed_dim = 768,
                depth = 3,
                num_heads = 8,
                mlp_ratio = 4,
                qkv_bias = True,
                dropout = 0.,
                attention_dropout = 0.,
                droppatch = 0.):
        super().__init__()
        self.patch_embedding = PatchEmbedding(image_size,patch_size,in_channels,embed_dim,dropout)
        self.encoder = Encoder(embed_dim,num_heads,depth)
        self.classifier = nn.Linear(embed_dim,num_classes)
    def forward(self,x):
        x = self.patch_embedding(x)
        x = x.flatten(2)
        x = self.encoder(x)
        x = self.classifier(x[:,0])
        return x

3. 最后我们打印下网络结果

    vit = VisualTransformer()
    print(vit)
    paddle.summary(vit,(4,3,224,224))

VisualTransformer(
  (patch_embedding): PatchEmbedding(
    (patch_embedding): Conv2D(3, 768, kernel_size=[16, 16], stride=[16, 16], data_format=NCHW)
    (dropout): Dropout(p=0.0, axis=None, mode=upscale_in_train)
  )
  (encoder): Encoder(
    (encoder): LayerList(
      (0): EncoderLayer(
        (attn): Attention(
          (qkv): Linear(in_features=768, out_features=2304, dtype=float32)
          (softmax): Softmax(axis=-1)
          (proj): Linear(in_features=768, out_features=768, dtype=float32)
          (dropout): Dropout(p=0.0, axis=None, mode=upscale_in_train)
        )
        (attn_norm): LayerNorm(normalized_shape=[768], epsilon=1e-05)
        (mlp): Mlp(
          (fc1): Linear(in_features=768, out_features=3072, dtype=float32)
          (fc2): Linear(in_features=3072, out_features=768, dtype=float32)
          (dropout): Dropout(p=0.0, axis=None, mode=upscale_in_train)
          (act): GELU(approximate=False)
        )
        (mlp_norm): LayerNorm(normalized_shape=[768], epsilon=1e-05)
      )
      (1): EncoderLayer(
        (attn): Attention(
          (qkv): Linear(in_features=768, out_features=2304, dtype=float32)
          (softmax): Softmax(axis=-1)
          (proj): Linear(in_features=768, out_features=768, dtype=float32)
          (dropout): Dropout(p=0.0, axis=None, mode=upscale_in_train)
        )
        (attn_norm): LayerNorm(normalized_shape=[768], epsilon=1e-05)
        (mlp): Mlp(
          (fc1): Linear(in_features=768, out_features=3072, dtype=float32)
          (fc2): Linear(in_features=3072, out_features=768, dtype=float32)
          (dropout): Dropout(p=0.0, axis=None, mode=upscale_in_train)
          (act): GELU(approximate=False)
        )
        (mlp_norm): LayerNorm(normalized_shape=[768], epsilon=1e-05)
      )
      (2): EncoderLayer(
        (attn): Attention(
          (qkv): Linear(in_features=768, out_features=2304, dtype=float32)
          (softmax): Softmax(axis=-1)
          (proj): Linear(in_features=768, out_features=768, dtype=float32)
          (dropout): Dropout(p=0.0, axis=None, mode=upscale_in_train)
        )
        (attn_norm): LayerNorm(normalized_shape=[768], epsilon=1e-05)
        (mlp): Mlp(
          (fc1): Linear(in_features=768, out_features=3072, dtype=float32)
          (fc2): Linear(in_features=3072, out_features=768, dtype=float32)
          (dropout): Dropout(p=0.0, axis=None, mode=upscale_in_train)
          (act): GELU(approximate=False)
        )
        (mlp_norm): LayerNorm(normalized_shape=[768], epsilon=1e-05)
      )
    )
    (encoder_norm): LayerNorm(normalized_shape=[768], epsilon=1e-06)
  )
  (classifier): Linear(in_features=768, out_features=1000, dtype=float32)
)
----------------------------------------------------------------------------
  Layer (type)       Input Shape          Output Shape         Param #    
============================================================================
    Conv2D-1      [[4, 3, 224, 224]]    [4, 768, 14, 14]       589,824    
PatchEmbedding-1  [[4, 3, 224, 224]]     [4, 197, 768]         152,064    
  LayerNorm-1      [[4, 197, 768]]       [4, 197, 768]          1,536     
    Linear-1       [[4, 197, 768]]       [4, 197, 2304]       1,771,776   
   Softmax-1      [[4, 8, 197, 197]]    [4, 8, 197, 197]          0       
   Dropout-2       [[4, 197, 768]]       [4, 197, 768]            0       
    Linear-2       [[4, 197, 768]]       [4, 197, 768]         590,592    
  Attention-1      [[4, 197, 768]]       [4, 197, 768]            0       
  LayerNorm-2      [[4, 197, 768]]       [4, 197, 768]          1,536     
    Linear-3       [[4, 197, 768]]       [4, 197, 3072]       2,362,368   
     GELU-1        [[4, 197, 3072]]      [4, 197, 3072]           0       
   Dropout-3       [[4, 197, 768]]       [4, 197, 768]            0       
    Linear-4       [[4, 197, 3072]]      [4, 197, 768]        2,360,064   
     Mlp-1         [[4, 197, 768]]       [4, 197, 768]            0       
 EncoderLayer-1    [[4, 197, 768]]       [4, 197, 768]            0       
  LayerNorm-3      [[4, 197, 768]]       [4, 197, 768]          1,536     
    Linear-5       [[4, 197, 768]]       [4, 197, 2304]       1,771,776   
   Softmax-2      [[4, 8, 197, 197]]    [4, 8, 197, 197]          0       
   Dropout-4       [[4, 197, 768]]       [4, 197, 768]            0       
    Linear-6       [[4, 197, 768]]       [4, 197, 768]         590,592    
  Attention-2      [[4, 197, 768]]       [4, 197, 768]            0       
  LayerNorm-4      [[4, 197, 768]]       [4, 197, 768]          1,536     
    Linear-7       [[4, 197, 768]]       [4, 197, 3072]       2,362,368   
     GELU-2        [[4, 197, 3072]]      [4, 197, 3072]           0       
   Dropout-5       [[4, 197, 768]]       [4, 197, 768]            0       
    Linear-8       [[4, 197, 3072]]      [4, 197, 768]        2,360,064   
     Mlp-2         [[4, 197, 768]]       [4, 197, 768]            0       
 EncoderLayer-2    [[4, 197, 768]]       [4, 197, 768]            0       
  LayerNorm-5      [[4, 197, 768]]       [4, 197, 768]          1,536     
    Linear-9       [[4, 197, 768]]       [4, 197, 2304]       1,771,776   
   Softmax-3      [[4, 8, 197, 197]]    [4, 8, 197, 197]          0       
   Dropout-6       [[4, 197, 768]]       [4, 197, 768]            0       
   Linear-10       [[4, 197, 768]]       [4, 197, 768]         590,592    
  Attention-3      [[4, 197, 768]]       [4, 197, 768]            0       
  LayerNorm-6      [[4, 197, 768]]       [4, 197, 768]          1,536     
   Linear-11       [[4, 197, 768]]       [4, 197, 3072]       2,362,368   
     GELU-3        [[4, 197, 3072]]      [4, 197, 3072]           0       
   Dropout-7       [[4, 197, 768]]       [4, 197, 768]            0       
   Linear-12       [[4, 197, 3072]]      [4, 197, 768]        2,360,064   
     Mlp-3         [[4, 197, 768]]       [4, 197, 768]            0       
 EncoderLayer-3    [[4, 197, 768]]       [4, 197, 768]            0       
  LayerNorm-7      [[4, 197, 768]]       [4, 197, 768]          1,536     
   Encoder-1       [[4, 197, 768]]       [4, 197, 768]            0       
   Linear-13          [[4, 768]]           [4, 1000]           769,000    
============================================================================
Total params: 22,776,040
Trainable params: 22,776,040
Non-trainable params: 0
----------------------------------------------------------------------------
Input size (MB): 2.30
Forward/backward pass size (MB): 323.93
Params size (MB): 86.88
Estimated Total Size (MB): 413.11
----------------------------------------------------------------------------






{'total_params': 22776040, 'trainable_params': 22776040}

4. 参考地址

代码实现

Vision Transformer详解

apodxxx
关注
专栏目录
Transformer课程 第43章Transformer模型SqueezeBERT架构
段智华的博客
11-27 286
第43章：使用grouped convolutions进行加速的Transformer模型SqueezeBERT架构内幕及完整源码实现 1，Computer vision中的grouped convolutions数学原理分析 2，把grouped convolutions用来加速Transformer的架构设计 3，SqueezeBertTokenizer源码完整实现分析 4，SqueezeBertEmbeddings源码完整实现分析 5，MatMulWrapper源码完整实现分析 6，SqueezeBe
Transformer课程 第46章 Transformer模型TAPAS架构
段智华的博客
11-27 285
第46章：从tabular data中获得答案的Transformer模型TAPAS架构内幕及其Tokenizer完整源码实现 1，使用relative position embeddings编码tabular structure数学原理剖析 2，使用7 token types编码tabular数据分析 3，TAPAS中的masked language modeling (MLM)分析 4，cell selection head and an aggregation head 5，基于weak superv
vision_transformer
03-16
视觉变压器 作者：Alexey Dosovitskiy *†，Lucas Beyer *，Alexander Kolesnikov *，Dirk Weissenborn *，翟小华*，Thomas Unterthiner，Mostafa Dehghani，Matthias Minderer，Georg Heigold，Sylvain Gelly，Jakob Uszkoreit和Neil Houlsby *†。 （*）等于技术贡献，（†）等于建议。 由Andreas Steiner准备的开源发行版。 注意：此存储库是从分支和修改的。 介绍 在此存储库中，我们从论文 释放模型，这些模型已在 （ imagenet21k ）数据集上进行了预训练。 我们提供用于微调 / 已发布模型的代码。 模型概述：我们将图像分割成固定大小的块，线性地嵌入每个块，添加位置嵌入，然后将所得的矢量序列馈送到标
Vision Transformer详解（附代码）
欢迎来到道的世界
01-10 6471
 受NLP\mathrm{NLP}NLP中Transformer\mathrm{Transformer}Transformer扩展成功的启发，Vision Transformer\mathrm{Vision\text{ }Transformer}Vision Transformer又进一步体现了Transformer\mathrm{Transformer}Transformer在计算机视觉的重要性，它可以很好的地取代卷积操作。本文会详细讲解 ...
Vision transformer
最新发布
juluwangriyue的博客
08-18 899
transformer在机器视觉中的应用。
Vision Transformer源码详解
m0_53374472的博客
11-10 1522
本篇文章主要分享视觉Transformer的Pytorch实现和代码细节问题,着重在于Vision Transfomer的Pytorch实现，
Vision Transformer（ViT）PyTorch代码全解析（附图解）
热门推荐
weixin_44966641的博客
07-14 6万+
Vision Transformer（ViT）代码全解析 最近CV领域的Vision Transformer将在NLP领域的Transormer结果借鉴过来，屠杀了各大CV榜单。本文将根据最原始的Vision Transformer论文，及其PyTorch实现，将整个ViT的代码做一个全面的解析。 对原Transformer还不熟悉的读者可以看一下Attention is All You Need原文，中文讲解推荐李宏毅老师的视频，个人觉得讲的很明白。 话不多说，直接开始。 下图是ViT的整体框架图，我们在
vision in transformer代码（attention的可视化）
weixin_44149454的博客
05-03 3139
github地址：https://github.com/lucidrains/vit-pytorch 这地方可以进行attention的可视化，在做不同方面的人体部分的特征整合时可以可视化看看对于不同子动作的attention值进行可视化。
详解Swin Transformer核心实现，经典模型也能快速调优
百度大脑
03-03 606
2020年，基于自注意力机制的Vision Transformer将用于NLP领域的Transformer模型成功地应用到了CV领域的图像分类上，并在ImageNet数据集上得到88.55%的精度。 然而想要真正地将Transformer模型应用到整个CV领域，有两点问题需要解决。1、超高分辨率的图像所带来的计算量问题；2、CV领域任务繁多，如语义分割，目标检测，实力分割等密集预测型任务。而最初的Vision Transformer是不具备多尺度预测的，因此仅在分类一个任务可以很好地工作。 针对第一..
紧跟步伐，何恺明新作MAE复现历程
迈微AI研习社 · 号主
12-27 2905
本文已获CW不要無聊的風格的发布授权，原文标题为《别再无聊地吹捧了，一起来动手实现 MAE(Masked Autoencoders Are Scalable Vision Learners) 玩玩吧！》，如需转载请与原作者联系。
ConvNext模型复现--CVPR2022
冲出仁川，走出马德里，故事还会再继续
09-06 1949
ConvNet和Vision Transformer的ImageNet分类结果。我们证明了标准的 ConvNet 模型可以实现与分层视觉 Transformer 相同的可扩展性，同时在设计上要简单得多。视觉识别的“咆哮的 20 年代”始于 Vision Transformers (ViTs) 的引入，它迅速取代了 ConvNets，成为最先进的图像分类模型。另一方面，普通的 ViT 在应用于目标检测和语义分割等一般计算机视觉任务时面临困难。
狗都能看懂的Vision Transformer的讲解和代码实现
个人学习笔记
01-24 4万+
狗都能看懂的Vision Transformer和代码复现
Vision Transformer（Pytorch版）代码阅读注释
HollowKnightz的博客
01-24 8252
Vision Transformer Pytorch版代码阅读注释
【神经网络】(21) Vision Transformer 代码复现，网络解析，附TensorFlow完整代码
博观而约取，厚积而薄发
05-16 5853
大家好，今天和各位分享一下如何使用 TensorFlow 构建 ViT B-16 模型。为了方便大家理解，代码使用函数方法。 1. 引言 在计算机视觉任务中通常使用注意力机制对特征进行增强或者使用注意力机制替换某些卷积层的方式来实现对网络结构的优化，这些方法都在原有卷积网络的结构中运用注意力机制进行特征增强。 而 ViT 依赖于原有的编码器结构进行搭建，并将其用于图像分类任务，在减少模型参数量的同时提高了检测准确度。 将 Transformer 用于图像分类任务主要有以下 5 个过程：（1）将输入图
Vision Transformer代码
分享计算机视觉，C++，网络摄像头研发，音视频开发，嵌入式等知识。
09-07 214
【代码】Vision Transformer代码。
Vision Transformer （ViT）初识：原理详解及代码
周红伟讲AI
03-12 1855
以ViT-B/16为例，使用一个卷积核大小为16x16，步距为16，卷积核个数为768的卷积来实现。通过卷积[224, 224, 3] -> [14, 14, 768]，然后把H以及W两个维度展平即可[14, 14, 768] -> [196, 768]，此时正好变成了一个二维矩阵，正是Transformer想要的。需要注意的是第一个全连接层会把输入节点个数翻4倍[197, 768] -> [197, 3072]，第二个全连接层会还原回原节点个数[197, 3072] -> [197, 768]
Vision Transformer(VIT)代码分析——保姆级教程
chase
10-16 7234
Vision Transformer(VIT)代码分析——保姆级教程
【ViT系列（2）】ViT（Vision Transformer）代码超详细解读（Pytorch）
路人贾的博客
07-21 9942
ViT（Vision Transformer）代码超详细解读
Vision Transformer 代码实现
周红伟讲AI
03-09 1227
最近开始恶补CV了（指->新建文件夹）。作为CV Transformer的开山大作，首先要学习的就是ViT（Vision Transformer）模型。有很多大佬都已经解读过这篇工作了，我比较推荐的视频，不仅能了解模型架构，还能学到些论文写作技巧。也参考了（代码是基于timm的） 本文代码基于，该项目包含了ViT和诸多变体。需要预训练模型的话可以参考ViT的架构ViT的结构如上图，我们按照流程一步步讲解。大概来说，ViT分为这几个步骤。1。
vision transformer代码
05-01
Vision Transformer是一种利用transformer架构处理计算机视觉问题的神经网络模型。其整体架构由一个嵌入层、若干个transformer编码层和一个输出层组成。 在代码实现方面，可以使用PyTorch等深度学习框架构建模型。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值