CASME数据集实战：微表情识别中的数据处理与模型优化指南

1次阅读

共计 3391 个字符，预计需要花费 9 分钟才能阅读完成。

CASME 作为微表情研究领域的基准数据集，包含 195 个视频样本（CASME II）和 98 个样本（CASME），采样率 200fps。实际使用中开发者常遇到三个典型问题：

小样本困境 ：原始视频平均仅含 1 - 2 个有效微表情片段，正样本不足导致模型易过拟合
时序特征敏感 ：微表情持续时间仅 0.5- 2 秒（对应 100-400 帧），传统 3D CNN 难以捕捉快速肌肉运动
标注不一致 ：AU（动作单元）标签存在主观差异，同一表情可能标注不同 AU 组合

光学流增强 ：
优点：保留肌肉运动物理特性，适合微表情的微小位移
实现：使用 TVL1 算法生成 x / y 方向光流场，叠加原始帧作为 3 通道输入
几何变换增强 ：
优点：计算成本低，适合实时处理
注意点：需限制旋转角度（±5°）和缩放比例（0.9-1.1），避免破坏微表情特征

3D CNN（如 I3D）：
优势：自然处理时空特征
缺陷：参数量大（约 12M），在小样本场景容易过拟合
Transformer（如 TimeSformer）：
优势：注意力机制适合长程依赖
缺陷：需要大量训练数据，原生架构在 CASME 上准确率仅 58.2%

import torch
from torch.utils.data import Dataset
import cv2

class CASME_Dataset(Dataset):
    def __init__(self, video_paths, labels, clip_len=16):
        """
        Args:
            clip_len: 时序切片长度（单位：帧）stride: 采样步长（建议设为 clip_len/2）"""
        self.clip_len = clip_len
        self.labels = labels

        # 预加载视频元数据
        self.video_metadata = []
        for path in video_paths:
            cap = cv2.VideoCapture(path)
            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
            self.video_metadata.append({
                'path': path,
                'length': frame_count
            })
            cap.release()

    def __getitem__(self, idx):
        """返回时序切片和标签"""
        metadata = self.video_metadata[idx]
        cap = cv2.VideoCapture(metadata['path'])

        # 随机采样起始帧
        start_frame = torch.randint(0, max(1, metadata['length']-self.clip_len), (1,))
        frames = []

        for i in range(self.clip_len):
            cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame+i)
            ret, frame = cap.read()
            if ret:
                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                frame = cv2.resize(frame, (112, 112))
                frames.append(frame)

        cap.release()
        frames = torch.from_numpy(np.array(frames)).permute(3,0,1,2)  # C,T,H,W

        return frames.float(), self.labels[idx]

class MicroExprNet(nn.Module):
    def __init__(self, num_classes):
        super().__init__()
        # 空间特征提取
        self.cnn = nn.Sequential(nn.Conv3d(3, 64, kernel_size=(1,3,3), padding=(0,1,1)),
            nn.BatchNorm3d(64),
            nn.ReLU(),
            nn.MaxPool3d((1,2,2)),

            nn.Conv3d(64, 128, kernel_size=(1,3,3), padding=(0,1,1)),
            nn.BatchNorm3d(128),
            nn.ReLU(),

            # 时序池化替代 3D 卷积
            nn.AdaptiveAvgPool3d((None, 1, 1))
        )

        # 时序建模
        self.lstm = nn.LSTM(
            input_size=128,
            hidden_size=64,
            num_layers=2,
            bidirectional=True
        )

        self.classifier = nn.Sequential(nn.Linear(128, 32),
            nn.Dropout(0.5),
            nn.Linear(32, num_classes)
        )

    def forward(self, x):
        # x: (B,C,T,H,W)
        B = x.shape[0]
        x = self.cnn(x).squeeze(-1).squeeze(-1)  # (B,C,T)
        x = x.permute(2,0,1)  # (T,B,C)

        _, (h_n, _) = self.lstm(x)
        h_n = h_n.permute(1,0,2).reshape(B, -1)  # (B, num_layers*2*hidden_size)

        return self.classifier(h_n)

关键参数说明 ：
– CNN 部分使用 2D 卷积 + 时序池化，相比 3D 卷积减少 83% 参数量
– LSTM 隐藏层设为 64 维，双向结构增强时序建模能力
– 分类器前加入 Dropout=0.5 防止过拟合

scaler = torch.cuda.amp.GradScaler()

for inputs, labels in train_loader:
    inputs = inputs.to(device)
    labels = labels.to(device)

    with torch.cuda.amp.autocast():
        outputs = model(inputs)
        loss = criterion(outputs, labels)

    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

实测效果 （RTX 3090）：
– 训练速度提升 1.8 倍
– 显存占用减少 37%

# 动态量化
model = torch.quantization.quantize_dynamic(model, {nn.Linear}, dtype=torch.qint8
)

# 保存量化模型
torch.jit.save(torch.jit.script(model), 'quantized_model.pt')

量化前后对比 ：
| 指标 | FP32 | INT8 |
|——|——|——|
| 模型大小 | 23MB | 6MB |
| 推理延迟 | 28ms | 11ms |
| 准确率 | 68.5% | 67.9% |

AU 合并策略 ：将相似肌肉运动的 AU 合并（如 AU1+AU2→前额区）
多标签训练 ：使用 BCEWithLogitsLoss 替代 CrossEntropyLoss

# 使用 PyAV 替代 OpenCV
import av
container = av.open(video_path)

# 按需解码关键帧
stream = container.streams.video[0]
stream.thread_type = 'AUTO'  # 启用多线程解码

for frame in container.decode(stream):
    frame = frame.to_ndarray(format='rgb24')

特征解耦训练 ：

# 添加域分类器
class DomainClassifier(nn.Module):
    def forward(self, x):
        return torch.mean(x, dim=1)  # 全局平均池化

# 使用梯度反转层（GRL）def backward(ctx, grad_output):
    return grad_output.neg()