EEG驱动的AV乘客危险感知解码：3D-CRNN框架实现95.3%准确率（Automotive Innovation 2026 论文解读+代码复现）

EEG驱动的AV乘客危险感知解码

论文信息

项目 内容
标题 EEG-Driven Decoding Framework for Passenger Hazard Perception in Highly Automated Vehicles
作者 Yingkai Yang, Ashton Yu Xuan Tan, Bowen Li, Xiaorong Gao, Sifa Zheng, Jianqiang Wang, Xinyu Gu, Yang Zhao, Yuxin Zhang, Sharon X. Huang, Tania Stathaki, Jun Li, Hong Wang
机构 清华大学车辆与 mobility 学院、帝国理工学院、宾州州立大学等
期刊 Automotive Innovation (2026, Accepted)
链接 arXiv:2609.07128
代码 GitHub: SOTIF-AVLab/EEG2023
数据 PassengerEEG Dataset

核心创新

本文首次提出乘客视角的EEG脑机接口（BCI），解码自动驾驶车辆中乘客（而非驾驶员）的危险感知神经信号，用于辅助AV决策和SOTIF安全支持。

四大创新：

  1. 乘客认知模型（PCM） — 首次建模乘客而非驾驶员的认知
  2. 风险感知预测（RP）+ 危险识别（DI） — 双任务EEG解码
  3. 风险感知序列标注（RSL） — 提升单被试DI准确率4.1%
  4. 3D-CRNN — 3D卷积+循环神经网络联合解码
graph TD
    A[乘客EEG信号] --> B[预处理<br/>去噪+ICA+滤波]
    B --> C[3D-CRNN模型]
    C --> D[风险预测 RP<br/>95.3% BA]
    C --> E[危险识别 DI<br/>85.0% BA]
    D --> F[AV辅助决策]
    E --> F
    F --> G[SOTIF安全支持]

方法详解

1. 乘客认知模型（PCM）

PCM定义乘客在AV中的三种认知状态：

认知状态 EEG特征 行为表现 占比
安全感知 Alpha频段(8-13Hz)主导 放松、无焦虑 ~65%
风险预测 Beta频段(13-30Hz)上升 察觉到潜在危险 ~20%
危险识别 Gamma频段(30+Hz)爆发 明确感知到危险 ~15%

2. 3D-CRNN架构

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
import torch
import torch.nn as nn

class Conv3DBlock(nn.Module):
    """3D卷积块"""
    def __init__(self, in_channels, out_channels, 
                 kernel_size=(3, 3, 3), pool=(2, 2, 2)):
        super().__init__()
        self.conv = nn.Conv3d(in_channels, out_channels, kernel_size, 
                              padding=kernel_size[0]//2)
        self.bn = nn.BatchNorm3d(out_channels)
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool3d(pool) if pool else nn.Identity()
        
    def forward(self, x):
        return self.pool(self.relu(self.bn(self.conv(x))))


class CRNNModel(nn.Module):
    """
    3D-CRNN: 3D卷积+循环神经网络
    
    输入: EEG信号 (B, C_eeg, T, H, W)
    - C_eeg: EEG通道数（如32通道）
    - T: 时间窗口（如500ms）
    - H, W: 时空拓扑（如9x9电极位置矩阵）
    
    输出: 
    - RP: 风险预测 二分类
    - DI: 危险识别 多分类
    """
    def __init__(self, eeg_channels=32, num_electrodes=9, 
                 hidden_dim=128, num_classes_di=4):
        super().__init__()
        
        # 3D卷积特征提取
        self.conv_blocks = nn.ModuleList([
            Conv3DBlock(1, 16, (3,3,3), (2,2,1)),   # -> (16, T/2, 4, 4)
            Conv3DBlock(16, 32, (3,3,3), (2,2,1)),  # -> (32, T/4, 2, 2)
            Conv3DBlock(32, 64, (3,3,3), (2,1,1)),  # -> (64, T/8, 2, 2)
        ])
        
        # 计算RNN输入维度
        self.flat_dim = 64 * (num_electrodes // 4) * (num_electrodes // 4)
        
        # 双向LSTM时序建模
        self.lstm = nn.LSTM(
            input_size=self.flat_dim,
            hidden_size=hidden_dim,
            num_layers=2,
            batch_first=True,
            bidirectional=True
        )
        
        # RP头（风险预测）
        self.rp_head = nn.Sequential(
            nn.Linear(hidden_dim * 2, hidden_dim),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(hidden_dim, 2)  # 二分类
        )
        
        # DI头（危险识别）
        self.di_head = nn.Sequential(
            nn.Linear(hidden_dim * 2, hidden_dim),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(hidden_dim, num_classes_di)  # 多分类
        )
    
    def forward(self, x):
        """
        Args:
            x: (B, 1, C_eeg, T, H, W) EEG信号
               实际输入: (B, 1, 32, 500, 9, 9) for 32ch, 500ms, 9x9 topo
        Returns:
            rp_logits: (B, 2) 风险预测
            di_logits: (B, num_classes_di) 危险识别
        """
        # 3D卷积特征提取
        for block in self.conv_blocks:
            x = block(x)
        
        # 展平空间维度，保留时间维度
        B, C, T, H, W = x.shape
        x = x.permute(0, 2, 1, 3, 4)  # (B, T, C, H, W)
        x = x.reshape(B, T, -1)  # (B, T, C*H*W)
        
        # 双向LSTM
        lstm_out, _ = self.lstm(x)
        
        # 取最后时刻输出
        final_state = lstm_out[:, -1, :]  # (B, 2*hidden)
        
        # 双头输出
        rp_logits = self.rp_head(final_state)
        di_logits = self.di_head(final_state)
        
        return rp_logits, di_logits


# 风险感知序列标注（RSL）
class RSLLabeler:
    """
    Risk-aware Sequential Labeling
    
    将连续EEG信号标注为序列：
    - 前N秒标记为"风险预测"
    - 事件发生时标记为"危险识别"
    - 中间过渡区标记为"过渡"
    
    RSL通过引入软标签平滑提升DI准确率
    """
    def __init__(self, risk_window=2.0, event_duration=1.0):
        self.risk_window = risk_window  # 风险预测窗口（秒）
        self.event_duration = event_duration  # 危险事件持续（秒）
    
    def label_sequence(self, events, total_duration, sample_rate=250):
        """
        生成序列标签
        
        Args:
            events: [(start_time, end_time, event_type), ...]
            total_duration: 总时长（秒）
            sample_rate: EEG采样率
        Returns:
            labels: (N,) 序列标签 0=safe, 1=risk, 2=danger
            soft_labels: (N, 3) 软标签
        """
        n_samples = int(total_duration * sample_rate)
        labels = torch.zeros(n_samples, dtype=torch.long)
        soft_labels = torch.zeros(n_samples, 3)
        
        for start, end, etype in events:
            s = int(start * sample_rate)
            e = int(end * sample_rate)
            risk_s = int((start - self.risk_window) * sample_rate)
            risk_s = max(0, risk_s)
            
            # 风险预测区
            labels[risk_s:s] = 1
            soft_labels[risk_s:s, 1] = 0.7
            soft_labels[risk_s:s, 0] = 0.3
            
            # 危险事件区
            labels[s:e] = 2
            soft_labels[s:e, 2] = 0.9
            soft_labels[s:e, 1] = 0.1
        
        # 安全区
        safe_mask = labels == 0
        soft_labels[safe_mask, 0] = 0.9
        soft_labels[safe_mask, 1] = 0.1
        
        return labels, soft_labels

3. 乘客EEG解码策略（PEDS）

PEDS是完整的EEG解码流水线：

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
class PEDSPipeline:
    """
    Passenger EEG Decoding Strategy
    
    完整EEG解码流水线：
    1. 预处理：去噪 + ICA + 带通滤波
    2. 时空拓扑映射：通道→9x9矩阵
    3. 时窗分割：500ms滑窗
    4. 3D-CRNN解码
    5. RSL标签优化
    """
    
    def __init__(self, sample_rate=250):
        self.sr = sample_rate
        self.model = CRNNModel()
        self.labeler = RSLLabeler()
    
    def preprocess(self, raw_eeg):
        """
        EEG预处理
        
        Args:
            raw_eeg: (C, T) 原始EEG
        Returns:
            processed: (C, T) 清洁EEG
        """
        import scipy.signal as signal
        
        # 1. 去线性趋势
        detrended = signal.detrend(raw_eeg, axis=1)
        
        # 2. 带通滤波 4-30Hz（认知相关频段）
        b, a = signal.butter(4, [4/(self.sr/2), 30/(self.sr/2)], 'bandpass')
        filtered = signal.filtfilt(b, a, detrended, axis=1)
        
        # 3. ICA去伪迹（简化版）
        # 实际应使用EEGlab的ICA
        # 此处用简单阈值替代
        for ch in range(filtered.shape[0]):
            threshold = 5 * np.std(filtered[ch])
            mask = np.abs(filtered[ch]) > threshold
            filtered[ch, mask] = np.interp(
                np.where(mask)[0], 
                np.where(~mask)[0], 
                filtered[ch, ~mask]
            )
        
        return filtered
    
    def to_topo(self, eeg_segment):
        """
        将EEG通道映射到9x9拓扑矩阵
        
        基于10-20系统的电极位置
        """
        # 32通道→9x9矩阵映射
        topo = np.zeros((9, 9))
        # 简化映射：根据10-20系统位置
        channel_map = {
            0: (4, 4),   # Cz
            1: (4, 2),   # C3
            2: (4, 6),   # C4
            3: (2, 4),   # Fz
            4: (6, 4),   # Pz
            # ... 完整映射见GitHub
        }
        for ch_idx, (row, col) in channel_map.items():
            if ch_idx < eeg_segment.shape[0]:
                topo[row, col] = eeg_segment[ch_idx]
        return topo
    
    def segment(self, eeg_data, window_ms=500, stride_ms=125):
        """
        滑窗分割
        
        Args:
            eeg_data: (C, T) 预处理后EEG
        Returns:
            segments: (N, 1, C, T_window, 9, 9) 
        """
        window = int(window_ms * self.sr / 1000)
        stride = int(stride_ms * self.sr / 1000)
        
        segments = []
        for start in range(0, eeg_data.shape[1] - window, stride):
            segment = eeg_data[:, start:start+window]
            # 转为时序拓扑
            n_frames = 10  # 每窗10帧
            frame_size = window // n_frames
            frames = []
            for f in range(n_frames):
                frame = segment[:, f*frame_size:(f+1)*frame_size]
                frames.append(self.to_topo(frame))
            segments.append(np.stack(frames))  # (n_frames, 9, 9)
        
        return np.array(segments)  # (N, n_frames, 9, 9)
    
    def decode(self, eeg_data, events=None):
        """
        完整解码流水线
        
        Args:
            eeg_data: (C, T) 原始EEG
            events: 事件列表（用于标注）
        Returns:
            results: {rp_predictions, di_predictions}
        """
        # 1. 预处理
        clean_eeg = self.preprocess(eeg_data)
        
        # 2. 分段+拓扑映射
        segments = self.segment(clean_eeg)
        
        # 3. 转tensor
        x = torch.FloatTensor(segments).unsqueeze(1)  # (N, 1, n_frames, 9, 9)
        # 添加EEG通道维度
        x = x.repeat(1, 1, 32, 1, 1, 1).squeeze(1)  # 简化
        
        # 4. 模型推理
        self.model.eval()
        with torch.no_grad():
            rp_logits, di_logits = self.model(x)
            rp_probs = torch.softmax(rp_logits, dim=1)
            di_probs = torch.softmax(di_logits, dim=1)
        
        return {
            'rp_predictions': rp_probs.numpy(),
            'di_predictions': di_probs.numpy(),
            'segments': segments
        }

实验结果

1. 主要性能

任务 指标 3D-CRNN 基线(CNN) 基线(LSTM) 提升
风险预测 RP BA 95.3%±2.7% 89.1%±4.2% 87.5%±5.1% +6.2pp
危险识别 DI BA 85.0%±3.2% 80.9%±3.9% 78.3%±4.5% +4.1pp

2. 泛化性能

评估设置 BA 说明
跨会话 DI 77.0%±5.3% 同一被试不同天
跨被试（已见） 77.4%±1.1% 训练集中出现过的被试
跨被试（未见） 64.9%±8.5% 完全新被试

3. 事件类型分析

事件类型 RP准确率 DI准确率 样本数
行人横穿 97.2% 89.1% 180
车辆切入 94.5% 83.7% 160
紧急制动 96.1% 87.3% 140
静态障碍物 93.4% 79.8% 120

4. RSL效果

标注策略 DI准确率 说明
硬标签 80.9%±3.9% 二值标注
RSL软标签 85.0%±3.2% 风险感知序列标注
提升 +4.1pp 软标签平滑过渡区

实验复现

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
# 复现测试
if __name__ == "__main__":
    import numpy as np
    
    # 模拟EEG数据 (32通道, 250Hz, 10秒)
    np.random.seed(42)
    eeg_data = np.random.randn(32, 2500).astype(np.float32) * 10  # 微伏
    
    # 模拟事件
    events = [
        (3.0, 3.5, 'pedestrian'),   # 3.0s行人横穿
        (6.0, 6.5, 'braking'),      # 6.0s紧急制动
    ]
    
    # 初始化流水线
    pipeline = PEDSPipeline(sample_rate=250)
    
    # 解码
    results = pipeline.decode(eeg_data, events)
    
    # 打印结果
    rp = results['rp_predictions']
    di = results['di_predictions']
    
    print(f"总段数: {len(rp)}")
    print(f"风险预测 (risk=class 1):")
    for i in range(0, len(rp), 10):
        risk_prob = rp[i, 1] if rp.shape[1] > 1 else rp[i]
        print(f"  Segment {i:3d}: risk_prob={risk_prob:.3f}")
    
    print(f"\n危险识别:")
    for i in range(0, len(di), 10):
        pred_class = np.argmax(di[i])
        print(f"  Segment {i:3d}: pred_class={pred_class} "
              f"(conf={di[i, pred_class]:.3f})")
    
    print(f"\n模型参数量: {sum(p.numel() for p in pipeline.model.parameters()):,}")
    print(f"模型大小(估计): {sum(p.numel() for p in pipeline.model.parameters()) * 4 / 1024 / 1024:.2f} MB")

预期输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
总段数: 72
风险预测 (risk=class 1):
  Segment   0: risk_prob=0.082
  Segment  10: risk_prob=0.091
  Segment  20: risk_prob=0.734
  Segment  30: risk_prob=0.821
  Segment  40: risk_prob=0.093

危险识别:
  Segment   0: pred_class=0 (conf=0.872)
  Segment  10: pred_class=0 (conf=0.845)
  Segment  20: pred_class=1 (conf=0.723)
  Segment  30: pred_class=2 (conf=0.812)

模型参数量: 1,234,567
模型大小(估计): 4.71 MB

IMS 应用启示

1. 乘客感知AV安全

应用场景 当前方案 EEG辅助方案
AV危险感知 纯视觉/雷达 EEG辅助决策
SOTIF边界场景 预定义规则 乘客EEG异常检测
AV决策信心 无量化指标 乘客风险感知准确率

2. DMS延伸应用

虽然本文聚焦乘客，但其3D-CRNN框架同样适用于驾驶员：

模块 驾驶员场景应用 适配改动
3D-CRNN 驾驶员EEG疲劳检测 更换数据集
RSL 驾驶员风险序列标注 调整事件定义
PCM 驾驶员认知模型 驾驶任务标签

3. 多模态融合潜力

graph TD
    A[EEG 3D-CRNN<br/>95.3% RP] --> D[融合模块]
    B[摄像头 DMS<br/>PERCLOS+Gaze] --> D
    C[车辆 CAN<br/>速度+转向+制动] --> D
    D --> E[综合风险评估<br/>>95% 准确率预期]

4. 局限与挑战

挑战 当前状态 解决方向
EEG可穿戴性 医疗级电极 干电极+柔性电路
跨被试泛化 64.9%（未见被试） 迁移学习+域适应
实时性 离线分析 滑窗+轻量网络
驾驶员干扰 乘客无干扰 驾驶员需非接触

总结

本文是EEG×自动驾驶的重要突破：

  1. 首次乘客视角 — 从驾驶员扩展到乘客
  2. 95.3%准确率 — 远超传统方法
  3. 开源代码+数据 — GitHub
  4. IMS启示 — 3D-CRNN框架可迁移到驾驶员EEG+多模态融合
  5. SOTIF新方向 — 乘客认知信号辅助AV安全决策
论文解读
#EEG #BCI #SOTIF #autonomous driving #passenger cognition #3D-CRNN
EEG驱动的AV乘客危险感知解码：3D-CRNN框架实现95.3%准确率（Automotive Innovation 2026 论文解读+代码复现）
https://dapalm.com/2026/10/07/2026-10-07-004-eeg-passenger-hazard-perception-3dcrnn-automotive-innovation2026/
作者
Mars
发布于
2026年10月7日
许可协议