am-mteeg-classification

name	am-mteeg-classification
description	基于脉冲关联记忆的多任务 EEG 分类方法（AM-MTEEG）。受海马体学习记忆原理启发，实现跨个体 BCI 分类，具有生物可解释性。触发词：EEG分类、多任务学习、关联记忆、associative memory、跨个体BCI、海马体启发、hippocampus-inspired。
user-invocable	true

AM-MTEEG: Multi-task EEG Classification with Associative Memory

核心方法论

AM-MTEEG 受海马体学习记忆原理启发，提出多任务 EEG 分类框架：

1. 脉冲神经表示 - 模拟海马体神经元的脉冲编码
2. 双向关联记忆 - Hopfield 式记忆矩阵用于特征-类别映射
3. 多任务学习 - 每个个体作为独立任务，跨个体共享特征
4. 生物可解释性 - 神经发放模式与海马体编码高度协调

核心优势

• 提高平均分类准确率
• 减少跨个体性能方差
• 提供波形重建可解释性
• 神经发放模式具有生物相似性

Python 代码示例

1. 脉冲神经表示模块

import torch
import torch.nn as nn
import numpy as np

class SpikingNeuronPopulation(nn.Module):
    """脉冲神经群体模块 - 模拟海马体神经元的脉冲编码"""
    
    def __init__(self, n_neurons, n_inputs, tau=20.0, threshold=1.0):
        super().__init__()
        self.n_neurons = n_neurons
        self.tau = tau
        self.threshold = threshold
        self.weights = nn.Parameter(torch.randn(n_inputs, n_neurons) * 0.1)
        self.register_buffer('membrane_potential', torch.zeros(1, n_neurons))
    
    def reset_state(self, batch_size=1):
        self.membrane_potential = torch.zeros(batch_size, self.n_neurons)
    
    def forward(self, x, time_steps=10):
        batch_size = x.shape[0]
        self.reset_state(batch_size)
        spike_output = []
        
        for t in range(time_steps):
            current = torch.matmul(x, self.weights)
            self.membrane_potential = self.membrane_potential * np.exp(-1.0 / self.tau) + current
            spikes = (self.membrane_potential > self.threshold).float()
            self.membrane_potential = self.membrane_potential * (1 - spikes)
            spike_output.append(spikes)
        
        spike_output = torch.stack(spike_output, dim=1)
        spike_rate = spike_output.mean(dim=1)
        return spike_output, spike_rate

2. 卷积编码器-解码器

class ConvEncoderDecoder(nn.Module):
    """卷积编码器-解码器 - 提取共享的 EEG 特征"""
    
    def __init__(self, n_channels, n_timepoints, latent_dim=64):
        super().__init__()
        
        self.encoder = nn.Sequential(
            nn.Conv1d(n_channels, 32, kernel_size=5, stride=2, padding=2),
            nn.BatchNorm1d(32), nn.ELU(),
            nn.Conv1d(32, 64, kernel_size=5, stride=2, padding=2),
            nn.BatchNorm1d(64), nn.ELU(),
            nn.Conv1d(64, 128, kernel_size=5, stride=2, padding=2),
            nn.BatchNorm1d(128), nn.ELU(),
            nn.Flatten(),
            nn.Linear(128 * (n_timepoints // 8), latent_dim)
        )
        
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 128 * (n_timepoints // 8)),
            nn.Unflatten(1, (128, n_timepoints // 8)),
            nn.ConvTranspose1d(128, 64, kernel_size=5, stride=2, padding=2, output_padding=1),
            nn.BatchNorm1d(64), nn.ELU(),
            nn.ConvTranspose1d(64, 32, kernel_size=5, stride=2, padding=, output_padding=),
            nn.BatchNorm1d(), nn.ELU(),
            nn.ConvTranspose1d(, n_channels, kernel_size=, stride=, padding=, output_padding=)
        )
    
     ():
        latent = .encoder(x)
        reconstructed = .decoder(latent)
         latent, reconstructed

3. 双向关联记忆矩阵

class BidirectionalAssociativeMemory(nn.Module):
    """双向关联记忆（BAM）- Hopfield 式记忆矩阵"""
    
    def __init__(self, feature_dim, n_classes, n_memories=16):
        super().__init__()
        self.memory_features = nn.Parameter(torch.randn(n_memories, feature_dim) * 0.1)
        self.memory_classes = nn.Parameter(torch.randn(n_memories, n_classes) * 0.1)
        self.association_matrix = nn.Parameter(torch.zeros(feature_dim, n_classes))
    
    def update_association(self):
        """Hebbian 学习更新关联矩阵"""
        with torch.no_grad():
            self.association_matrix.data = torch.mm(self.memory_features.T, self.memory_classes)
    
    def forward(self, features):
        class_output = torch.mm(features, self.association_matrix)
        class_probs = torch.softmax(class_output, dim=-1)
        reconstructed_features = torch.mm(class_probs, self.association_matrix.T)
        return class_output, reconstructed_features

4. 完整 AM-MTEEG 模型

class AM_MTEEG(nn.Module):
    """AM-MTEEG: 完整的多任务 EEG 分类模型"""
    
    def __init__(self, n_channels, n_timepoints, n_classes, n_tasks=10, latent_dim=64, n_neurons=128):
        super().__init__()
        self.n_tasks = n_tasks
        
        self.encoder_decoder = ConvEncoderDecoder(n_channels, n_timepoints, latent_dim)
        self.spiking_population = SpikingNeuronPopulation(n_neurons=n_neurons, n_inputs=latent_dim)
        self.bam = BidirectionalAssociativeMemory(feature_dim=n_neurons, n_classes=n_classes)
        
        self.task_adapters = nn.ModuleList([
            nn.Sequential(nn.Linear(latent_dim, latent_dim), nn.ELU())
            for _ in range(n_tasks)
        ])
    
    def forward(self, x, task_id=None):
        latent, reconstructed = self.encoder_decoder(x)
        if task_id is not None:
            latent = self.task_adapters[task_id](latent)
        spike_output, spike_rate = self.spiking_population(latent)
        logits, _ = self.bam(spike_rate)
        return logits, reconstructed, spike_output

应用场景

1. 跨个体 BCI - 减少个体差异影响
2. 运动想象分类 - 手部运动想象识别
3. 情绪识别 - EEG 情绪状态分类
4. 注意力监测 - 注意力状态检测

生物可解释性

1. 脉冲编码 - 类似海马体神经元的发放模式
2. 关联记忆 - 模拟海马体的情景记忆机制
3. 波形重建 - 提供分类决策的可视化解释

Activation Keywords

• EEG分类
• 多任务学习
• 关联记忆
• associative memory
• 跨个体BCI
• 海马体启发
• hippocampus-inspired
• 脉冲神经网络
• SNN

Tools Used

• Python
• PyTorch
• NumPy
• SciPy

Instructions for Agents

1. 确认任务类型是否为EEG分类或脑机接口相关
2. 检查数据格式（通道数、时间点数、类别数）
3. 根据数据规模选择合适的模型参数（神经元数量、潜在维度）
4. 实现脉冲神经群体模块进行特征编码
5. 使用双向关联记忆进行分类
6. 如需跨个体迁移，启用任务适配器

Examples

# 使用AM-MTEEG进行EEG分类
model = AM_MTEEG(
    n_channels=64,
    n_timepoints=1000,
    n_classes=4,
    n_tasks=10
)

# 前向传播
eeg_data = torch.randn(32, 64, 1000)  # batch, channels, timepoints
logits, reconstructed, spikes = model(eeg_data, task_id=0)

# 分类预测
predictions = logits.argmax(dim=1)

参考文献

• Paper: arXiv:2409.18375