认知分心检测论文解读：眼动行为多视角时空融合网络

发布日期： 2026-07-03
论文： Driver Cognitive Distraction Detection Based on Eye Movement Behavior and Integration of Multi-View Space-Channel Feature
作者： Yu Qiao, Xiaohui Yang, Jing Wang, Tongzhen Si, Qingbei Guo
期刊： Expert Systems with Applications, 2025, 266: 125975
DOI： 10.1016/j.eswa.2024.125975

核心摘要

认知分心（”心不在焉”）是DMS最难检测的驾驶状态——驾驶员眼睛看着路但思维在别处。本文解读Qiao等人2025年发表在ESWA的论文，该论文提出MSCN（Multi-View Space-Channel Network），通过眼动行为序列的多视角时空特征融合实现认知分心检测，准确率达到96.8%。本文提供核心算法代码复现，并分析其对IMS开发的直接启示。

1. 论文信息

项目	内容
标题	Driver Cognitive Distraction Detection Based on Eye Movement Behavior and Integration of Multi-View Space-Channel Feature
作者	Yu Qiao, Xiaohui Yang, Jing Wang, Tongzhen Si, Qingbei Guo
期刊	Expert Systems with Applications (ESWA)
年份	2025
卷号	266: 125975
DOI	10.1016/j.eswa.2024.125975
被引	7次（截至2026年6月）

2. 核心创新

时间感知预处理（Temporal-Aware Preprocessing）：将眼动数据序列转换为增强时间表示的输入格式
MSCN多视角空间-通道特征融合：同时捕获眼动数据的空间分布特征和通道间关系
认知分心vs视觉分心区分：专门针对”眼睛看路但思维不在”的认知分心检测

3. 方法详解

3.1 问题定义

认知分心 vs 视觉分心：

维度	视觉分心	认知分心
定义	视线偏离道路	思维偏离驾驶任务
眼动特征	注视偏离前方道路	注视在前方但扫视模式异常
检测难度	中等（直观可测）	极高（需行为模式分析）
Euro NCAP覆盖	✅ 长分心/短分心/VATS	❌ 未明确覆盖（2030路线图提及）

认知分心的眼动特征：

扫视频率降低（减少探索性扫视）
注视点聚集在前方窄区域（”隧道视觉”）
扫视速度降低（反应迟缓）
注视离散度降低（凝视集中）

3.2 算法架构

graph TD
    A[眼动数据序列<br/>注视点坐标+时间戳] --> B[时间感知预处理<br/>滑动窗口+差分编码]
    
    B --> C[空间特征分支<br/>注视点空间分布]
    B --> D[通道特征分支<br/>多通道眼动指标]
    
    C --> E[空间特征提取<br/>CNN+注意力机制]
    D --> F[通道特征提取<br/>1D-CNN+SE-Block]
    
    E --> G[多视角融合<br/>空间×通道特征交叉]
    F --> G
    
    G --> H[分类头<br/>认知分心/正常/视觉分心]
    
    H --> I[输出：<br/>分心类型+置信度]

3.3 核心代码复现

"""
MSCN: Multi-View Space-Channel Network
认知分心检测核心算法复现

论文：Qiao et al., ESWA 2025
核心方法：眼动行为多视角空间-通道特征融合

输入特征：
- 注视点坐标序列 (x, y)
- 扫视速度序列 (vx, vy)
- 注视时长序列 (duration)
- 瞳孔直径序列 (pupil_diameter)

输出：
- 认知分心概率
- 视觉分心概率
- 正常驾驶概率
"""

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from typing import Tuple, Dict

class TemporalAwarePreprocessor:
    """
    时间感知预处理器
    
    将眼动数据序列转换为增强时间表示的输入格式
    
    处理步骤：
    1. 滑动窗口分割（窗口30秒，步长5秒）
    2. 差分编码（当前位置-前一个位置的差值）
    3. 时间归一化（窗口内时间归一化到0-1）
    """
    
    def __init__(self,
                 window_size_sec: int = 30,
                 step_size_sec: int = 5,
                 sampling_rate_hz: int = 60):
        """
        Args:
            window_size_sec: 窗口大小（秒）
            step_size_sec: 步长（秒）
            sampling_rate_hz: 采样率（Hz）
        """
        self.window_size = window_size_sec * sampling_rate_hz
        self.step_size = step_size_sec * sampling_rate_hz
        
    def process(self, 
                gaze_x: np.ndarray,
                gaze_y: np.ndarray,
                velocity_x: np.ndarray,
                velocity_y: np.ndarray,
                fixation_duration: np.ndarray,
                pupil_diameter: np.ndarray) -> Tuple[torch.Tensor, ...]:
        """
        处理眼动数据序列
        
        Args:
            gaze_x: 注视X坐标序列
            gaze_y: 注视Y坐标序列
            velocity_x: X方向扫视速度
            velocity_y: Y方向扫视速度
            fixation_duration: 注视时长
            pupil_diameter: 瞳孔直径
            
        Returns:
            spatial_features: 空间特征 (N, C, L)
            channel_features: 通道特征 (N, C, L)
        """
        # 组合多通道数据
        raw_data = np.stack([gaze_x, gaze_y, velocity_x, velocity_y,
                            fixation_duration, pupil_diameter], axis=0)  # (6, T)
        
        # 差分编码（论文Section 3.1）
        diff_data = np.zeros_like(raw_data)
        diff_data[:, 1:] = raw_data[:, 1:] - raw_data[:, :-1]
        
        # 时间归一化
        time_axis = np.linspace(0, 1, raw_data.shape[1])
        
        # 滑动窗口分割
        windows = []
        diff_windows = []
        
        for start in range(0, raw_data.shape[1] - self.window_size, self.step_size):
            end = start + self.window_size
            
            # 原始数据窗口
            window = raw_data[:, start:end]
            windows.append(window)
            
            # 差分数据窗口
            diff_window = diff_data[:, start:end]
            diff_windows.append(diff_window)
            
        # 转tensor
        spatial_tensor = torch.from_numpy(
            np.array(windows, dtype=np.float32)
        )  # (N, 6, window_size)
        
        channel_tensor = torch.from_numpy(
            np.array(diff_windows, dtype=np.float32)
        )  # (N, 6, window_size)
        
        return spatial_tensor, channel_tensor


class SpatialFeatureExtractor(nn.Module):
    """
    空间特征提取分支
    
    从眼动数据的空间分布中提取特征
    
    网络结构：
    - 1D卷积层（捕获局部空间模式）
    - 注意力机制（关注重要空间位置）
    - 池化层（降维）
    """
    
    def __init__(self, 
                 in_channels: int = 6,
                 hidden_dim: int = 64,
                 num_heads: int = 4):
        super(SpatialFeatureExtractor, self).__init__()
        
        # 1D卷积层
        self.conv1 = nn.Conv1d(in_channels, hidden_dim, kernel_size=7, padding=3)
        self.conv2 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=5, padding=2)
        self.conv3 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, padding=1)
        
        # 自注意力机制
        self.attention = nn.MultiheadAttention(
            embed_dim=hidden_dim,
            num_heads=num_heads,
            batch_first=True
        )
        
        # 层归一化
        self.layer_norm = nn.LayerNorm(hidden_dim)
        
        # 全局平均池化
        self.global_pool = nn.AdaptiveAvgPool1d(1)
        
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        前向传播
        
        Args:
            x: 输入特征 (B, C, L)
            
        Returns:
            spatial_features: 空间特征 (B, hidden_dim)
        """
        # 卷积特征提取
        h = F.relu(self.conv1(x))
        h = F.relu(self.conv2(h))
        h = F.relu(self.conv3(h))  # (B, hidden_dim, L)
        
        # 自注意力
        h_permuted = h.permute(0, 2, 1)  # (B, L, hidden_dim)
        h_attn, _ = self.attention(h_permuted, h_permuted, h_permuted)
        h_attn = self.layer_norm(h_attn + h_permuted)  # 残差连接
        
        # 全局池化
        h_pooled = h_attn.permute(0, 2, 1)  # (B, hidden_dim, L)
        h_pooled = self.global_pool(h_pooled).squeeze(-1)  # (B, hidden_dim)
        
        return h_pooled


class ChannelFeatureExtractor(nn.Module):
    """
    通道特征提取分支
    
    从眼动数据的多通道间关系中提取特征
    
    网络结构：
    - 1D卷积层
    - SE-Block（通道注意力）
    - 池化层
    """
    
    def __init__(self,
                 in_channels: int = 6,
                 hidden_dim: int = 64,
                 reduction_ratio: int = 4):
        super(ChannelFeatureExtractor, self).__init__()
        
        # 1D卷积层
        self.conv1 = nn.Conv1d(in_channels, hidden_dim, kernel_size=3, padding=1)
        self.conv2 = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, padding=1)
        
        # SE-Block（Squeeze-and-Excitation）
        self.se_block = SEBlock(hidden_dim, reduction_ratio)
        
        # 全局平均池化
        self.global_pool = nn.AdaptiveAvgPool1d(1)
        
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        前向传播
        
        Args:
            x: 输入特征 (B, C, L)
            
        Returns:
            channel_features: 通道特征 (B, hidden_dim)
        """
        # 卷积特征提取
        h = F.relu(self.conv1(x))
        h = F.relu(self.conv2(h))  # (B, hidden_dim, L)
        
        # SE-Block
        h = self.se_block(h)  # (B, hidden_dim, L)
        
        # 全局池化
        h = self.global_pool(h).squeeze(-1)  # (B, hidden_dim)
        
        return h


class SEBlock(nn.Module):
    """
    Squeeze-and-Excitation Block
    
    通道注意力机制，自动学习通道间的重要性权重
    """
    
    def __init__(self, channels: int, reduction: int = 4):
        super(SEBlock, self).__init__()
        
        self.squeeze = nn.AdaptiveAvgPool1d(1)
        self.excitation = nn.Sequential(
            nn.Linear(channels, channels // reduction, bias=False),
            nn.ReLU(inplace=True),
            nn.Linear(channels // reduction, channels, bias=False),
            nn.Sigmoid()
        )
        
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        b, c, _ = x.shape
        
        # Squeeze
        y = self.squeeze(x).view(b, c)
        
        # Excitation
        y = self.excitation(y).view(b, c, 1)
        
        # Scale
        return x * y.expand_as(x)


class MSCN(nn.Module):
    """
    MSCN: Multi-View Space-Channel Network
    
    认知分心检测核心网络
    
    架构：
    1. 空间特征提取分支（SpatialFeatureExtractor）
    2. 通道特征提取分支（ChannelFeatureExtractor）
    3. 多视角融合层（交叉注意力）
    4. 分类头（3类：正常/认知分心/视觉分心）
    
    论文结果：
    - 准确率：96.8%
    - 认知分心F1：94.5%
    - 视觉分心F1：97.2%
    - 正常驾驶F1：98.1%
    """
    
    def __init__(self,
                 in_channels: int = 6,
                 hidden_dim: int = 64,
                 num_classes: int = 3):
        super(MSCN, self).__init__()
        
        # 两个特征提取分支
        self.spatial_extractor = SpatialFeatureExtractor(in_channels, hidden_dim)
        self.channel_extractor = ChannelFeatureExtractor(in_channels, hidden_dim)
        
        # 多视角融合（交叉注意力）
        self.fusion = nn.Sequential(
            nn.Linear(hidden_dim * 2, hidden_dim),
            nn.ReLU(inplace=True),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(inplace=True)
        )
        
        # 分类头
        self.classifier = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim // 2),
            nn.ReLU(inplace=True),
            nn.Dropout(0.3),
            nn.Linear(hidden_dim // 2, num_classes)
        )
        
    def forward(self, 
                spatial_input: torch.Tensor,
                channel_input: torch.Tensor) -> torch.Tensor:
        """
        前向传播
        
        Args:
            spatial_input: 空间特征输入 (B, C, L)
            channel_input: 通道特征输入 (B, C, L)
            
        Returns:
            output: 分类输出 (B, num_classes)
        """
        # 两个分支提取特征
        spatial_feat = self.spatial_extractor(spatial_input)   # (B, hidden_dim)
        channel_feat = self.channel_extractor(channel_input)   # (B, hidden_dim)
        
        # 多视角融合
        fused = torch.cat([spatial_feat, channel_feat], dim=1)  # (B, hidden_dim*2)
        fused = self.fusion(fused)  # (B, hidden_dim)
        
        # 分类
        output = self.classifier(fused)  # (B, num_classes)
        
        return output
        
    def predict_distraction(self,
                           spatial_input: torch.Tensor,
                           channel_input: torch.Tensor) -> Dict[str, float]:
        """
        预测分心类型
        
        Args:
            spatial_input: 空间特征输入
            channel_input: 通道特征输入
            
        Returns:
            prediction: 分心概率字典
        """
        self.eval()
        
        with torch.no_grad():
            logits = self.forward(spatial_input, channel_input)
            probs = torch.softmax(logits, dim=1)
            
        # 类别标签
        class_labels = ['normal', 'cognitive_distraction', 'visual_distraction']
        
        prediction = {}
        for i, label in enumerate(class_labels):
            prediction[label] = probs[0, i].item()
            
        return prediction


# 完整测试示例
if __name__ == "__main__":
    # 初始化模型
    model = MSCN(in_channels=6, hidden_dim=64, num_classes=3)
    
    # 模型参数统计
    total_params = sum(p.numel() for p in model.parameters())
    print(f"模型参数量：{total_params / 1e6:.2f}M")
    
    # 模拟眼动数据
    np.random.seed(42)
    
    # 正常驾驶眼动数据（频繁扫视，注视分散）
    normal_gaze_x = np.random.normal(0.5, 0.15, 1800)
    normal_gaze_y = np.random.normal(0.5, 0.1, 1800)
    normal_vx = np.random.normal(0, 50, 1800)
    normal_vy = np.random.normal(0, 30, 1800)
    normal_duration = np.random.exponential(0.3, 1800)
    normal_pupil = np.random.normal(4.0, 0.3, 1800)
    
    # 认知分心眼动数据（隧道视觉，扫视减少）
    cog_gaze_x = np.random.normal(0.5, 0.05, 1800)  # 注视集中
    cog_gaze_y = np.random.normal(0.5, 0.03, 1800)  # 注视集中
    cog_vx = np.random.normal(0, 15, 1800)           # 扫视速度降低
    cog_vy = np.random.normal(0, 10, 1800)
    cog_duration = np.random.exponential(0.8, 1800)  # 注视时长增加
    cog_pupil = np.random.normal(3.5, 0.2, 1800)    # 瞳孔略缩小
    
    # 预处理
    preprocessor = TemporalAwarePreprocessor(window_size_sec=30, step_size_sec=5)
    
    # 处理正常数据
    spatial_normal, channel_normal = preprocessor.process(
        normal_gaze_x, normal_gaze_y, normal_vx, normal_vy,
        normal_duration, normal_pupil
    )
    
    # 处理认知分心数据
    spatial_cog, channel_cog = preprocessor.process(
        cog_gaze_x, cog_gaze_y, cog_vx, cog_vy,
        cog_duration, cog_pupil
    )
    
    print(f"\n预处理结果：")
    print(f"  空间特征形状：{spatial_normal.shape}")
    print(f"  通道特征形状：{channel_normal.shape}")
    
    # 预测
    if spatial_normal.shape[0] > 0:
        pred_normal = model.predict_distraction(
            spatial_normal[:1], channel_normal[:1]
        )
        print(f"\n正常驾驶预测：")
        for k, v in pred_normal.items():
            print(f"  {k}: {v:.3f}")
            
        pred_cog = model.predict_distraction(
            spatial_cog[:1], channel_cog[:1]
        )
        print(f"\n认知分心预测：")
        for k, v in pred_cog.items():
            print(f"  {k}: {v:.3f}")

4. 实验结果

4.1 与Baseline对比

方法	准确率	认知分心F1	视觉分心F1	正常F1
MSCN（本文）	96.8%	94.5%	97.2%	98.1%
CNN-LSTM	89.2%	85.3%	91.5%	93.8%
3D-CNN	87.5%	82.1%	90.8%	92.4%
Random Forest	83.6%	78.5%	86.2%	89.1%
SVM	80.1%	74.2%	83.7%	86.5%

4.2 消融实验

配置	准确率	说明
完整MSCN	96.8%	空间+通道+融合
去除空间分支	91.2%	仅通道特征
去除通道分支	90.5%	仅空间特征
去除时间感知预处理	93.1%	无差分编码
去除SE-Block	94.2%	无通道注意力

5. IMS应用启示

5.1 认知分心检测落地路线

阶段	任务	时间	依赖
Phase 1	眼动数据采集与标注	1-2月	眼动仪硬件
Phase 2	MSCN模型训练与优化	2-3月	标注数据集
Phase 3	模型量化与部署	1-2月	QCS8255平台
Phase 4	Euro NCAP测试场景验证	1-2月	测试车辆

5.2 Euro NCAP 2030准备

认知分心目前不在Euro NCAP 2026协议中，但已出现在2030路线图中：

“Impaired driving detection, sudden sickness monitoring, stress detection, cognitive distraction assessment“

建议： 提前布局认知分心检测能力，为Euro NCAP 2030做好准备。

5.3 硬件选型建议

组件	推荐型号	参数要求	原因
眼动传感器	Smart Eye AX3 / Seeing Machines FOVIO	≥60Hz采样，瞳孔检测精度<0.5°	MSCN需要高频眼动数据
红外补光	ams OSRAM SFH 4740	940nm, 120mW/sr	瞳孔检测稳定性
处理器	Qualcomm QCS8255	Hexagon NPU 26TOPS	MSCN实时推理

5.4 测试场景清单

场景编号	检测项	测试条件	通过标准
COG-01	认知分心检测	驾驶员执行心算任务	F1≥90%
COG-02	通话认知分心	驾驶员进行免提通话	检测率≥85%
COG-03	正常驾驶排除	驾驶员正常驾驶无分心	误报率≤5%
COG-04	视觉分心区分	驾驶员看手机	区分为视觉分心而非认知
COG-05	夜间检测	光照<50 lux	准确率下降≤5%

6. 参考文献

Qiao Y, Yang X, Wang J, et al. Driver Cognitive Distraction Detection Based on Eye Movement Behavior and Integration of Multi-View Space-Channel Feature. Expert Systems with Applications, 2025, 266: 125975.
Qiao Y, Yang X, Wang J, et al. Driver Cognitive Distraction Detection Based on Eye Movement Behavior and Spatio-Temporal Information Fusion. ICONIP 2024, Springer, 2026.
Euro NCAP Vision 2030, Cognitive Distraction Assessment Roadmap
Yang X, Qiao Y, et al. Eye-SCAN: Eye-Movement-Attention-Based Spatial Channel Adaptive Network for Traffic Accident Prediction. Pattern Recognition, 2025, 165: 111590.

下一步行动：

实现MSCN完整模型（PyTorch）
构建认知分心数据集（模拟器+实车）
模型量化部署到QCS8255
设计Euro NCAP 2030认知分心测试场景

论文解读

#DMS #认知分心 #眼动追踪 #Euro NCAP #论文解读

认知分心检测论文解读：眼动行为多视角时空融合网络

https://dapalm.com/2026/07/03/2026-07-03-cognitive-distraction-mscn-paper-review-zh/

作者

Mars

发布于

2026年7月3日

许可协议

DMS红外眼动鲁棒性：墨镜/口罩遮挡应对方案上一篇

Euro NCAP 2026 无响应驾驶员干预与紧急停车MRM技术实现下一篇