AttentiveGaze：不确定性感知多模态视线估计如何提升DMS鲁棒性

论文信息

项目	内容
标题	AttentiveGaze: an uncertainty-aware multimodal feature fusion for robust gaze estimation
作者	Pooja Jigar Choksy, Heena Patel 等
机构	Akeso Eyecare (北京), EyelignAI (印度)
发表	Multimedia Tools and Applications, 2026
链接	https://link.springer.com/article/10.1007/s11042-026-21909-z

核心创新

AttentiveGaze 首次在视线估计中同时实现两个关键能力：

1. 自适应多模态融合 — 网络 dynamically 决定每时刻信任眼部纹理、面部上下文还是头部姿态
2. 逐样本不确定性预测 — 每个视线估计都附带置信度值，让下游系统知道”什么时候不该信”

这对DMS系统具有直接价值：当光照变差或驾驶员戴墨镜时，系统自动标记”低置信度”并触发保守策略。

1. 问题背景

1.1 现有视线估计的致命缺陷

问题	现状	后果
固定融合权重	眼/脸/头按固定比例组合	好条件时浪费，差条件时崩溃
无不确定性输出	模型永远”自信”	错误时无警告，制造假安心
OOD样本无感知	训练分布外样本静默失败	安全隐患
大模型延迟	追求SOTA精度	实时性不足

1.2 安全关键场景

一个DMS系统在疲劳驾驶员戴墨镜+侧头时静默误判为”注意力集中”——比没有DMS更危险，因为它制造了虚假安心。

2. 方法详解

2.1 架构总览

graph TD
    A[眼部裁剪图] --> B[注意力增强眼部特征提取]
    C[全脸图像] --> D[面部上下文特征]
    E[头部姿态估计] --> F[头姿特征]
    
    B --> G[跨模态注意力融合]
    D --> G
    F --> G
    
    G --> H[可学习门控]
    H --> I[多投嵌入式]
    I --> J[不确定性感知回归头]
    
    J --> K[视线方向 θ, φ]
    J --> L[置信度 σ²]
    
    style G fill:#ff9,stroke:#333
    style J fill:#f96,stroke:#333

2.2 注意力增强眼部特征提取

import torch
import torch.nn as nn

class AttentiveEyeEncoder(nn.Module):
    """
    AttentiveGaze眼部特征编码器
    
    核心设计:
    1. 空间注意力: 学习角膜缘边界、角膜反射等局部结构的权重
    2. 通道注意力: 学习哪些特征通道在当前条件下最有判别力
    
    当镜片反光/阴影遮挡时，注意力权重自动降低被污染区域的贡献
    """
    
    def __init__(self, in_channels: int = 3, feat_dim: int = 256):
        super().__init__()
        
        # CNN backbone
        self.backbone = nn.Sequential(
            nn.Conv2d(in_channels, 64, 3, padding=1),
            nn.BatchNorm2d(64), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(64, 128, 3, padding=1),
            nn.BatchNorm2d(128), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(128, 256, 3, padding=1),
            nn.BatchNorm2d(256), nn.ReLU(), nn.AdaptiveAvgPool2d((1, 1))
        )
        
        # 空间注意力
        self.spatial_att = nn.Sequential(
            nn.Conv2d(256, 1, kernel_size=1),
            nn.Sigmoid()
        )
        
        # 通道注意力
        self.channel_att = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Flatten(),
            nn.Linear(256, 16), nn.ReLU(),
            nn.Linear(16, 256), nn.Sigmoid()
        )
        
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        Args:
            x: 眼部裁剪图, shape=(B, 3, H, W)
        Returns:
            feat: 注意力加权特征, shape=(B, 256)
        """
        feat = self.backbone[:-1](x)  # (B, 256, H', W')
        
        # 空间注意力
        sp_weight = self.spatial_att(feat)
        feat_sp = feat * sp_weight
        
        # 通道注意力
        ch_weight = self.channel_att(feat_sp)
        feat_ch = feat_sp * ch_weight.view(-1, 256, 1, 1)
        
        # 全局池化
        out = feat_ch.mean(dim=(2, 3))  # (B, 256)
        return out


class CrossModalFusion(nn.Module):
    """
    跨模态注意力融合 + 可学习门控
    
    每个模态查询其他模态的互补信息，
    然后门控决定最终混合权重
    """
    
    def __init__(self, dim: int = 256):
        super().__init__()
        
        # 跨模态注意力 (Multi-Head)
        self.cross_attn = nn.MultiheadAttention(
            embed_dim=dim,
            num_heads=4,
            batch_first=True
        )
        
        # 可学习门控
        self.gate = nn.Sequential(
            nn.Linear(dim * 3, 3),
            nn.Softmax(dim=1)
        )
        
    def forward(
        self,
        eye_feat: torch.Tensor,
        face_feat: torch.Tensor,
        head_feat: torch.Tensor
    ) -> torch.Tensor:
        """
        Args:
            eye_feat: (B, 256) 眼部特征
            face_feat: (B, 256) 面部特征
            head_feat: (B, 256) 头姿特征
        
        Returns:
            fused: (B, 256) 融合特征
        """
        B = eye_feat.shape[0]
        
        # 堆叠为序列 (B, 3, 256)
        stacked = torch.stack([eye_feat, face_feat, head_feat], dim=1)
        
        # 跨模态注意力
        attn_out, _ = self.cross_attn(stacked, stacked, stacked)
        
        # 门控权重
        concat = torch.cat([eye_feat, face_feat, head_feat], dim=1)
        gate_weights = self.gate(concat)  # (B, 3)
        
        # 加权融合
        fused = (attn_out * gate_weights.unsqueeze(-1)).sum(dim=1)
        
        return fused


class UncertaintyGazeHead(nn.Module):
    """
    不确定性感知回归头
    
    输出视线方向 + 预测方差（不确定性）
    
    基于异方差回归 (Nix & Weigend, 1994):
    Loss = 0.5 * exp(-log_var) * ||pred - target||^2 + 0.5 * log_var
    
    高不确定性时 → exp(-log_var)小 → 数据损失权重低 → 模型不确定时不过拟合
    """
    
    def __init__(self, in_dim: int = 256):
        super().__init__()
        
        # 多投嵌入式 (Transformer风格)
        self.multi_head = nn.ModuleList([
            nn.Linear(in_dim, 64) for _ in range(4)
        ])
        
        # 回归头: 预测 (pitch, yaw, log_var)
        self.regressor = nn.Sequential(
            nn.Linear(64 * 4, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 3)  # pitch, yaw, log_var
        )
        
    def forward(self, x: torch.Tensor) -> tuple:
        """
        Returns:
            gaze: (B, 2) 视线方向 (pitch, yaw)
            uncertainty: (B,) 预测方差 (σ²)
        """
        # 多投投影
        heads = [head(x) for head in self.multi_head]
        cat = torch.cat(heads, dim=1)
        
        out = self.regressor(cat)
        gaze = out[:, :2]
        log_var = out[:, 2]
        uncertainty = torch.exp(log_var)
        
        return gaze, uncertainty


# 完整模型
class AttentiveGaze(nn.Module):
    """
    AttentiveGaze 完整模型
    
    自适应多模态融合 + 不确定性感知的实时视线估计
    """
    
    def __init__(self):
        super().__init__()
        self.eye_encoder = AttentiveEyeEncoder()
        self.face_encoder = AttentiveEyeEncoder()  # 可共享或独立
        self.head_encoder = nn.Sequential(
            nn.Linear(3, 64), nn.ReLU(),
            nn.Linear(64, 256)
        )
        self.fusion = CrossModalFusion()
        self.gaze_head = UncertaintyGazeHead()
        
    def forward(
        self,
        eye_img: torch.Tensor,
        face_img: torch.Tensor,
        head_pose: torch.Tensor
    ) -> tuple:
        """
        Args:
            eye_img: (B, 3, 64, 64) 眼部裁剪
            face_img: (B, 3, 128, 128) 全脸
            head_pose: (B, 3) 头部姿态 (pitch, yaw, roll)
        
        Returns:
            gaze: (B, 2) 视线方向
            uncertainty: (B,) 不确定性
        """
        eye_feat = self.eye_encoder(eye_img)
        face_feat = self.face_encoder(face_img)
        head_feat = self.head_encoder(head_pose)
        
        fused = self.fusion(eye_feat, face_feat, head_feat)
        gaze, uncertainty = self.gaze_head(fused)
        
        return gaze, uncertainty


# 训练损失函数
def heteroscedastic_loss(
    pred_gaze: torch.Tensor,
    true_gaze: torch.Tensor,
    log_var: torch.Tensor
) -> torch.Tensor:
    """
    异方差损失函数
    
    L = 0.5 * exp(-s) * ||pred - target||^2 + 0.5 * s
    
    其中 s = log(σ²)
    
    当模型不确定时 s↑ → exp(-s)↓ → 数据损失权重↓ → 正则项↑
    当模型确定时 s↓ → exp(-s)↑ → 数据损失权重↑
    """
    mse = (pred_gaze - true_gaze).pow(2).sum(dim=1)
    loss = 0.5 * torch.exp(-log_var) * mse + 0.5 * log_var
    return loss.mean()


# 测试
if __name__ == "__main__":
    model = AttentiveGaze()
    n_params = sum(p.numel() for p in model.parameters())
    print(f"AttentiveGaze 参数量: {n_params:,} ({n_params/1e6:.2f}M)")
    
    # 模拟输入
    eye = torch.randn(8, 3, 64, 64)
    face = torch.randn(8, 3, 128, 128)
    pose = torch.randn(8, 3)
    
    gaze, unc = model(eye, face, pose)
    print(f"视线: {gaze.shape}, 不确定性: {unc.shape}")
    print(f"平均不确定性: {unc.mean():.4f}")

2.3 不确定性建模原理

场景	眼部特征	融合策略	不确定性	DMS动作
良好光照+正脸	高质量	眼部权重高	σ²低 (~0.01)	正常监控
墨镜遮挡	退化	转向面部+头姿	σ²中 (~0.1)	保守策略
极端侧脸	严重退化	仅靠头姿	σ²高 (>0.5)	降级+告警
OOD样本	未知分布	门控失灵	σ²极高 (>1.0)	触发备份方案

3. 评估结果

3.1 基准测试

数据集	场景	AttentiveGaze	SOTA对比	特点
MPIIFaceGaze	笔记本摄像头	竞争性	~4.5°	自然光照条件
EyeDiap	室内+移动	竞争性	~5.2°	RGB+深度
GazeCapture	手机前置	竞争性	~6.8°	大规模自然采集

3.2 不确定性检测OOD

关键发现：不确定性分数能有效检测OOD样本

• 已知分布：平均σ² ≈ 0.02
• 戴墨镜：σ² ≈ 0.15 (7.5倍提升)
• 极端头部旋转：σ² ≈ 0.3 (15倍)
• 完全遮挡：σ² > 1.0 (50倍)

4. IMS开发启示

4.1 当前DMS的盲区

场景	当前DMS行为	应有行为
光照骤变	静默误判	标记低置信→保守策略
墨镜+疲劳	误判为清醒	高σ²→触发备份传感器
大幅侧头	视线估计失败	高σ²→降级+头姿兜底
手遮挡面部	完全失效	高σ²→声觉/座椅传感器

4.2 不确定性驱动的DMS决策架构

graph TD
    A[DMS摄像头] --> B[视线估计]
    C[头部姿态] --> B
    B --> D{不确定性 σ²}
    
    D -->|σ² < 0.05 高置信| E[正常DMS决策]
    D -->|0.05 ≤ σ² < 0.3 中置信| F[保守策略]
    D -->|σ² ≥ 0.3 低置信| G[降级模式]
    
    E --> H[疲劳/分心检测]
    F --> I[仅用PERCLOS+头姿]
    G --> J[切换雷达/座椅传感器]
    
    style D fill:#ff9,stroke:#333
    style G fill:#f96,stroke:#333

4.3 具体部署参数

参数	推荐值	依据
模型大小	<5MB	边缘部署约束
推理延迟	<10ms	30fps实时要求
σ²高阈值	0.3	OOD检测基准
σ²中阈值	0.05	良好条件上界
降级策略	PERCLOS+头姿	无眼部信号时的兜底
备份传感器	60GHz雷达	穿透遮挡

5. 与现有DMS方案对比

方案	精度	不确定性	鲁棒性	实时性	成本
AttentiveGaze	竞争性	✅ 逐样本	高	✅ 紧凑	低
传统CNN回归	略高	❌ 无	中	中	低
Transformer	略高	❌ 无	中	慢	中
深度集成	高	✅ 但昂贵	高	很慢	高
贝叶斯NN	中	✅ 但计算贵	高	慢	中

6. 总结

AttentiveGaze 的核心价值不在于精度提升，而在于 范式转变：

1. 从”永远自信”到”知道自己不知道” — 每个估计附带置信度
2. 从”固定融合”到”自适应门控” — 条件变化时自动调整
3. 从”静默失败”到”显式降级” — OOD检测+保守策略

对IMS团队的直接建议：

• 立即评估 现有视线估计器在墨镜/遮挡时的不确定性行为
• 原型实现 异方差损失函数，为现有模型添加σ²输出
• 设计 不确定性驱动的降级决策树
• 对标 Euro NCAP DMS鲁棒性测试场景（墨镜/侧脸/光照变化）

---

论文链接: https://link.springer.com/article/10.1007/s11042-026-21909-z