EyeCue：视线-视觉上下文交互的认知分心检测——首个无需EEG的纯视觉认知分心方案

论文信息

项目 内容
标题 EyeCue: Driver Cognitive Distraction Detection via Gaze-Empowered Egocentric Video Understanding
来源 arXiv 2605.07859
发表 2026年5月8日
链接 https://arxiv.org/abs/2605.07859
核心方法 视线+自我视角视频交互建模
优势 无需EEG、无需额外传感器、纯视觉

核心创新

  1. 纯视觉认知分心检测：不依赖EEG/ECG，仅用摄像头+视线
  2. 视线-视觉上下文交互：建模”看哪里”和”看什么”的关系
  3. 自我视角视频理解：从驾驶员第一人称视角理解注意力
  4. 隐式认知状态推断：通过视线模式反推认知状态

问题定义

认知分心vs视觉分心

类型 定义 检测方法 难度
视觉分心 眼睛离开道路 视线偏离检测 ✅ 容易
手动分心 手离开方向盘 手部检测 ⚠️ 中等
认知分心 思维离开驾驶任务 传统方法无法 🔴 极难

认知分心的”隐身”问题

表现 描述 传统检测
眼睛看路 但思维在别处 ❌ 视觉检测通过
方向盘稳定 自动驾驶模式 ❌ 行为检测通过
面部正常 无疲劳特征 ❌ 表情检测通过
视线凝视 凝视点固定但无扫描 ✅ EyeCue检测

方法详解

EyeCue架构

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
import torch
import torch.nn as nn
import numpy as np
from dataclasses import dataclass

@dataclass
class GazeContext:
    """视线-上下文交互特征"""
    gaze_point: np.ndarray    # 视线落点 (x, y)
    gaze_entropy: float       # 视线熵（扫描随机性）
    fixation_duration: float  # 凝视持续时间
    saccade_rate: float       # 扫视频率
    context_relevance: float  # 视觉上下文相关性

class GazeEncoder(nn.Module):
    """视线编码器"""
    
    def __init__(self, embed_dim: int = 128):
        super().__init__()
        self.gaze_embed = nn.Sequential(
            nn.Linear(4, 32),  # x, y, duration, entropy
            nn.ReLU(),
            nn.Linear(32, embed_dim)
        )
        self.temporal = nn.LSTM(
            embed_dim, 64, num_layers=2, batch_first=True
        )
    
    def forward(self, gaze_sequence):
        """
        Args:
            gaze_sequence: (B, T, 4) [x, y, duration, entropy]
        Returns:
            gaze_feat: (B, 64)
        """
        embedded = self.gaze_embed(gaze_sequence)
        out, _ = self.temporal(embedded)
        return out[:, -1]  # 最后一帧

class EgocentricVideoEncoder(nn.Module):
    """自我视角视频编码器"""
    
    def __init__(self, embed_dim: int = 128):
        super().__init__()
        # 轻量CNN
        self.cnn = nn.Sequential(
            nn.Conv2d(3, 16, 3, stride=2, padding=1),
            nn.ReLU6(),
            nn.Conv2d(16, 32, 3, stride=2, padding=1),
            nn.ReLU6(),
            nn.Conv2d(32, 64, 3, stride=2, padding=1),
            nn.ReLU6(),
            nn.AdaptiveAvgPool2d((4, 4)),
        )
        self.fc = nn.Sequential(
            nn.Linear(64 * 4 * 4, embed_dim),
            nn.ReLU()
        )
    
    def forward(self, frame):
        feat = self.cnn(frame)
        return self.fc(feat.flatten(1))

class CrossAttentionFusion(nn.Module):
    """视线-视觉上下文交叉注意力"""
    
    def __init__(self, dim: int = 64):
        super().__init__()
        self.gaze_proj = nn.Linear(dim, dim)
        self.video_proj = nn.Linear(128, dim)
        
        # 交叉注意力
        self.cross_attn = nn.MultiheadAttention(
            embed_dim=dim, num_heads=4, batch_first=True
        )
    
    def forward(self, gaze_feat, video_feat):
        g = self.gaze_proj(gaze_feat).unsqueeze(1)  # (B, 1, D)
        v = self.video_proj(video_feat).unsqueeze(1)  # (B, 1, D)
        
        # 视线关注视觉什么区域
        attn_out, _ = self.cross_attn(g, v, v)
        return attn_out.squeeze(1)

class EyeCueModel(nn.Module):
    """
    EyeCue完整模型
    
    架构：
    1. 视线编码（时序）
    2. 自我视角视频编码
    3. 交叉注意力融合
    4. 认知分心分类
    """
    
    def __init__(self, n_classes: int = 3):
        super().__init__()
        self.gaze_encoder = GazeEncoder()
        self.video_encoder = EgocentricVideoEncoder()
        self.fusion = CrossAttentionFusion(dim=64)
        
        self.classifier = nn.Sequential(
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Dropout(0.1),
            nn.Linear(32, n_classes)
        )
    
    def forward(self, gaze_sequence, video_frame):
        gaze_feat = self.gaze_encoder(gaze_sequence)
        video_feat = self.video_encoder(video_frame)
        fused = self.fusion(gaze_feat, video_feat)
        return self.classifier(fused)


# 认知分心指标计算
class CognitiveMetrics:
    """认知分心检测指标"""
    
    @staticmethod
    def gaze_entropy(gaze_points: np.ndarray) -> float:
        """
        计算视线熵
        
        高熵=广扫描=专注
        低熵=凝视固定=认知分心
        """
        hist, _ = np.histogram2d(
            gaze_points[:, 0], gaze_points[:, 1],
            bins=10, range=[[0, 1], [0, 1]]
        )
        hist = hist / hist.sum() + 1e-10
        return -np.sum(hist * np.log(hist))
    
    @staticmethod
    def saccade_rate(gaze_points: np.ndarray, fps: float = 30) -> float:
        """扫视频率（次/秒）"""
        if len(gaze_points) < 2:
            return 0
        diffs = np.diff(gaze_points, axis=0)
        distances = np.sqrt((diffs ** 2).sum(axis=1))
        saccades = (distances > 0.05).sum()
        return saccades / (len(gaze_points) / fps)
    
    @staticmethod
    def fixation_ratio(gaze_points: np.ndarray,
                        threshold: float = 0.02) -> float:
        """凝视比例"""
        if len(gaze_points) < 2:
            return 1.0
        diffs = np.diff(gaze_points, axis=0)
        distances = np.sqrt((diffs ** 2).sum(axis=1))
        fixations = (distances < threshold).sum()
        return fixations / len(distances)


# 测试
if __name__ == "__main__":
    model = EyeCueModel(n_classes=3)
    
    # 模拟输入
    gaze_seq = torch.randn(1, 30, 4)  # 30帧视线
    video_frame = torch.randn(1, 3, 224, 224)
    
    output = model(gaze_seq, video_frame)
    
    print("=== EyeCue认知分心检测 ===")
    print(f"输出: {output}")
    print(f"预测: {['专注', '轻度分心', '深度分心'][output.argmax(1).item()]}")
    
    # 认知指标测试
    metrics = CognitiveMetrics()
    
    # 专注驾驶：广扫描
    attentive_gaze = np.random.rand(100, 2)
    # 认知分心：凝视固定
    distracted_gaze = np.random.randn(100, 2) * 0.05 + 0.5
    
    print(f"\n=== 认知指标 ===")
    print(f"专注: 熵={metrics.gaze_entropy(attentive_gaze):.3f} "
          f"扫视={metrics.saccade_rate(attentive_gaze):.1f}/s "
          f"凝视={metrics.fixation_ratio(attentive_gaze):.2f}")
    print(f"分心: 熵={metrics.gaze_entropy(distracted_gaze):.3f} "
          f"扫视={metrics.saccade_rate(distracted_gaze):.1f}/s "
          f"凝视={metrics.fixation_ratio(distracted_gaze):.2f}")
    
    params = sum(p.numel() for p in model.parameters())
    print(f"\n参数: {params:,}")

实验结果

认知分心检测性能

方法 准确率 假阳性 假阴性 传感器
PERCLOS 62% 28% 18% 摄像头
EEG+EOG 91% 5% 8% 脑电+眼动
EyeCue 87% 8% 10% 仅摄像头

视线熵区分能力

状态 视线熵 扫视频率 凝视比例
专注驾驶 2.85 4.2/s 0.35
轻度分心 1.92 2.1/s 0.58
深度分心 0.85 0.8/s 0.82

关键发现

发现 描述
凝视固定≠专注 认知分心时视线凝视固定但思维在别处
视线熵下降 认知分心时视线熵从2.85→0.85
扫视消失 专注时4.2次/s扫视，分心时0.8次/s
上下文不相关 分心时视线落在路面但关注点在内心

IMS开发启示

1. 认知分心检测的突破

传统方案 EyeCue方案 优势
需EEG电极 仅DMS摄像头 无额外硬件
需驾驶员佩戴设备 无接触 用户体验
精度91% 精度87% 仅低4%
成本$200+ 成本$0（已有DMS） 免费

2. 与已有管道集成

组件 来源 角色
视线估计 DMS现有 输入
视频帧 DMS现有 输入
认知分心 EyeCue 分类
疲劳检测 自适应窗口(#13) 互补
LLM干预 #15 认知分心对话唤醒

3. Euro NCAP认知分心价值

Euro NCAP要求 EyeCue覆盖 得分潜力
D-01视线偏离 ✅ 1.0
D-02手机使用 ⚠️ 0.5
D-05认知分心 ✅ 突破 2.0
D-07走神 ✅ 1.0

总结

  1. 纯视觉认知分心检测突破：无需EEG，87%准确率
  2. 视线熵是关键指标：专注2.85→分心0.85，下降70%
  3. 扫视消失信号：专注4.2次/s→分心0.8次/s
  4. 零额外成本：复用已有DMS摄像头
  5. 填补Euro NCAP D-05空白：认知分心2分项
https://dapalm.com/2026/09/22/2026-09-22-19-eyecue-cognitive-distraction-gaze-visual-context-ims/
作者
Mars
发布于
2026年9月22日
许可协议