跨数据集视线估计：证据融合降低0.83°误差

研究背景

跨数据集视线估计的核心挑战：源域和目标域的分布差异导致性能下降。

传统方案局限

方案 问题
直接迁移 性能严重下降（误差增加50-100%）
域适应 需要大量目标域标注数据
联合训练 计算成本高，数据整合复杂

本文创新： 证据融合（Evidential Inter-intra Fusion, EIF）

核心创新：证据融合

两阶段训练框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
import torch
import torch.nn as nn
import torch.nn.functional as F

class EIFramework(nn.Module):
    """
    Evidence Inter-intra Fusion Framework
    
    两阶段：
    1. 单数据集训练：为每个数据集训练证据回归分支
    2. 跨数据集联合训练：融合各分支提升跨域泛化
    """
    
    def __init__(self, num_datasets=4, feature_dim=256):
        super().__init__()
        
        # 共享特征提取器
        self.encoder = ResNetEncoder(feature_dim)
        
        # 每个数据集一个证据回归分支
        self.evidence_heads = nn.ModuleList([
            EvidenceHead(feature_dim) for _ in range(num_datasets)
        ])
        
        # 融合层
        self.fusion = EvidentialFusion(num_datasets)
        
        self.num_datasets = num_datasets
    
    def forward(self, x, dataset_idx=None, return_evidence=False):
        """
        Args:
            x: (B, C, H, W) 输入图像
            dataset_idx: 数据集索引（训练时使用）
            return_evidence: 是否返回证据值
        
        Returns:
            gaze: (B, 2) 视线预测
        """
        
        # 特征提取
        features = self.encoder(x)
        
        if self.training:
            # 训练阶段：更新对应数据集的分支
            evidence = self.evidence_heads[dataset_idx](features)
            gaze = self.evidence_to_gaze(evidence)
            
            if return_evidence:
                return gaze, evidence
            return gaze
        
        else:
            # 推理阶段：融合所有分支
            all_evidence = []
            for head in self.evidence_heads:
                evidence = head(features)
                all_evidence.append(evidence)
            
            # 融合
            fused_evidence = self.fusion(all_evidence)
            gaze = self.evidence_to_gaze(fused_evidence)
            
            if return_evidence:
                return gaze, all_evidence
            return gaze
    
    def evidence_to_gaze(self, evidence):
        """
        从证据值计算视线
        
        证据理论：不确定性估计
        """
        
        # evidence: (B, 4) [e1, e2, e3, e4]
        # e1, e2: pitch方向的证据
        # e3, e4: yaw方向的证据
        
        pitch = torch.atan2(evidence[:, 1] - evidence[:, 0], 
                           evidence[:, 1] + evidence[:, 0])
        yaw = torch.atan2(evidence[:, 3] - evidence[:, 2],
                         evidence[:, 3] + evidence[:, 2])
        
        return torch.stack([pitch, yaw], dim=1)


class EvidenceHead(nn.Module):
    """
    证据回归头
    
    输出：证据值（用于不确定性估计）
    """
    
    def __init__(self, feature_dim):
        super().__init__()
        
        self.fc = nn.Sequential(
            nn.Linear(feature_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 4)  # 4个证据值
        )
    
    def forward(self, features):
        """
        Returns:
            evidence: (B, 4) 证据值（必须为正）
        """
        
        # 使用Softplus确保证据值为正
        return F.softplus(self.fc(features))


class EvidentialFusion(nn.Module):
    """
    证据融合
    
    核心思想：
    - 不同数据集的分支有不同的证据权重
    - 使用证据值作为权重进行融合
    """
    
    def __init__(self, num_sources):
        super().__init__()
        
        # 学习融合权重
        self.weight_net = nn.Sequential(
            nn.Linear(num_sources, 32),
            nn.ReLU(),
            nn.Linear(32, num_sources),
            nn.Softmax(dim=1)
        )
    
    def forward(self, evidence_list):
        """
        Args:
            evidence_list: List[(B, 4)] 各数据集的证据
        
        Returns:
            fused_evidence: (B, 4) 融合后的证据
        """
        
        # 计算每个证据的总证据量（不确定性度量）
        total_evidence = torch.stack([
            e.sum(dim=1) for e in evidence_list
        ], dim=1)  # (B, num_sources)
        
        # 学习融合权重
        weights = self.weight_net(total_evidence)  # (B, num_sources)
        
        # 加权融合
        stacked_evidence = torch.stack(evidence_list, dim=2)  # (B, 4, num_sources)
        weights_expanded = weights.unsqueeze(1)  # (B, 1, num_sources)
        
        fused = (stacked_evidence * weights_expanded).sum(dim=2)  # (B, 4)
        
        return fused


class EvidentialLoss(nn.Module):
    """
    证据损失函数
    
    组成：
    1. 负对数似然损失
    2. KL散度正则化
    """
    
    def __init__(self, lambda_kl=0.1):
        super().__init__()
        self.lambda_kl = lambda_kl
    
    def forward(self, evidence, gaze_gt):
        """
        Args:
            evidence: (B, 4) 证据值
            gaze_gt: (B, 2) 真实视线方向
        """
        
        # 计算参数
        alpha = evidence + 1  # Dirichlet参数
        
        # 计算均值
        pitch_alpha = alpha[:, :2]
        yaw_alpha = alpha[:, 2:]
        
        pitch_mean = (pitch_alpha[:, 1] - pitch_alpha[:, 0]) / pitch_alpha.sum(dim=1)
        yaw_mean = (yaw_alpha[:, 1] - yaw_alpha[:, 0]) / yaw_alpha.sum(dim=1)
        
        pred = torch.stack([pitch_mean, yaw_mean], dim=1)
        
        # 负对数似然
        nll_loss = F.mse_loss(pred, gaze_gt)
        
        # KL散度正则化（防止过拟合）
        kl_loss = self.kl_divergence(alpha)
        
        return nll_loss + self.lambda_kl * kl_loss
    
    def kl_divergence(self, alpha):
        """计算KL散度"""
        
        # 简化实现
        # 完整实现参见论文
        return alpha.sum(dim=1).mean()

实验结果

跨域性能对比

实验设置：

  • 源域：ETH-Gaze, MPIIGaze, Gaze360
  • 目标域：RT-GENE
  • 目标域样本：100个
方法 角度误差 (°) 改进
直接迁移 11.5 -
Fine-tuning 6.8 -4.7°
PCFGaze 5.9 -5.6°
EIF (本文) 5.07 -6.43°

消融实验

组件 误差 (°) 说明
完整模型 5.07 全部组件
单数据集训练 6.8 无融合
无证据加权 5.5 平均融合
无KL正则化 5.3 无正则化

IMS开发启示

1. 少样本域适应

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 部署配置
deployment_config = {
    'approach': 'evidential_fusion',
    'source_datasets': ['ETH-Gaze', 'MPIIGaze', 'Gaze360'],
    'target_adaptation': {
        'samples_needed': 100,  # 仅需100个样本
        'annotation_type': 'weak',  # 弱标注即可
        'adaptation_time': '< 1小时'
    },
    'performance': {
        'angle_error': '< 5.1°',
        'improvement': '0.83° vs baseline'
    }
}

2. 跨车型部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
### DG-02 EIF跨车型测试

**场景：**
- 模型在轿车A/B/C数据集训练
- 目标车型：新SUV车型

**样本需求：**
| 方法 | 需要样本数 | 标注强度 | 性能 |
|------|-----------|---------|------|
| Fine-tuning | 1000+ | 强标注 | 6.8° |
| Domain Adaptation | 500 | 弱标注 | 5.9° |
| **EIF** | **100** | **弱标注** | **5.1°** |

**部署流程：**
1. 在源车型数据集训练各证据分支
2. 收集100个目标车型样本
3. 联合训练融合层
4. 部署到新车型的ECU

3. 不确定性估计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 不确定性量化
def quantify_uncertainty(evidence):
    """
    从证据值计算不确定性
    
    应用：
    - 高不确定性场景降低信任度
    - 触发额外验证或人工介入
    """
    
    alpha = evidence + 1
    
    # 计算总证据量
    total_evidence = alpha.sum(dim=1)
    
    # 不确定性 = 1 / 总证据量
    uncertainty = 1.0 / total_evidence
    
    return uncertainty


# 使用示例
def adaptive_warning(gaze_pred, uncertainty, thresholds):
    """
    自适应警告策略
    
    高不确定性时提升警告阈值
    """
    
    if uncertainty > thresholds['high_uncertainty']:
        # 不确定性高，提升阈值避免误报
        adjusted_threshold = thresholds['base'] * 1.5
    else:
        adjusted_threshold = thresholds['base']
    
    return adjusted_threshold

参考文献

总结

EIF证据融合框架的核心优势：

  1. 少样本适应：仅需100个目标域样本
  2. 性能提升：角度误差降低0.83°
  3. 不确定性量化：证据理论支持可信度评估
  4. 实用性高：弱标注、快速训练

IMS开发优先级： 🔴 高优先级（解决跨车型部署核心痛点）

DMS算法 > 视线估计
#视线估计 #跨数据集 #证据融合 #域适应
跨数据集视线估计：证据融合降低0.83°误差
https://dapalm.com/2026/07/31/2026-07-31-cross-dataset-gaze-evidential-fusion/
作者
Mars
发布于
2026年7月31日
许可协议