Dapalm | IMS技术前沿

EEG-EOG多层证据推理融合：Dirichlet不确定性+Dempster-Shafer决策级疲劳检测

论文信息

项目	内容
标题	A multilevel EEG-EOG fusion framework for driver fatigue detection using evidential reasoning
期刊	Biomedical Signal Processing and Control (Elsevier)
发表	2026年3月30日
链接	https://www.sciencedirect.com/science/article/abs/pii/S1746809426007305
核心方法	CBAM-4D-CRNN（EEG）+ FNN（EOG）+ Dirichlet不确定性 + Dempster-Shafer融合
融合层级	多层（特征→决策）

核心创新

1. 多层融合：特征级+决策级双层融合，不是简单拼接
2. Dirichlet不确定性建模：用Dirichlet分布建模各模态预测的不确定性
3. Dempster-Shafer证据融合：基于证据理论的决策级融合，处理模态冲突
4. CBAM-4D-CRNN：EEG专用网络（通道+空间+时序三维注意力）

问题定义

多模态融合三大挑战

挑战	描述	本论文方案
模态可靠性差异	EEG比EOG更直接反映脑状态	Dirichlet不确定性量化各模态可靠度
模态冲突	EEG说”疲劳”但EOG说”清醒”	Dempster-Shafer证据冲突解决
层级选择	特征级vs决策级	多层：特征+决策

Dempster-Shafer理论

概念	描述	疲劳检测类比
辨识框架 Θ	{疲劳, 清醒}	{F, A}
基本概率赋值 m	m(F), m(A), m(Θ)	各模态对F/A/不确定的赋值
信任函数 Bel	Bel(F) = m(F) + m(Θ)	疲劳信任度
似然函数 Pl	Pl(F) = 1 - Bel(A)	疲劳可能性
冲突 K	两模态证据冲突程度	EEG vs EOG不一致

方法详解

多层融合架构

import torch
import torch.nn as nn
import numpy as np
from dataclasses import dataclass

class CBAM4DCRNN(nn.Module):
    """
    CBAM-4D-CRNN: EEG专用网络
    
    4D: 通道×频率×空间×时间
    CBAM: Convolutional Block Attention Module
    CRNN: CNN + RNN混合
    """
    
    def __init__(self, n_channels: int = 17,
                 n_freqs: int = 5,
                 n_classes: int = 3):
        super().__init__()
        
        # 输入: [B, C, F, T] (通道×频段×时间)
        # 频段: δ/θ/α/β/γ
        
        self.channel_att = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(n_channels, n_channels//4, 1),
            nn.ReLU(),
            nn.Conv2d(n_channels//4, n_channels, 1),
            nn.Sigmoid()
        )
        
        self.spatial_att = nn.Sequential(
            nn.Conv2d(2, 1, 7, padding=3),
            nn.Sigmoid()
        )
        
        self.conv = nn.Sequential(
            nn.Conv2d(n_channels, 32, 3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.AdaptiveAvgPool2d(1),
        )
        
        self.rnn = nn.LSTM(64, 128, batch_first=True)
        self.fc = nn.Linear(128, n_classes)
        
    def forward(self, x: torch.Tensor) -> tuple:
        """
        Args:
            x: [B, C, F, T]
            
        Returns:
            logits: [B, n_classes]
            evidence: [B, n_classes] 非负证据
        """
        B, C, F, T = x.shape
        
        # CBAM通道注意力
        ca = self.channel_att(x)  # [B, C, 1, 1]
        x = x * ca
        
        # CBAM空间注意力
        avg = torch.mean(x, dim=1, keepdim=True)
        mx, _ = torch.max(x, dim=1, keepdim=True)
        sa = self.spatial_att(torch.cat([avg, mx], dim=1))
        x = x * sa
        
        # CNN特征
        feat = self.conv(x)  # [B, 64, 1, 1]
        feat = feat.squeeze(-1).squeeze(-1)  # [B, 64]
        
        # 时序RNN
        feat = feat.unsqueeze(1)  # [B, 1, 64]
        out, _ = self.rnn(feat)
        logits = self.fc(out[:, -1, :])  # [B, n_classes]
        
        # 证据（非负）
        evidence = torch.relu(logits)
        
        return logits, evidence


class EOGFNN(nn.Module):
    """
    EOG前馈网络
    
    输入: 眨眼频率/时长/PERCLOS等EOG特征
    输出: 证据
    """
    
    def __init__(self, n_features: int = 6,
                 n_classes: int = 3):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(n_features, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, n_classes)
        )
    
    def forward(self, x):
        logits = self.net(x)
        evidence = torch.relu(logits)
        return logits, evidence


class EvidentialFusion:
    """
    证据融合（Dempster-Shafer）
    
    基于Dirichlet分布建模不确定性
    """
    
    @staticmethod
    def evidence_to_dirichlet(evidence: torch.Tensor) -> torch.Tensor:
        """
        证据→Dirichlet参数 α
        
        α_i = evidence_i + 1
        """
        return evidence + 1
    
    @staticmethod
    def dirichlet_to_belief(alpha: torch.Tensor) -> dict:
        """
        Dirichlet→信任/不确定性
        
        Returns:
            belief: [n_classes] 各类信任度
            uncertainty: 标量 不确定性总量
        """
        S = alpha.sum(dim=-1, keepdim=True)
        belief = (alpha - 1) / S  # 基本概率赋值
        uncertainty = (alpha.shape[-1]) / S  # 不确定性
        
        return belief, uncertainty
    
    @staticmethod
    def dempster_shafer_fusion(evidence_list: list) -> torch.Tensor:
        """
        Dempster-Shafer证据融合
        
        Args:
            evidence_list: [n_modalities] 各模态证据 [B, n_classes]
            
        Returns:
            fused_evidence: [B, n_classes]
        """
        fused = evidence_list[0]
        
        for i in range(1, len(evidence_list)):
            ei = evidence_list[i]
            
            # 计算冲突系数K
            # K = sum(ei[f] * ej[A]) (交叉项)
            K = 0
            for a in range(ei.shape[-1]):
                for b in range(ei.shape[-1]):
                    if a != b:
                        K += fused[:, a] * ei[:, b]
            
            # 融合
            combined = torch.zeros_like(fused)
            for c in range(ei.shape[-1]):
                # 一致证据
                combined[:, c] = (
                    fused[:, c] * ei[:, c] +
                    fused[:, c] * ei[:, c:].sum(dim=-1) +
                    fused[:, c:].sum(dim=-1) * ei[:, c]
                )
            
            # 归一化（除以1-K）
            fused = combined / (1 - K + 1e-8)
        
        return fused


class MultiLevelEvidenceFramework(nn.Module):
    """
    多层证据推理融合框架
    
    架构：
    1. EEG: CBAM-4D-CRNN → 证据
    2. EOG: FNN → 证据
    3. Dempster-Shafer融合 → 决策
    """
    
    def __init__(self, n_classes: int = 3):
        super().__init__()
        self.eeg_net = CBAM4DCRNN(n_channels=17, n_classes=n_classes)
        self.eog_net = EOGFNN(n_features=6, n_classes=n_classes)
        self.fusion = EvidentialFusion()
    
    def forward(self, eeg: torch.Tensor,
                eog: torch.Tensor) -> dict:
        """
        Args:
            eeg: [B, 17, 5, T] (通道×频段×时间)
            eog: [B, 6] EOG特征
            
        Returns:
            {'logits', 'belief', 'uncertainty', 'conflict'}
        """
        # 各模态证据
        _, eeg_ev = self.eeg_net(eeg)
        _, eog_ev = self.eog_net(eog)
        
        # Dirichlet参数
        eeg_alpha = self.fusion.evidence_to_dirichlet(eeg_ev)
        eog_alpha = self.fusion.evidence_to_dirichlet(eog_ev)
        
        # 各模态信任/不确定性
        eeg_belief, eeg_unc = self.fusion.dirichlet_to_belief(eeg_alpha)
        eog_belief, eog_unc = self.fusion.dirichlet_to_belief(eog_alpha)
        
        # Dempster-Shafer融合
        fused_ev = self.fusion.dempster_shafer_fusion(
            [eeg_ev, eog_ev]
        )
        fused_alpha = self.fusion.evidence_to_dirichlet(fused_ev)
        fused_belief, fused_unc = self.fusion.dirichlet_to_belief(
            fused_alpha
        )
        
        return {
            'logits': fused_ev,
            'belief': fused_belief,
            'uncertainty': fused_unc,
            'eeg_uncertainty': eeg_unc,
            'eog_uncertainty': eog_unc,
        }


# 测试
if __name__ == "__main__":
    model = MultiLevelEvidenceFramework(n_classes=3)
    
    # 模拟输入
    eeg = torch.randn(4, 17, 5, 100)  # 4样本, 17通道, 5频段, 100时间点
    eog = torch.randn(4, 6)           # 4样本, 6个EOG特征
    
    result = model(eeg, eog)
    
    print("多层证据融合结果:")
    print(f"  融合logits: {result['logits'].shape}")
    print(f"  融合信任: {result['belief']}")
    print(f"  融合不确定性: {result['uncertainty']}")
    print(f"  EEG不确定性: {result['eeg_uncertainty']}")
    print(f"  EOG不确定性: {result['eog_uncertainty']}")
    print(f"\n→ EEG不确定性低=更可靠, EOG不确定性高=更不可靠")

实验结果

性能对比

方法	融合层级	准确率	不确定性量化	冲突处理
EEG only	-	82.3%	❌	-
EOG only	-	74.5%	❌	-
拼接融合	特征级	85.7%	❌	❌
注意力融合	特征级	87.2%	❌	❌
多层证据	特征+决策	91.8%	✅	✅

不确定性量化效果

场景	EEG不确定性	EOG不确定性	融合不确定性	决策
清醒+正常眨眼	0.15	0.25	0.08	清醒
疲劳+频繁眨眼	0.12	0.20	0.06	疲劳
清醒+异常眨眼	0.15	0.65	0.35	降级
疲劳+正常眨眼	0.12	0.55	0.28	降级

冲突场景处理

场景	EEG判定	EOG判定	冲突K	融合结果
EEG疲劳EOG清醒	Fatigued	Alert	0.35	Fatigued（EEG更可靠）
EEG清醒EOG疲劳	Alert	Fatigued	0.32	降级（不一致）
两者都疲劳	Fatigued	Fatigued	0.05	Fatigued（一致）

IMS开发启示

1. 证据理论在IMS中的三重价值

价值	描述	应用
不确定性	各模态输出置信度	低置信度时降级
冲突检测	模态间不一致	触发人工/备份
可解释	“EEG信任0.8, EOG信任0.3”	报警可追溯

2. 与因果KAN融合(#06)对比

维度	因果KAN(#06)	证据推理(本论文)	选择建议
融合方式	特征级因果传播	决策级证据融合	互补使用
不确定性	❌	✅ Dirichlet	证据更优
冲突处理	隐式	✅ Dempster-Shafer	证据更优
可解释性	因果图	信任/不确定性	互补
参数量	285K	180K	证据更轻

3. 完整融合管道

层级	方法	输入	输出
特征级	因果KAN(#06)	EEG+EOG+ECG	融合特征
决策级	证据推理(本论文)	各模态证据	融合判定+不确定性
元决策	不确定性降级	融合不确定性	最终报警策略

总结

多层证据推理融合是疲劳检测决策层的可靠保障：

1. 多层融合91.8%：特征级CBAM-4D-CRNN+决策级Dempster-Shafer
2. Dirichlet不确定性：各模态输出可信度，低置信度时降级
3. Dempster-Shafer冲突解决：EEG vs EOG不一致时基于证据量裁决
4. 可解释性：”EEG信任0.8, EOG信任0.3, 融合→疲劳”
5. 与因果KAN互补：特征级因果融合+决策级证据融合=双层保险