自然杂志2024：EEG复杂度测量检测视频学习中的思维游离

Nature 2024：EEG复杂度测量检测视频学习中的思维游离

论文来源： Nature Scientific Reports
期刊： Scientific Reports, April 8, 2024
核心创新： EEG 复杂度指标 → 思维游离（Mind Wandering）检测

---

论文信息

项目	内容
标题	EEG complexity measures for detecting mind wandering during video-based learning
期刊	Nature Scientific Reports
日期	April 8, 2024
链接	https://www.nature.com/articles/s41598-024-58889-9

---

核心问题：思维游离与认知分心

思维游离定义：

思维游离（Mind Wandering）：
- 定义：注意力从当前任务转移到内部思维
- 表现：眼睛在看，但思维已游离
- 检测挑战：外部行为无明显变化

Euro NCAP 2026 关联：
- 思维游离 = 认知分心的核心机制
- 需要检测"目光在路但思维游离"的状态

---

EEG 复杂度测量方法

import numpy as np
from scipy.signal import hilbert
from scipy.stats import entropy

class EEGComplexityAnalyzer:
    """
    EEG 复杂度分析器
    
    Nature 2024 论文核心：
    思维游离时 EEG 复杂度变化
    
    关键指标：
    1. 多尺度熵（Multiscale Entropy）
    2. Lempel-Ziv复杂度
    3. Hurst指数
    """
    
    def __init__(self):
        pass
    
    def compute_multiscale_entropy(self, 
                                    eeg_signal: np.ndarray,
                                    scales: list = None,
                                    m: int = 2,
                                    r: float = 0.2) -> dict:
        """
        多尺度样本熵
        
        论文发现：
        思维游离时，小尺度熵降低，大尺度熵增加
        
        Args:
            eeg_signal: EEG 信号, shape=(N,)
            scales: 尺度列表（默认 1-20）
            m: 嵌入维度
            r: 相似度阈值（标准差的倍数）
        
        Returns:
            dict: {
                "mse_values": 各尺度熵值,
                "mse_trend": 熵值趋势,
                "mind_wandering_indicator": float
            }
        """
        if scales is None:
            scales = range(1, 21)
        
        mse_values = []
        
        for scale in scales:
            # 粗粒化
            coarse_grained = self._coarse_grain(eeg_signal, scale)
            
            # 样本熵
            sampen = self._sample_entropy(coarse_grained, m, r)
            mse_values.append(sampen)
        
        mse_values = np.array(mse_values)
        
        # 熵值趋势
        mse_trend = np.polyfit(scales, mse_values, 1)[0]  # 线性趋势
        
        # 思维游离指标
        # 论文发现：小尺度熵（scale 1-5）降低表示思维游离
        small_scale_entropy = np.mean(mse_values[:5])
        large_scale_entropy = np.mean(mse_values[-5:])
        
        # 思维游离时：小尺度熵低，大尺度熵高
        mind_wandering_indicator = large_scale_entropy - small_scale_entropy
        
        return {
            "mse_values": mse_values,
            "mse_trend": mse_trend,
            "small_scale_entropy": small_scale_entropy,
            "large_scale_entropy": large_scale_entropy,
            "mind_wandering_indicator": mind_wandering_indicator
        }
    
    def _coarse_grain(self, signal: np.ndarray, scale: int) -> np.ndarray:
        """粗粒化"""
        n = len(signal)
        coarse_len = n // scale
        
        coarse = np.zeros(coarse_len)
        for i in range(coarse_len):
            coarse[i] = np.mean(signal[i*scale:(i+1)*scale])
        
        return coarse
    
    def _sample_entropy(self, 
                        signal: np.ndarray,
                        m: int = 2,
                        r: float = 0.2) -> float:
        """样本熵"""
        n = len(signal)
        if n < m + 1:
            return 0.0
        
        # 标准化阈值
        std = np.std(signal)
        r_threshold = r * std
        
        # 构建 m 维向量
        vectors_m = np.array([signal[i:i+m] for i in range(n - m)])
        vectors_m1 = np.array([signal[i:i+m+1] for i in range(n - m - 1)])
        
        # 计算相似对数量
        def count_similar_pairs(vectors, threshold):
            count = 0
            for i in range(len(vectors)):
                for j in range(i+1, len(vectors)):
                    if np.max(np.abs(vectors[i] - vectors[j])) < threshold:
                        count += 1
            return count
        
        count_m = count_similar_pairs(vectors_m, r_threshold)
        count_m1 = count_similar_pairs(vectors_m1, r_threshold)
        
        if count_m == 0 or count_m1 == 0:
            return np.inf
        
        sampen = -np.log(count_m1 / count_m)
        return sampen
    
    def compute_lempel_ziv_complexity(self, eeg_signal: np.ndarray) -> float:
        """
        Lempel-Ziv 复杂度
        
        论文发现：
        思维游离时 LZ 复杂度增加
        
        Args:
            eeg_signal: EEG 信号
        
        Returns:
            lz_complexity: LZ 复杂度值
        """
        # 二值化
        mean_val = np.mean(eeg_signal)
        binary_signal = (eeg_signal > mean_val).astype(int)
        
        # LZ 复杂度计算
        n = len(binary_signal)
        c = 1  # 复杂度计数
        s = binary_signal[0]
        
        for i in range(1, n):
            # 检查当前序列是否是新模式
            current_subseq = binary_signal[:i+1]
            
            # 查找是否有重复模式
            found = False
            for j in range(i):
                if np.array_equal(binary_signal[j:i+1], current_subseq[j:i+1-j]):
                    found = True
                    break
            
            if not found:
                c += 1
        
        # 标准化
        lz_complexity = c * np.log2(n) / n
        
        return lz_complexity
    
    def compute_hurst_exponent(self, eeg_signal: np.ndarray) -> float:
        """
        Hurst 指数
        
        论文发现：
        思维游离时 Hurst 指数变化
        
        H < 0.5: 反持久性
        H ≈ 0.5: 随机
        H > 0.5: 持久性
        
        Args:
            eeg_signal: EEG 信号
        
        Returns:
            hurst_exponent: Hurst 指数
        """
        n = len(eeg_signal)
        
        # 累积偏差
        mean_val = np.mean(eeg_signal)
        cumulative_deviation = np.cumsum(eeg_signal - mean_val)
        
        # 范围
        R = np.max(cumulative_deviation) - np.min(cumulative_deviation)
        
        # 标准差
        S = np.std(eeg_signal)
        
        # Hurst 指数
        if S == 0:
            return 0.5
        
        H = np.log(R / S) / np.log(n)
        
        return H
    
    def detect_mind_wandering(self, eeg_signal: np.ndarray) -> dict:
        """
        检测思维游离
        
        综合多个复杂度指标
        
        Args:
            eeg_signal: EEG 信号
        
        Returns:
            dict: {
                "is_mind_wandering": bool,
                "confidence": float,
                "mse_indicator": float,
                "lz_complexity": float,
                "hurst": float
            }
        """
        # 多尺度熵
        mse_result = self.compute_multiscale_entropy(eeg_signal)
        
        # LZ 复杂度
        lz = self.compute_lempel_ziv_complexity(eeg_signal)
        
        # Hurst 指数
        hurst = self.compute_hurst_exponent(eeg_signal)
        
        # 思维游离判断
        # 论文发现：
        # 1. MSE 小尺度熵降低
        # 2. LZ 复杂度增加
        # 3. Hurst 指数偏离 0.5
        
        is_mind_wandering = (
            mse_result["mind_wandering_indicator"] > 0.5 and
            lz > 0.8 and
            abs(hurst - 0.5) > 0.1
        )
        
        confidence = (
            mse_result["mind_wandering_indicator"] * 0.4 +
            lz * 0.3 +
            abs(hurst - 0.5) * 0.3
        )
        
        return {
            "is_mind_wandering": is_mind_wandering,
            "confidence": confidence,
            "mse_indicator": mse_result["mind_wandering_indicator"],
            "lz_complexity": lz,
            "hurst": hurst,
            "mse_values": mse_result["mse_values"]
        }


# 测试示例
if __main__ == "__main__":
    analyzer = EEGComplexityAnalyzer()
    
    # 模拟专注状态 EEG
    np.random.seed(42)
    focused_eeg = np.random.normal(0, 1, 1000) + 0.5 * np.sin(np.arange(1000) / 10)
    
    # 模拟思维游离 EEG
    wandering_eeg = np.random.normal(0, 1.5, 1000)  # 更随机
    
    print("=== 专注状态 ===")
    focused_result = analyzer.detect_mind_wandering(focused_eeg)
    print(f"思维游离: {focused_result['is_mind_wandering']}")
    print(f"置信度: {focused_result['confidence']:.3f}")
    print(f"MSE 指标: {focused_result['mse_indicator']:.3f}")
    print(f"LZ 复杂度: {focused_result['lz_complexity']:.3f}")
    print(f"Hurst 指数: {focused_result['hurst']:.3f}")
    
    print("\n=== 思维游离 ===")
    wandering_result = analyzer.detect_mind_wandering(wandering_eeg)
    print(f"思维游离: {wandering_result['is_mind_wandering']}")
    print(f"置信度: {wandering_result['confidence']:.3f}")
    print(f"MSE 指标: {wandering_result['mse_indicator']:.3f}")
    print(f"LZ 复杂度: {wandering_result['lz_complexity']:.3f}")
    print(f"Hurst 指数: {wandering_result['hurst']:.3f}")

---

DMS 认知分心检测应用

融合 EEG + 眼动

class CognitiveDistractionEEGFusion:
    """
    EEG + 眼动融合认知分心检测
    
    结合 Nature 2024 EEG 复杂度 +
    ScienceDirect 2024 眼动熵
    """
    
    def __init__(self):
        self.eeg_analyzer = EEGComplexityAnalyzer()
        self.eye_entropy_threshold = 0.6
    
    def detect_cognitive_distraction(self, 
                                       eeg_signal: np.ndarray,
                                       eye_entropy: float) -> dict:
        """
        多模态认知分心检测
        
        Args:
            eeg_signal: EEG 信号
            eye_entropy: 眼动熵
        
        Returns:
            dict: {
                "is_cognitive_distraction": bool,
                "confidence": float,
                "eeg_indicator": float,
                "eye_indicator": float,
                "fusion_method": str
            }
        """
        # EEG 思维游离检测
        eeg_result = self.eeg_analyzer.detect_mind_wandering(eeg_signal)
        
        # 眼动分心检测
        eye_distraction = eye_entropy > self.eye_entropy_threshold
        
        # 融合判断
        # 眼动熵高 + EEG 思维游离 → 认知分心
        is_cognitive_distraction = (
            eeg_result["is_mind_wandering"] and eye_distraction
        )
        
        # 置信度融合
        confidence = (
            eeg_result["confidence"] * 0.5 +
            eye_entropy * 0.5
        )
        
        return {
            "is_cognitive_distraction": is_cognitive_distraction,
            "confidence": confidence,
            "eeg_indicator": eeg_result["mse_indicator"],
            "eye_indicator": eye_entropy,
            "fusion_method": "EEG_MSE + Eye_Entropy"
        }

---

Euro NCAP 2026 认知分心检测场景

场景	EEG 复杂度特征	眼动熵特征	融合判断
正常驾驶	MSE 小尺度熵高	空间熵低	无分心
认知分心	MSE 小尺度熵低	空间熵高	分心警告
疲劳	LZ 复杂度低	PERCLOS 高	疲劳警告
思维游离	Hurst 偏离 0.5	眼动熵中	认知分心

---

参考资料

1. Nature Scientific Reports 2024
2. Kaushik et al., “Decoding cognitive states”, Scientific Reports
3. Euro NCAP 2026 Cognitive Distraction Protocol

---

总结

Nature 2024 论文核心：

1. 多尺度熵（MSE）：思维游离时小尺度熵降低
2. LZ 复杂度：思维游离时增加
3. Hurst 指数：偏离 0.5 表示异常

IMS 开发优先级：

• 🔴 高：MSE 计算（EEG 信号分析）
• 🟡 中：耳 EEG 采集方案
• 🟢 低：EEG + 眼动融合优化

下一步行动：

• 实现多尺度熵计算
• 研究 LZ 复杂度快速算法
• 对齐 Euro NCAP 认知分心测试场景