FantasticGNU/UniVAD项目中的Vision Transformer模型解析

2025-07-08 07:38:03作者：胡唯隽

概述

本文将深入解析FantasticGNU/UniVAD项目中使用的Vision Transformer(ViT)模型实现。ViT是一种将自然语言处理中成功的Transformer架构应用于计算机视觉任务的创新方法，它完全摒弃了传统CNN结构，直接处理图像块(patch)序列。

核心组件解析

1. DropPath机制

DropPath是一种正则化技术，也称为Stochastic Depth（随机深度）。它在训练过程中随机"丢弃"整个网络层，迫使网络学习更鲁棒的特征表示。

class DropPath(nn.Module):
    """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).
    """
    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)

2. 多层感知机(MLP)模块

MLP模块是Transformer中的标准组件，包含两个全连接层和GELU激活函数：

class Mlp(nn.Module):
    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
        super().__init__()
        out_features = out_features or in_features
        hidden_features = hidden_features or in_features
        self.fc1 = nn.Linear(in_features, hidden_features)
        self.act = act_layer()
        self.fc2 = nn.Linear(hidden_features, out_features)
        self.drop = nn.Dropout(drop)

3. 自注意力机制(Attention)

自注意力机制是Transformer的核心，它允许模型关注输入序列的不同部分：

class Attention(nn.Module):
    def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
        super().__init__()
        self.num_heads = num_heads
        head_dim = dim // num_heads
        self.scale = qk_scale or head_dim ** -0.5
        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
        ...

4. Transformer块(Block)

每个Transformer块包含自注意力层和前馈网络(MLP)，并应用了残差连接和层归一化：

class Block(nn.Module):
    def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
        super().__init__()
        self.norm1 = norm_layer(dim)
        self.attn = Attention(dim, ...)
        self.drop_path = DropPath(drop_path)
        self.norm2 = norm_layer(dim)
        self.mlp = Mlp(...)

图像到序列的转换

Vision Transformer需要将2D图像转换为1D序列，这是通过PatchEmbed模块实现的：

class PatchEmbed(nn.Module):
    """ Image to Patch Embedding """
    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
        super().__init__()
        num_patches = (img_size // patch_size) * (img_size // patch_size)
        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)

完整的Vision Transformer架构

VisionTransformer类整合了所有组件，构建完整的模型：

class VisionTransformer(nn.Module):
    def __init__(self, img_size=[224], patch_size=16, in_chans=3, num_classes=0, embed_dim=768, depth=12,
                 num_heads=12, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop_rate=0., attn_drop_rate=0.,
                 drop_path_rate=0., norm_layer=nn.LayerNorm, **kwargs):
        super().__init__()
        self.patch_embed = PatchEmbed(...)
        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
        self.pos_embed = nn.Parameter(...)
        self.blocks = nn.ModuleList([Block(...) for _ in range(depth)])
        self.norm = norm_layer(embed_dim)

模型变体

项目提供了三种不同规模的ViT模型变体：

ViT-Tiny: 小型模型，适用于资源受限环境
ViT-Small: 中等规模模型，平衡性能和计算成本
ViT-Base: 基础规模模型，提供更好的性能

def vit_tiny(patch_size=16, **kwargs):
    return VisionTransformer(patch_size=patch_size, embed_dim=192, depth=12, num_heads=3, ...)

def vit_small(patch_size=16, **kwargs):
    return VisionTransformer(patch_size=patch_size, embed_dim=384, depth=12, num_heads=6, ...)

def vit_base(patch_size=16, **kwargs):
    return VisionTransformer(patch_size=patch_size, embed_dim=768, depth=12, num_heads=12, ...)

DINO头部结构

DINOHead是一个特殊的投影头，用于自监督学习任务：

class DINOHead(nn.Module):
    def __init__(self, in_dim, out_dim, use_bn=False, norm_last_layer=True, nlayers=3, hidden_dim=2048, bottleneck_dim=256):
        super().__init__()
        # 构建多层MLP
        self.last_layer = nn.utils.weight_norm(nn.Linear(bottleneck_dim, out_dim, bias=False))