【Transformer专题】Vision Transformer（ViT）原理 + 代码

已于 2022-11-03 13:50:55 修改
阅读量8.2k 收藏 110
点赞数 12
分类专栏： # Transformers CV论文 文章标签： transformer ViT
于 2022-07-31 16:29:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38253797/article/details/126085344
版权

目录

前言

Vision Transformer是第一篇Transformer在CV领域的应用，论文地址：An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale

在视觉任务中，主要是利用到了Transformer中的Encoder模块，所以下面主要是关注这个模块。

我主要是看这个UP主学的：VIT (Vision Transformer) 模型论文+代码(源码)从零详细解读，看不懂来打我 他的Transformer系列讲的挺好的。

一、Transformer的Encoder

如果对Transformer理论不了解的可以看我的上一篇博客：【Transformer专题】一、Attention is All You Need（Transformer）

如下图所示：
Encode的输入：原始字符转换为数字，再转换为向量Input Embedding再和位置编码Positional Encoding对应位置相加，就得到了最终Encoder的输入。
Encoder = 多头注意力 + Add & Norm + Feed Forward（2个全连接层） + Add & Norm
在这里插入图片描述
那么怎么把一张图片融入到这个编码器Encoder当中呢？

直观是想法：把图片的每一个像素都拿出来，组成一个词向量，再个对应的位置编码相加，不就把一张图片送入Encoder了吗？

但是这样子会产生一个复杂度的问题：假设一张图片的输入是224x224，那么序列长度 = 224 * 224，参数量和计算量就太大了。

解决办法：把整张图片切分为一个个的patch，现在是一大块像素作为一个token（patch和token可以理解为一个东西）：

二、ViT整体架构

如图为整个ViT的架构，分为5个部分：

  1. 将图片切分为一个个的Token
  2. 将Token转化为Token Embedding
  3. 将Token Embedding 和 Position Embedding对应位置相加
  4. 输入到Transformer Encoder中
  5. Cls输出做多分类任务
    在这里插入图片描述

三、ViT的输入部分

3.1、图片切分为Token

输入x = [bs，3，224，224]

比如一张224x224x3的图片，切分为16x16个token，每个token是14x14大小，得到16x16x3=768个token。

3.2、Token转换为Token Embedding

  1. 将一个16x16x3=768个Token拉直，拉到一个1维，长度为768的向量 -> [bs，196，768]；
  2. 接一个Linear层，把768映射到Transormer Encode规定的Embedding Size（1024）的长度 -> [bs，196，1024]；

3.3、Token Embedding和Position Embedding对应位置相加

  1. 生成一个Cls对应的Token Embedding（对应图中的*部分） -> [bs，1，1024]；
  2. 生成所有序列的位置编码（包括Cls符号和和所有Token Embeding的位置编码 对应图中的0-9） -> [bs，197，1024]；
  3. 将Token Embedding和Position Embedding对应位置相加 -> [bs，197，1024]；

问题1：为什么要加一个Cls的符号呢？

Cls是在Bert中的用到的一个符号，NLP任务中的Cls可以在一定程度上让bert的两个任务保持一定的独立性，而在ViT中只有一个多分类任务，所以Cls符号并不是必须的；

而论文作者也做了实验证明了这点，在ViT的任务中，加Cls和不加Cls训练效果是差不多的，所以我认为可以不用；

问题2：为什么需要位置编码？
RNN在计算的时候是一个个的运算，具有一种天然时序关系，可以告诉模型哪些单词在前面，哪些单词在后面；但是在Transformer中它的单词是一起输入进去的，然后经过Attention层，那么如果没用位置编码，模型并不知道哪些单词在前面哪些单词在后面。

所以，我们需要给模型一个位置信息，告诉模型，哪些词/哪个token在前面，哪些词/token在后面。

问题3：为什么Token Embedding和Position Embedding是相加的？可不可以Concat?
这个问题好像没用什么很好的答案，Concat会让计算量翻倍？

从论文的实验结果可以发现，加入位置编码可以加3个点左右。位置编码是有用的。
在这里插入图片描述

四、Encoder部分

Encoder 输入：[bs，197，1024]

Transformer和ViT中的Encoder部分的区别：

  1. 把Norm层提前了；
  2. 没用Pad符号；
    在这里插入图片描述
    Encoder 输出：[bs，197，1024]

五、CLS多分类输出

最终得到每一个token都会得到一个1024的输出，再把第一个1024的向量拿出来，接一个全连接层进行多分类。
[bs，197，1024] -> 拿第一个[bs，1024] -> [bs，num_classes]

六、代码讲解

## from https://github.com/lucidrains/vit-pytorch
import torch
from torch import nn

from einops import rearrange, repeat
from einops.layers.torch import Rearrange


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


class PreNorm(nn.Module):
    # 在执行fn之前执行一个Layer Norm
    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)


class FeedForward(nn.Module):
    def __init__(self, dim, hidden_dim, dropout = 0.):
        super().__init__()
        # 前馈神经网络 = 2个全连接层
        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)


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   # 缩放因子

        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()

    def forward(self, x):
        # x: [bs, 197, 1024]   197 = 1个Cls + 196个patch  1024就是每一个patch需要转为1024长度的向量
        # self.to_qkv(x)将x向量映射到长度为1024*3
        # chunk: qkv 最后是一个元祖，tuple，长度是3，每个元素形状：[1, 197, 1024]
        # 直接用x配合一个Linear生成qkv，再切分为3块
        qkv = self.to_qkv(x).chunk(3, dim = -1)
        # 再把qkv分别拆分开来
        # q: [1, 16, 197, 64]  k: [1, 16, 197, 64]  v: [1, 16, 197, 64]
        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
        # q * k转置 除以根号d_k
        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
        # softmax得到每个token对于其他token的attention系数
        attn = self.attend(dots)
        # * v  [1, 16, 197, 64]
        out = torch.matmul(attn, v)
        # [1, 197, 1024]
        out = rearrange(out, 'b h n d -> b n (h d)')
        return self.to_out(out)


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):  # 堆叠多个Encoder  depth个
            self.layers.append(nn.ModuleList([
                # 每个encoder = Attention(Multi-Head Attention) + FeedForward(MLP)
                # PreNorm：指在fn(Attention/FeedForward)之前执行一个Layer Norm
                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


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)  # 得到多少个token  14x14=196
        patch_dim = channels * patch_height * patch_width  # 3x16x16 = 768  patch展平后的维度
        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),   # 把所有的patch拉平->768维
            nn.Linear(patch_dim, dim),                                                                  # 映射到encoder需要的维度768->1024
        )

        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))  # 生成所有token和Cls的位置编码
        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))   # 生成Cls的初始化参数
        self.dropout = nn.Dropout(emb_dropout)                  # embedding后面一般会接的一个Dropout

        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)   # encoder

        self.pool = pool
        self.to_latent = nn.Identity()

        self.mlp_head = nn.Sequential(   # CLS多分类输出部分
            nn.LayerNorm(dim),
            nn.Linear(dim, num_classes)
        )

    def forward(self, img):
        # img: [1, 3, 224, 224] x = [1, 196, 1024]
        # 生成每张图片的Patch Embedding
        # 图片的每一个通道切分为Token +  将3个channel的所有Token拉直，拉到一个1维，长度为768的向量 + 接一个线性层映射到encoder需要的维度768->1024
        x = self.to_patch_embedding(img)
        b, n, _ = x.shape  # b = 1   n = 196

        # 为每张图片生成一个Cls符号 [1, 1, 1024]
        cls_tokens = repeat(self.cls_token, '() n d -> b n d', b = b)
        # [1, 197, 1024]   将每张图片的Cls符号和Patch Embedding进行拼接
        x = torch.cat((cls_tokens, x), dim=1)
        # 初始化位置编码 再和(Cls和Patch Embedding)对应位置相加
        x += self.pos_embedding[:, :(n + 1)]
        # embedding后接一个Dropout
        x = self.dropout(x)

        # 将最终的Embedding输入Encoder  x: [1, 197, 1024]  -> [1, 197, 1024]
        x = self.transformer(x)

        # self.pool = 'cls' 所以取第一个输出直接进行多分类 [1, 1024]
        x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
        x = self.to_latent(x)  # 恒等映射 [1, 1024]

        # Cls Head 多分类 [1, cls_num]
        return self.mlp_head(x)


if __name__ == '__main__':
    v = ViT(
        image_size=224,  # 输入图像的大小
        patch_size=16,  # 每个token/patch的大小16x16
        num_classes=1000,  # 多分类
        dim=1024,  # encoder规定的输入的维度
        depth=6,  # Encoder的个数
        heads=16,  # 多头注意力机制的head个数
        mlp_dim=2048,  # mlp的维度
        dropout=0.1,  #
        emb_dropout=0.1  # embedding一半会接一个dropout
    )
    img = torch.randn(1, 3, 224, 224)
    preds = v(img)  # (1, 1000)

Reference

VIT (Vision Transformer) 模型论文+代码(源码)从零详细解读，看不懂来打我

满船清梦压星河HK
关注
  • 12
    点赞
  • 踩
  • 110
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
【Transformer】基于vision transformer（ViT）实现猫狗二分类项目实战
m0_51579041的博客
05-03 1313
【Transformer】基于vision transformer（ViT）实现猫狗二分类项目实战
CV攻城狮入门VIT(vision transformer)之旅——VIT原理详解篇
2401_84412194的博客
04-20 880
​  在上一篇，我已经详细为大家介绍了NLP邻域中的，足足写了10000+字，酝酿了好多天才下笔，也写了很久，自认为写的还算是通俗全面。如若你对Transformer还没什么了解，建议你点击☞☞☞了解详情。​  其实，作为CV程序猿的我们，学习NLP邻域的Transformer更像是被迫之举，毕竟现在基于Transformer的算法在CV邻域可谓是大杀特杀。那么今天我就为大家带来将Transformer引入到视觉物体分类中的一篇文章，标题为download📥📥📥。
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 ）数据集上进行了预训练。 我们提供用于微调 / 已发布模型的代码。 模型概述：我们将图像分割成固定大小的块，线性地嵌入每个块，添加位置嵌入，然后将所得的矢量序列馈送到标
详解视觉Transformers
u012374012的专栏
07-16 1546
从2017年在《Attention is All You Need》中首次提出以来，Transformer模型已经成为自然语言处理（NLP）领域的最新技术。在2021年，论文《An Image is Worth 16x16 Words》成功地将Transformer应用于计算机视觉任务。从那时起，基于Transformer的各种架构陆续被提出用于计算机视觉。Transformer是一种利用注意力机制作为主要学习机制的机器学习模型，它很快成为了序列到序列任务（如语言翻译）的最新技术。
Vision Transformer源码详解
m0_53374472的博客
11-10 1517
本篇文章主要分享视觉Transformer的Pytorch实现和代码细节问题,着重在于Vision Transfomer的Pytorch实现，
【ViT系列（2）】ViT（Vision Transformer）代码超详细解读（Pytorch）
路人贾的博客
07-21 9760
ViT（Vision Transformer）代码超详细解读
Encoder in Vision Transformer
weixin_46257458的博客
04-20 2183
梳理了vision transformer中的encoder部分
狗都能看懂的Vision Transformer的讲解和代码实现
热门推荐
个人学习笔记
01-24 4万+
狗都能看懂的Vision Transformer和代码复现
VIT(vision transformer)实现图像分类
05-29
VIT(vision transformer)实现图像分类，是将transformer首次应用于CV(计算机视觉)领域，该资源包含所有源代码，拿走技能运行跑通，包含数据集和训练好的权重，分类精度高达99%以上。
vision-transformer-pytorch:带有预训练模型的Pytorch版本的Vision Transformer（ViT）。 这是CASL（https
04-13
conda create --name vit --file requirements.txt conda activate vit 可用型号 我们提供，这些是从原始jax / flax wieghts转换而来的。 您可以下载它们并将文件放在“ weights / pytorch”下以使用它们。 否则，...
vit.zip视觉transformer代码
03-12
vision in transformer论文源码
ViT:实现Vi（sion）T（transformer）
05-26
在PyTorch中实现Vi（sual）T（transformer） 大家好，新年快乐！ 今天，我们将要实现著名的Vi （双） T （变压器），该产品在“。 代码在这里，可以从下载本文的交互式版本。 ViT将很快在我称为新计算机视觉库中提供 这是一个技术教程，而不是您在普通的中级文章中找到的使您变得富有的前5个最重要的熊猫功能。 因此，在开始之前，我强烈建议您： 看看惊人的网站 观看 阅读文档 因此，ViT使用在图像上工作的普通变压器（“提出的一种变压器）。 但是，如何？ 下图显示了ViT的体系结构 输入图像被分解为16x16展平的小块（图像未按比例绘制）。 然后使用普通的完全连接层将它们嵌入，在它们前面添加特殊的cls令牌，并对positional encoding求和。 生成的张量首先传递到标准Transformer，然后传递到分类头。 就是这样。 本文的结构分为以下几节
基于pytorch实现的 vision transformer的图像分类 完整代码+预训练权重【可直接运行 毕业设计】
最新发布
07-29
在本项目中，我们探讨了如何使用PyTorch框架中的Vision Transformer（ViT）进行图像分类。PyTorch是一个流行的深度学习库，它提供了丰富的功能和灵活性，非常适合进行复杂的模型开发，如Transformer架构。...
Vision Transformer详解（附代码）
欢迎来到道的世界
01-10 6462
 受NLP\mathrm{NLP}NLP中Transformer\mathrm{Transformer}Transformer扩展成功的启发，Vision Transformer\mathrm{Vision\text{ }Transformer}Vision Transformer又进一步体现了Transformer\mathrm{Transformer}Transformer在计算机视觉的重要性，它可以很好的地取代卷积操作。本文会详细讲解 ...
Vision Transformer代码讲解及复现
apodx的博客
04-03 2376
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__(
Vision Transformer （ViT）初识：原理详解及代码
weixin_46833029的博客
11-18 3409
CV 领域的 transformer : ViT (Vision transformer) 原理详解h和代码注释，及宝藏学习参考资源大全
Vision Transformer
不要錯過才珍惜
12-18 6184
Vision Transformer (ViT)，就在图像识别任务达到了不亚于 ResNet 的精度，并且相较于ResNet 训练所耗费的时间，VIT的训练所耗费的算了减少了一大部分。由于 ViT 模型是从在 NLP 领域特别火的 Transformer 模型改编而来，并且没有对Transformer 内部进行修改，ViT主要的改变就是在输入端，将图像进行了分块和降维，从而将图像变成一种类似于词语编码的表达方式，方便了后续处理。
vit和swin-vit输入图像大小
05-14
ViT（Vision Transformer）和Swin Transformer-based ViT（Swin-ViT）模型的输入大小是相对固定的，通常为224x224或256x256像素的图像。这是因为这些模型通常使用预训练的权重，这些权重是使用大型数据集（例如ImageNet）进行训练的。因此，为了与这些预训练权重兼容，输入图像的大小通常应该与训练数据集中的图像大小相似。当然，对于特定的任务和数据集，可以根据需要进行适当的调整。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值