ICCV2021|极简ViT：从零开始训练ImageNet上的Tokens-to-Token Vision Transformer

人工智能

2023-09-23 07:56:37

Tokens-to-Token ViT：革命性的视觉Transformer

引言

在计算机视觉领域，视觉Transformer (ViT) 正在取得长足进步，ViT 是一个强大的图像处理模型，在各种任务中都表现出色。然而，标准 ViT 的庞大参数数量和计算成本限制了其广泛使用。

Tokens-to-Token ViT 的创新

为了克服这些限制，研究人员开发了 Tokens-to-Token ViT (T2T-ViT)，它以更少的资源实现了与标准 ViT 相当的性能。T2T-ViT 的关键创新在于其独创的 tokens-to-token 结构：

直接操作 tokens： 与标准 ViT 将图像块投影到嵌入向量序列不同，T2T-ViT 直接对原始 tokens 进行操作，消除了 patch 嵌入阶段，从而显著减少了参数和计算量。
卷积投影： T2T-ViT 使用卷积层将图像块投影到低维表示，然后使用一系列 tokens-to-token 自注意力层对这些 tokens 进行处理。
长期依赖关系： 这些层捕获图像中 tokens 之间的长期依赖关系，无需额外的编码步骤。

ImageNet 上的卓越表现

在 ImageNet 数据集上从零开始训练时，T2T-ViT 表现出了令人印象深刻的性能：

与标准 ViT 媲美： T2T-ViT-Base 在 ImageNet 上实现了 81.3% 的 top-1 准确率，与 ViT-Base 相当。
参数和 MAC 减少： 然而，T2T-ViT-Base 的参数数量仅为 ViT-Base 的一半，MAC 仅为其三分之一。

优势和应用

T2T-ViT 的优势使其在以下领域具有广泛的应用前景：

资源效率： 较少的参数和 MAC 使 T2T-ViT 能够在资源受限的设备上部署，如移动设备和嵌入式系统。
推理速度快： 由于计算量低，T2T-ViT 具有更快的推理速度，这对于实时应用至关重要。
易于部署： T2T-ViT 的简洁设计简化了部署过程，使其更容易集成到各种应用程序中。

未来展望

T2T-ViT 为 ViT 的研究开辟了新的篇章。其高效的架构和令人印象深刻的性能使其成为各种计算机视觉任务的有力竞争者。随着技术的不断发展，我们期待着 T2T-ViT 在实际应用中取得更大的成功。

常见问题解答

T2T-ViT 和标准 ViT 之间有什么区别？ T2T-ViT 直接对原始 tokens 进行操作，而标准 ViT 将图像块投影到嵌入向量序列中。这导致 T2T-ViT 的参数和计算量减少。
T2T-ViT 在哪些任务中表现出色？ T2T-ViT 在图像分类、对象检测和语义分割等各种计算机视觉任务中都表现出色。
T2T-ViT 是否可以在资源受限的设备上部署？ 是的，T2T-ViT 的资源效率使其能够在资源受限的设备上部署，如移动设备和嵌入式系统。
T2T-ViT 如何与其他视觉 Transformer 相比较？ T2T-ViT 凭借其高效的架构和令人印象深刻的性能，在视觉 Transformer 中脱颖而出。
T2T-ViT 的未来发展方向是什么？ 随着技术的不断发展，我们期待着 T2T-ViT 在各种计算机视觉应用中取得更大的成功。

示例代码

以下是使用 Python 和 PyTorch 实现 T2T-ViT 的示例代码：

import torch
import torch.nn as nn

class T2T_ViT_Block(nn.Module):
    def __init__(self, dim, num_heads, mlp_dim, dropout=0.1):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.attn = nn.MultiheadAttention(dim, num_heads, dropout=dropout)
        self.norm2 = nn.LayerNorm(dim)
        self.mlp = nn.Sequential(
            nn.Linear(dim, mlp_dim),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(mlp_dim, dim),
        )

    def forward(self, x):
        x = x + self.attn(self.norm1(x), self.norm1(x), self.norm1(x))
        x = x + self.mlp(self.norm2(x))
        return x

class T2T_ViT(nn.Module):
    def __init__(self, image_size, patch_size, dim, num_heads, mlp_dim, num_layers, dropout=0.1):
        super().__init__()
        self.patch_embed = nn.Conv2d(3, dim, kernel_size=patch_size, stride=patch_size)
        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, dim))
        self.cls_token = nn.Parameter(torch.zeros(1, 1, dim))
        self.blocks = nn.Sequential(*[T2T_ViT_Block(dim, num_heads, mlp_dim, dropout) for _ in range(num_layers)])
        self.norm = nn.LayerNorm(dim)
        self.head = nn.Linear(dim, num_classes)

    def forward(self, x):
        x = self.patch_embed(x)
        B, C, H, W = x.shape
        x = x.flatten(2).transpose(1, 2)
        x = torch.cat([self.cls_token.expand(B, -1, -1), x], dim=1)
        x = x + self.pos_embed
        x = self.blocks(x)
        x = self.norm(x)
        cls_token = x[:, 0]
        x = self.head(cls_token)
        return x