SignFormer：基于Vision Transformer的静态手语识别模型解析与实战

1. 项目概述与核心价值

手语是听障人士与世界沟通的主要桥梁，但这座桥梁的另一端，往往站着因语言不通而手足无措的健听者。作为一名长期关注计算机视觉与辅助技术落地的从业者，我一直在寻找一种既能精准理解手语复杂空间语义，又能在实际部署中兼顾效率与准确性的技术方案。传统的卷积神经网络（CNN）在手语识别上已取得不少成果，但其固有的局部感受野特性，在理解手语这种高度依赖手部姿态、面部表情及身体方位等全局上下文信息的任务上，有时会显得力不从心。

近年来，Transformer架构及其核心的自注意力机制，在自然语言处理领域掀起革命后，正迅速向计算机视觉领域渗透。其“注意力即一切”的设计哲学，使其能无视距离地建模序列中任意两个元素之间的关系。当我们将一幅手语图像不再视为像素的二维网格，而是切割成一系列视觉“词汇”（图像块）的序列时，Transformer处理语言的能力便有了用武之地。这就是Vision Transformer（ViT）的核心思想，也是我们构建高效手语识别系统的钥匙。

本文要解析的，正是这样一个将ViT思想应用于静态印度手语识别的具体实践——SignFormer模型。这个项目的核心价值在于，它证明了基于纯Transformer的架构，无需复杂的预处理或特征工程，仅需极少的训练周期（例如5个epoch），就能在包含36个类别（数字0-9及部分字母）的静态印度手语数据集上达到99.29%的识别准确率。这不仅为开发低延迟、高精度的实时手语翻译应用提供了新的技术路径，也为资源受限的边缘设备部署带来了希望。无论你是刚入门深度学习的新手，还是正在寻找CV新范式的资深工程师，理解SignFormer的设计与实现，都能为你打开一扇通往视觉Transformer应用新世界的大门。

2. 核心思路：为何选择Vision Transformer？

在深入代码和结构之前，我们必须先厘清一个根本问题：为什么是Vision Transformer？在ResNet、EfficientNet等CNN模型大行其道的今天，转向一个源自NLP的架构需要充足的理由。SignFormer的选择，是基于对任务本质和模型特性的深刻匹配。

2.1 手语识别的核心挑战与CNN的局限

静态手语识别，看似是一个标准的图像分类问题，实则有其特殊性。一个手语手势的语义，并非由某个局部特征（如指尖）单独决定，而是手部整体形状、手指间的相对位置、手掌朝向以及手势在图像中的空间位置等多重信息共同作用的结果。

传统的CNN通过堆叠卷积层，逐步扩大感受野来捕获上下文信息。然而，这种捕获是间接且渐进的。浅层网络关注边缘、角落等局部特征，深层网络才能整合出更全局的语义。对于手语识别，我们需要模型从一开始就具备理解“拇指与食指的相对距离”和“手掌中心与图像边界的相对位置”这类全局关系的能力。CNN要做到这一点，要么需要非常深的网络（增加计算量和过拟合风险），要么需要引入额外的注意力模块或全局池化层。

更重要的是，CNN对图像平移、旋转等变化的等变性（equivariance）在图像分类中是优势，但在手语识别中，手势的绝对位置和方向可能本身就携带重要信息（例如，手势在胸前与在脸侧可能意义不同）。CNN的归纳偏置（局部性、平移等变性）在此处可能反而成为一种约束。

2.2 Transformer的自注意力机制：全局关系的直接建模

Transformer的核心——自注意力机制，恰好提供了解决方案。其计算公式虽简单，但威力巨大：

Attention(Q, K, V) = softmax(QK^T / √d_k) V

在这个公式中，查询（Q）、键（K）、值（V）都来自同一输入序列。对于图像块序列，自注意力允许序列中的每一个图像块（patch）直接与所有其他图像块进行交互，计算出一个“注意力分数”。这个分数决定了在整合信息时，当前块应该“关注”其他块的多少程度。

这意味着，模型在第一个Transformer层，就能让代表“拇指尖”的图像块与代表“食指尖”的图像块直接建立联系，无需经过多层卷积的缓慢传播。这种显式且高效的全局关系建模能力，是Transformer在处理手语这类强空间依赖任务时的先天优势。

2.3 SignFormer的设计哲学：轻量化与高效性

SignFormer论文的作者并没有盲目追求最庞大的ViT模型（如ViT-Huge）。相反，他们采取了务实且高效的轻量化设计：

1. 小尺寸输入：将图像统一缩放至72x72像素，远小于ImageNet经典的224x224。这大幅减少了后续计算量。
2. 适中的Patch大小：采用6x6的块大小，将一张图分割成(72/6)^2 = 144个图像块。这个数量在序列长度和每个块的信息粒度间取得了平衡。
3. 精简的编码器：仅使用4个Transformer编码器层，每层使用4个注意力头。这与原始ViT-Base的12层、12头相比，参数量和计算复杂度大大降低。
4. 聚焦静态识别：当前模型专注于静态图片分类，避免了动态序列建模的复杂性，使得模型结构更加简洁，训练更快收敛。

这种设计使得SignFormer在保持Transformer全局建模优点的同时，获得了极快的训练速度（仅需5个epoch）和较低的推理开销，为其在移动端或嵌入式设备上的应用奠定了基础。

注意：选择72x72的输入分辨率并非随意。一方面，它足以保留手语手势的关键细节；另一方面，这是经过权衡的结果。分辨率太低（如48x48）会丢失信息，太高（如96x96）会使序列长度变为(96/6)^2=256，显著增加自注意力计算量（计算复杂度与序列长度的平方成正比）。

3. 模型架构深度解析：从图像到分类结果

理解了“为什么”之后，我们来看“是什么”。SignFormer的架构是一个优雅的管道，将一张RGB图像一步步转化为一个类别标签。我们可以将其拆解为四个核心阶段：图像分块与嵌入、位置编码、多头自注意力编码、以及MLP分类头。

3.1 阶段一：图像分块与线性投影（Patch Embedding）

这是将图像“翻译”成Transformer能理解的“语言”的关键一步。Transformer原生处理的是1D的令牌（token）序列，如图中的单词。我们需要把2D图像转换成类似的序列。

具体操作如下：

1. 输入：一张形状为(72, 72, 3)的RGB图像。
2. 分块：将图像视为一个网格，用6x6的窗口（无重叠）进行扫描切割。图像高度和宽度都是72，窗口大小是6，因此会得到(72/6) * (72/6) = 12 * 12 = 144个图像块。
3. 展平：每个图像块的形状是(6, 6, 3)。将其展平成一个长度为6*6*3=108的1D向量。
4. 线性投影：这144个长度为108的向量，通过一个可训练的线性层（全连接层）进行映射。这个线性层将每个向量从108维投影到一个更高的、模型设定的隐藏维度D（例如768维，SignFormer中可能根据设计更小）。这个投影后的向量，就称为“块嵌入”（Patch Embedding）。

为什么这么做？线性投影的作用类似于一个学习到的特征提取器。它将原始的像素强度值，转换到另一个高维空间，在这个空间里，图像块之间的语义关系可能更容易被模型捕捉和学习。

3.2 阶段二：位置编码（Positional Encoding）

经过上一步，我们得到了144个彼此独立的块嵌入向量。但是，Transformer的自注意力机制本身是置换不变的，即打乱输入序列的顺序，输出序列的对应关系也会被打乱，但注意力机制本身无法感知原始的空间位置信息。对于图像来说，块的空间顺序至关重要。

解决方案是添加位置编码：

1. 生成位置索引：为144个块按光栅扫描顺序（从左到右，从上到下）分配一个绝对位置索引，从0到143。
2. 生成编码向量：通过一个可学习的位置嵌入查找表，将每个位置索引映射为一个与块嵌入同维度（D维）的向量。
3. 相加融合：将每个块嵌入向量与其对应的位置编码向量进行逐元素相加。这样，融合后的向量既包含了该图像块的视觉内容信息，也编码了其在原始图像中的绝对位置信息。

实操心得：在ViT的许多实现中，会在序列开头添加一个特殊的[class] token，其嵌入用于最终的分类。SignFormer的论文图示中似乎也包含了这一点。这个[class] token会与所有图像块交互，并在最后一层编码器的输出中，取其对应的向量作为整个图像的全局表示，送入分类器。这是一种常见且有效的设计。

3.3 阶段三：多头自注意力编码器（Multi-Head Self-Attention Encoder）

这是模型的核心计算单元。经过嵌入和位置编码的序列Z（形状：[144+1, D]，+1是[class] token）被送入由L个（SignFormer中为4个）相同层堆叠而成的Transformer编码器。

每一层编码器主要包含两个子层：

1. 多头自注意力层：
   • 线性变换：将输入Z通过三组不同的可训练权重矩阵W_q, W_k, W_v，分别投影生成查询（Q）、键（K）、值（V）矩阵。
   • 分头：将Q、K、V在特征维度D上切分成h个头（SignFormer中h=4）。每个头独立计算注意力，关注输入的不同子空间或不同方面的关系。
   • 缩放点积注意力：对每个头，计算Attention = softmax((Q_i * K_i^T) / √d_k) * V_i。这里d_k是每个头的维度（D/h）。除以√d_k是为了防止点积结果过大导致softmax梯度消失。
   • 合并：将h个头的输出在特征维度上拼接起来，再通过一个线性投影层W_o融合，得到多头注意力的最终输出。
2. 前馈网络：这是一个简单的两层MLP，通常中间包含一个非线性激活函数（如GELU或ReLU）。它对序列中每个位置的向量进行独立的、相同的变换，用于引入非线性并增强模型的表达能力。

残差连接与层归一化：每个子层（自注意力和前馈网络）都被一个残差连接包围，并且其输出会经过层归一化。即：输出 = LayerNorm(子层输入 + 子层函数(子层输入))。这是稳定深层Transformer训练的关键技术。

为什么需要多头？类比一下，当你看一幅手语图片时，你可能会同时关注“手型轮廓”、“指关节角度”、“与身体的相对位置”等多个方面。多头注意力机制模拟了这种并行处理不同信息子空间的能力。有的头可能专门学习手指间的局部关系，有的头则可能学习手势与图像边界的全局关系，最后再综合起来。

3.4 阶段四：MLP分类头

经过L层编码器的层层抽象和交互，我们得到了最终的序列表示。取序列第一个位置（即[class] token）对应的输出向量z_cls，它理论上聚合了所有图像块的信息，代表了整个图像的全局语义。

将这个z_cls向量输入一个多层感知机进行分类。SignFormer论文中使用了包含四个隐藏层的MLP。这是一个标准操作：输出 = Linear(ReLU(Linear(ReLU(Linear(ReLU(Linear(z_cls))))))最后一层Linear的输出神经元数量等于类别数（36），通过softmax函数即得到每个手语类别的预测概率。

4. 实战复现：从数据到训练的关键步骤

纸上得来终觉浅，绝知此事要躬行。理解了架构，我们来看看如何用代码（以PyTorch风格为例）将其实现，并成功训练起来。这里我会结合论文中的实验设置，补充一些关键的实操细节和我的经验。

4.1 数据准备与增强

数据集：论文使用了公开的静态印度手语数据集，包含数字0-9和部分字母，共36类，每类超过1000张图像。图像尺寸为480x320。

第一步：统一预处理

import torch from torchvision import transforms # 定义训练和验证的数据增强与预处理管道 train_transform = transforms.Compose([ transforms.Resize((72, 72)), # 统一缩放到72x72 transforms.RandomHorizontalFlip(p=0.5), # 随机水平翻转（模拟左右手） transforms.RandomRotation(degrees=(-10, 10)), # 随机旋转±10度 transforms.ColorJitter(brightness=0.2, contrast=0.2), # 颜色空间微调 transforms.ToTensor(), # 转为Tensor，并归一化到[0,1] transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # ImageNet统计量 ]) val_transform = transforms.Compose([ transforms.Resize((72, 72)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])

注意：虽然ViT论文提到可以在大数据集上从头训练，但对于中等规模的手语数据集，使用在ImageNet上预训练的归一化统计量（mean, std）是一个稳妥的起点，有助于稳定训练。随机水平翻转对于手语需谨慎，因为有些手势左右手不对称，但论文中使用了，说明其数据集可能已做镜像处理或手势本身对称。

第二步：实现Patch Embedding层这是自定义层，需要我们自己实现。

import torch.nn as nn class PatchEmbedding(nn.Module): def __init__(self, img_size=72, patch_size=6, in_channels=3, embed_dim=768): super().__init__() self.img_size = img_size self.patch_size = patch_size self.num_patches = (img_size // patch_size) ** 2 # 使用一个卷积层同时完成分块和投影，效率更高 self.projection = nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=patch_size) def forward(self, x): # x: [B, C, H, W] B, C, H, W = x.shape assert H == self.img_size and W == self.img_size, \ f`Input image size ({H}*{W}) doesn't match model ({self.img_size}*{self.img_size}).` # 卷积投影: [B, embed_dim, num_patches_h, num_patches_w] x = self.projection(x) # 展平空间维度: [B, embed_dim, num_patches] x = x.flatten(2) # 调整维度为Transformer期望的序列优先: [B, num_patches, embed_dim] x = x.transpose(1, 2) return x

4.2 构建SignFormer模型

现在，我们可以组装完整的SignFormer模型。为了精简，我们构建一个4层、4头的小型Transformer。

import torch.nn as nn import math class MultiHeadSelfAttention(nn.Module): def __init__(self, embed_dim, num_heads): super().__init__() assert embed_dim % num_heads == 0, "embed_dim must be divisible by num_heads" self.embed_dim = embed_dim self.num_heads = num_heads self.head_dim = embed_dim // num_heads self.qkv_proj = nn.Linear(embed_dim, embed_dim * 3) # 同时生成Q, K, V self.out_proj = nn.Linear(embed_dim, embed_dim) def forward(self, x): B, N, C = x.shape # N: 序列长度 (144+1) qkv = self.qkv_proj(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4) q, k, v = qkv[0], qkv[1], qkv[2] # 每个形状: [B, num_heads, N, head_dim] # 缩放点积注意力 attn_scores = (q @ k.transpose(-2, -1)) / math.sqrt(self.head_dim) # [B, num_heads, N, N] attn_probs = torch.softmax(attn_scores, dim=-1) attn_output = attn_probs @ v # [B, num_heads, N, head_dim] # 合并多头 attn_output = attn_output.transpose(1, 2).contiguous().view(B, N, C) output = self.out_proj(attn_output) return output class TransformerEncoderLayer(nn.Module): def __init__(self, embed_dim, num_heads, mlp_ratio=4.0, dropout=0.1): super().__init__() self.norm1 = nn.LayerNorm(embed_dim) self.attn = MultiHeadSelfAttention(embed_dim, num_heads) self.dropout1 = nn.Dropout(dropout) self.norm2 = nn.LayerNorm(embed_dim) mlp_hidden_dim = int(embed_dim * mlp_ratio) self.mlp = nn.Sequential( nn.Linear(embed_dim, mlp_hidden_dim), nn.GELU(), # 比ReLU更平滑，Transformer中常用 nn.Dropout(dropout), nn.Linear(mlp_hidden_dim, embed_dim), nn.Dropout(dropout) ) def forward(self, x): # 残差连接 + 层归一化 (Pre-Norm结构，更稳定) x = x + self.dropout1(self.attn(self.norm1(x))) x = x + self.mlp(self.norm2(x)) return x class SignFormer(nn.Module): def __init__(self, img_size=72, patch_size=6, in_channels=3, num_classes=36, embed_dim=384, depth=4, num_heads=4, mlp_ratio=4.0): super().__init__() self.patch_embed = PatchEmbedding(img_size, patch_size, in_channels, embed_dim) num_patches = self.patch_embed.num_patches # [class] token 和位置编码 self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) nn.init.trunc_normal_(self.pos_embed, std=0.02) # Transformer编码器堆叠 self.encoder_layers = nn.ModuleList([ TransformerEncoderLayer(embed_dim, num_heads, mlp_ratio) for _ in range(depth) ]) self.norm = nn.LayerNorm(embed_dim) # 分类头：四层MLP self.head = nn.Sequential( nn.Linear(embed_dim, 256), nn.ReLU(), nn.Dropout(0.3), nn.Linear(256, 128), nn.ReLU(), nn.Dropout(0.3), nn.Linear(128, 64), nn.ReLU(), nn.Linear(64, num_classes) ) self.apply(self._init_weights) def _init_weights(self, m): if isinstance(m, nn.Linear): nn.init.trunc_normal_(m.weight, std=0.02) if m.bias is not None: nn.init.constant_(m.bias, 0) elif isinstance(m, nn.LayerNorm): nn.init.constant_(m.bias, 0) nn.init.constant_(m.weight, 1.0) def forward(self, x): B = x.shape[0] # 生成块嵌入 x = self.patch_embed(x) # [B, num_patches, embed_dim] # 添加 [class] token cls_tokens = self.cls_token.expand(B, -1, -1) # [B, 1, embed_dim] x = torch.cat((cls_tokens, x), dim=1) # [B, num_patches+1, embed_dim] # 添加位置编码 x = x + self.pos_embed # 通过Transformer编码器 for layer in self.encoder_layers: x = layer(x) # 取 [class] token 对应的输出用于分类 x = self.norm(x) cls_output = x[:, 0] # [B, embed_dim] # 分类头 logits = self.head(cls_output) # [B, num_classes] return logits

4.3 训练策略与超参数设置

论文中强调仅用5个epoch就达到了高精度，这除了模型本身高效，也离不开精心设计的训练策略。

优化器与学习率：

import torch.optim as optim from torch.optim.lr_scheduler import CosineAnnealingLR model = SignFormer(embed_dim=384, depth=4, num_heads=4) criterion = nn.CrossEntropyLoss() # 使用AdamW优化器，它对权重衰减的处理更正确，是训练Transformer的标配 optimizer = optim.AdamW(model.parameters(), lr=3e-4, weight_decay=0.05) # 余弦退火学习率调度器，在5个epoch内从初始lr衰减到接近0，有助于快速收敛 scheduler = CosineAnnealingLR(optimizer, T_max=5, eta_min=1e-6)

训练循环关键点：

1. 梯度裁剪：在反向传播后、优化器更新前，加入torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)防止梯度爆炸，这对Transformer训练尤其重要。
2. 混合精度训练：如果硬件支持（如NVIDIA GPU），使用torch.cuda.amp进行自动混合精度训练，可以大幅减少显存占用并加快训练速度，几乎不影响精度。
3. 简单的数据增强：如代码所示，使用随机翻转、旋转和颜色抖动。对于手语数据，避免使用随机裁剪，因为手势在图像中的完整位置是关键信息。

一个epoch的训练步骤概览：

model.train() for images, labels in train_loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() # 混合精度训练上下文 with torch.cuda.amp.autocast(): outputs = model(images) loss = criterion(outputs, labels) # 缩放损失，反向传播，梯度裁剪，更新权重 scaler.scale(loss).backward() scaler.unscale_(optimizer) torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) scaler.step(optimizer) scaler.update() scheduler.step()

5. 实验结果分析与调优经验

按照论文描述，在80-20的训练-测试集划分下，仅训练5个epoch，SignFormer在36类静态印度手语数据集上达到了99.29%的测试准确率。这个结果非常亮眼，但我们在复现和将其应用于自己的项目时，需要深入分析其背后的原因，并了解如何调优。

5.1 关键实验结果解读

1. 注意力头数的影响：论文中的实验（对应原文Figure 6）表明，当注意力头数从1增加到2时，准确率提升不明显；但从2增加到4时，准确率有显著提升。这印证了“多头”机制的价值——不同的头可以学习到互补的注意力模式。然而，头数并非越多越好，超过一定数量（如8或12）可能会增加过拟合风险且提升有限，尤其是在小数据集上。对于类似规模的任务，4或8个头是一个不错的起点。

2. 训练集大小的影响：论文中对比了不同训练-测试划分比例（80-20, 70-30, 60-40）。结果显示，随着训练数据减少，准确率略有下降，但幅度不大。这说明SignFormer模型具有良好的数据效率，即使在数据量相对较少的情况下也能学到有效的特征。这对于收集和标注成本较高的手语数据集来说是一个巨大优势。

3. 背景鲁棒性：论文在“不同背景”下的实验表明，模型性能稳定。这得益于Transformer的全局注意力机制，它迫使模型关注手势主体本身（所有图像块间的关系），而不是依赖于固定的背景上下文。当然，这也与数据增强（如颜色抖动）有关。

4. 与CNN基线的比较：论文Figure 9将SignFormer与CNN、Fast R-CNN等模型对比，显示了其优势。核心优势不在于峰值准确率（大家可能都很高），而在于达到高准确率所需的训练周期极短。CNN通常需要数十甚至上百个epoch才能充分收敛，而SignFormer在5个epoch内就做到了。这意味着更快的模型迭代和更低的计算成本。

5.2 调优经验与避坑指南

在实际复现或迁移到其他手语数据集时，你可能会遇到一些问题。以下是我总结的一些经验：

问题一：训练不稳定，损失值震荡或NaN。

• 可能原因：学习率过高；初始化权重不合适；梯度爆炸。
• 解决方案：
  • 降低学习率：从较小的学习率开始尝试，如1e-4或3e-4。使用学习率预热（Warmup）策略，在前几个step或epoch内将学习率从0线性增加到设定值，这对Transformer训练非常有益。
  • 检查初始化：确保使用了类似上文代码中的_init_weights方法，对Linear层使用截断正态初始化，对LayerNorm初始化权重为1，偏置为0。
  • 强制梯度裁剪：如上文代码所示，设置max_norm=1.0或0.5。
  • 检查数据：确保输入数据没有NaN或无穷值，归一化操作正确。

问题二：模型收敛很快，但验证集准确率上不去（过拟合）。

• 可能原因：模型容量相对于数据集过大；数据增强不够；训练时间过长（虽然论文说5 epoch，但你的数据可能不同）。
• 解决方案：
  • 增强正则化：增大Dropout率（在MLP和注意力输出后），尝试Stochastic Depth（随机深度，在深模型中效果好）。
  • 强化数据增强：除了水平翻转和旋转，可以尝试MixUp或CutMix，这两种混合样本的数据增强对视觉Transformer防止过拟合非常有效。
  • 早停：密切监控验证集损失，当其在连续几个epoch内不再下降时，停止训练。
  • 减小模型：尝试减少embed_dim（如从384降到256）或depth（从4层降到3层）。

问题三：想提升模型最终精度。

• 可能原因：模型潜力未完全发挥；特征融合或分类头不够强。
• 解决方案：
  • 更精细的数据增强：使用AutoAugment或RandAugment等策略搜索适合手语数据的增强组合。
  • 知识蒸馏：如果有一个在更大数据集上预训练好的、更大的ViT模型（如DeiT），可以用它作为教师模型，来蒸馏训练我们的小型SignFormer，往往能提升性能。
  • 优化分类头：论文使用了4层MLP。可以尝试在最终分类层前加入SE（Squeeze-and-Excitation）注意力模块或轻量级的CBAM（Convolutional Block Attention Module），让模型在分类前重新校准特征通道的重要性。
  • 集成学习：训练多个不同随机种子初始化的SignFormer模型，对它们的预测结果进行平均（软投票），这是提升稳定性和精度的经典有效方法。

问题四：模型推理速度慢，无法满足实时性要求。

• 可能原因：自注意力计算复杂度与序列长度平方成正比。144个块已经带来不小的计算量。
• 解决方案：
  • 减少序列长度：这是最直接的方法。可以尝试增大patch_size（如从6增加到9或12），将序列长度从144减少到64或36。但这会损失细节信息，需要权衡。
  • 使用高效注意力变体：研究并集成诸如Linformer（低秩近似）、Performer（基于核的方法）或Swin Transformer（局部窗口+移位窗口）中的高效注意力机制到你的编码器层中。
  • 模型量化与剪枝：训练后，对模型进行动态量化或感知量化训练，将FP32权重转换为INT8，可以大幅减少模型体积和加速推理。也可以对注意力头或MLP中间层进行剪枝，移除不重要的参数。

核心心得：SignFormer的成功，很大程度上在于它用对了Transformer的“巧劲”。它没有追求极致的参数规模，而是通过精巧的设计（合适的patch大小、层数、头数），让自注意力机制在小型数据集上也能快速、有效地聚焦于手势的全局结构。复现时，首要任务是确保数据管道和模型前向传播正确，然后从小学习率开始，配合Warmup和Cosine衰减，通常就能观察到论文中描述的快速收敛现象。如果效果不佳，首先从数据质量和增强策略上找原因，其次是调整模型容量和正则化强度。