SEED-VII数据集实战：用Python快速搭建情感脑电图分析环境（附代码）

SEED-VII数据集实战：用Python快速搭建情感脑电图分析环境（附代码）

最近几年，身边不少做情感计算和脑机接口的朋友，都开始把目光投向了一个叫SEED-VII的数据集。说实话，我第一次接触它的时候，也被它庞大的数据量和丰富的模态吓了一跳。这不仅仅是一个简单的脑电图（EEG）数据集合，它更像是一个为情感识别研究量身定制的“游乐场”，里面不仅有经典的EEG信号，还整合了眼动、生理信号等多种信息，让研究者能从更多维度去窥探情绪的奥秘。对于开发者、学生和刚入行的研究人员来说，直接上手这样一个复杂的数据集，难免会感到无从下手——环境怎么配？数据怎么读？模型怎么搭？别急，这篇文章就是为你准备的。我会带你从零开始，用Python一步步搭建起一个可运行、可实验的分析环境，把SEED-VII这个“利器”真正用起来。

1. 环境搭建与数据获取：迈出第一步

在开始任何数据分析之前，一个稳定、可复现的Python环境是基石。对于脑电信号处理，我们需要的工具链相对固定，但版本兼容性是个需要特别注意的坑。

1.1 创建并配置Python虚拟环境

我强烈建议你为这个项目创建一个独立的虚拟环境。这能避免与你系统上其他项目的依赖发生冲突。使用conda或venv都可以，这里以conda为例，因为它能更好地管理一些科学计算包的二进制依赖。

# 创建一个名为seed_vii_env的Python 3.9环境
conda create -n seed_vii_env python=3.9 -y

# 激活环境
conda activate seed_vii_env

环境激活后，我们开始安装核心包。脑电处理离不开numpy、scipy和pandas进行数值运算和数据操作，而mne（MNE-Python）是处理脑电数据的行业标准工具，提供了从读取、预处理到可视化的全套功能。

# 安装核心数据处理和科学计算库
pip install numpy scipy pandas matplotlib seaborn

# 安装脑电处理专业库MNE
pip install mne

# 安装机器学习框架，这里以PyTorch为例（根据你的CUDA版本选择安装命令）
# 例如，对于CUDA 11.8
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# 安装scikit-learn用于传统机器学习模型和评估
pip install scikit-learn

注意：mne库在Windows系统上安装时，可能会遇到一些底层C库的编译问题。如果安装失败，可以尝试使用conda install -c conda-forge mne命令通过conda安装，conda-forge频道通常提供了预编译好的二进制包。

1.2 获取与初步探索SEED-VII数据集

SEED-VII数据集通常需要从官方渠道申请获取。假设你已经成功下载了数据集，并解压到了本地目录。数据集的文件结构可能比较复杂，常见的是按被试者（Subject）和实验会话（Session）进行组织，数据格式可能是.mat（MATLAB文件）或.npy（NumPy文件）。

我们先写一个简单的脚本来探索数据目录结构，做到心中有数。

import os
from pathlib import Path

# 假设你的数据集根目录路径
data_root = Path('./SEED-VII')
if not data_root.exists():
    print(f"警告：数据目录 {data_root} 不存在，请检查路径。")
else:
    print(f"正在探索数据目录: {data_root}")
    for root, dirs, files in os.walk(data_root):
        level = root.replace(str(data_root), '').count(os.sep)
        indent = ' ' * 2 * level
        print(f'{indent}{os.path.basename(root)}/')
        sub_indent = ' ' * 2 * (level + 1)
        for file in files[:5]: # 只打印前5个文件，避免输出过长
            print(f'{sub_indent}{file}')
        if len(files) > 5:
            print(f'{sub_indent}... 以及另外 {len(files)-5} 个文件')

一个典型的数据结构可能如下表所示，了解它有助于后续编写数据加载器：

目录/文件层级	描述	示例
SEED-VII/	数据集根目录
├── Subject_01/	1号被试者数据目录
│ ├── Session_1/	第1次实验会话
│ │ ├── eeg_data.mat	EEG原始数据文件
│ │ ├── eye_tracking.csv	眼动数据文件
│ │ └── labels.npy	情感标签文件（如效价、唤醒度）
│ └── Session_2/	第2次实验会话
└── Subject_02/	2号被试者数据目录

2. 数据加载与预处理：从原始信号到可用特征

拿到原始数据后，我们很少能直接将其扔进模型。EEG信号非常微弱，容易受到眼电、肌电、工频干扰等噪声污染，必须经过一系列预处理步骤来“提纯”。

2.1 使用MNE-Python加载与可视化原始EEG

假设我们的EEG数据是.mat格式。我们可以使用scipy读取，并利用mne创建仿真的原始数据结构，以便使用其强大的预处理流水线。

import scipy.io as sio
import mne
import numpy as np
import matplotlib.pyplot as plt

def load_eeg_mat(file_path, sfreq=200):
    """
    加载.mat格式的EEG数据，并转换为MNE Raw对象。
    参数：
        file_path: .mat文件路径。
        sfreq: 采样频率（Hz），SEED-VII通常为200Hz或更高。
    返回：
        raw: MNE Raw对象。
    """
    try:
        mat_data = sio.loadmat(file_path)
        # 关键：需要根据实际.mat文件的结构访问EEG数据
        # 例如，数据可能在键'eeg_data'下，形状为(通道数, 时间点数)
        eeg_data = mat_data['eeg_data']  # 请根据实际情况修改键名

        # 创建MNE的Info对象，描述数据
        n_channels, n_times = eeg_data.shape
        # 创建通道名称列表，假设是标准62导联
        ch_names = [f'EEG{i:03d}' for i in range(n_channels)]
        ch_types = ['eeg'] * n_channels
        info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)

        # 创建RawArray对象。注意：数据单位需要是伏特(V)，通常原始数据是微伏(uV)，需转换
        # 假设数据是uV，转换为V
        eeg_data_v = eeg_data * 1e-6
        raw = mne.io.RawArray(eeg_data_v, info)

        # 设置标准10-20系统电极位置（近似）。对于精确分析，需要真实的电极位置文件。
        montage = mne.channels.make_standard_montage('standard_1020')
        # 由于我们的通道名是自定义的，需要手动映射或使用通用位置，这里仅作示例
        # raw.set_montage(montage) # 如果通道名能匹配，可以直接设置

        print(f"成功加载数据: {file_path}")
        print(f"  通道数: {n_channels}, 时间点数: {n_times}, 时长: {n_times/sfreq:.2f}秒")
        return raw
    except Exception as e:
        print(f"加载文件 {file_path} 时出错: {e}")
        return None

# 示例：加载一个文件并绘制原始信号片段
sample_file = './SEED-VII/Subject_01/Session_1/eeg_data.mat'
raw = load_eeg_mat(sample_file, sfreq=200)
if raw:
    # 绘制前5秒的原始信号（仅显示前10个通道避免过于拥挤）
    fig = raw.plot(duration=5.0, n_channels=10, scalings='auto', show=False)
    fig.suptitle('原始EEG信号示例 (前10个通道，前5秒)')
    plt.show()

2.2 构建标准预处理流水线

预处理步骤的顺序和参数设置需要根据具体研究和数据质量调整。下面是一个典型的流水线：

1. 滤波：去除高频噪声和低频漂移。通常保留1-45Hz的频率成分用于情感分析。
2. 坏道检测与插值：识别并修复信号质量极差的电极通道。
3. 重参考：将参考电极转换为平均参考，以减少参考电极的影响。
4. 独立成分分析：识别并去除眼电、心电等伪迹成分。

def preprocess_raw(raw, l_freq=1.0, h_freq=45.0):
    """
    对Raw对象进行预处理。
    """
    raw_copy = raw.copy() # 在副本上操作，避免修改原始数据

    # 1. 带通滤波
    print("应用带通滤波 (1-45 Hz)...")
    raw_copy.filter(l_freq=l_freq, h_freq=h_freq, fir_design='firwin')

    # 2. 坏道检测（简单阈值法示例）
    print("检测坏道...")
    # 计算每个通道的峰峰值幅度
    data, times = raw_copy[:, :]
    peak_to_peak = np.ptp(data, axis=1)
    median_ptp = np.median(peak_to_peak)
    std_ptp = np.std(peak_to_peak)
    # 将幅度超过中位数3个标准差的通道标记为坏道
    bad_ch_idx = np.where(peak_to_peak > median_ptp + 3 * std_ptp)[0]
    bad_chs = [raw_copy.ch_names[i] for i in bad_ch_idx]
    if bad_chs:
        raw_copy.info['bads'] = bad_chs
        print(f"  发现坏道: {bad_chs}")
        # 在实际应用中，可以考虑插值坏道: raw_copy.interpolate_bads()
    else:
        print("  未发现明显坏道。")

    # 3. 重参考（设置为平均参考）
    print("应用平均参考...")
    raw_copy.set_eeg_reference(ref_channels='average', projection=False)

    # 注意：完整的ICA去除伪迹步骤较耗时，通常需要根据眼电等标记进行成分识别和剔除。
    # 此处为简化流程，暂不包含。实际项目中强烈建议执行此步骤。
    # print("进行ICA去除眼电伪迹...")
    # ica = mne.preprocessing.ICA(n_components=20, random_state=97)
    # ica.fit(raw_copy)
    # ica.exclude = [...] # 需要手动或自动识别眼电成分的索引
    # ica.apply(raw_copy)

    print("预处理完成。")
    return raw_copy

# 应用预处理
if raw:
    raw_processed = preprocess_raw(raw)
    # 可以再次绘图对比预处理效果
    fig = raw_processed.plot(duration=5.0, n_channels=10, scalings='auto', show=False)
    fig.suptitle('预处理后EEG信号示例')
    plt.show()

3. 特征工程：从时域到频域，捕捉情感指纹

经过预处理的干净EEG信号，数据量依然庞大。直接使用高维时间序列作为模型输入，不仅计算成本高，而且容易过拟合。因此，我们需要从中提取能够有效表征情感状态的特征。情感EEG分析中，微分熵（Differential Entropy, DE）特征因其在情绪识别中的良好表现而被广泛使用，特别是在SEED系列数据集的基线方法中。

3.1 理解微分熵特征

微分熵是香农熵在连续概率分布上的推广，可以粗略理解为信号在特定频带内复杂度的度量。对于一段近似服从高斯分布的脑电信号，其在某个频带（如Theta: 4-8Hz, Alpha: 8-14Hz, Beta: 14-31Hz, Gamma: 31-45Hz）内的微分熵有一个简化的计算公式，等价于对该频带信号功率谱的对数运算。

提取DE特征的一般步骤是：

• 将每个通道的EEG信号进行短时傅里叶变换（STFT）或使用带通滤波器组。
• 计算每个频带内的信号功率。
• 根据公式计算该频带的微分熵值。

3.2 使用Python批量提取DE特征

下面我们实现一个函数，用于从单个试次（trial）的EEG数据中提取多频带DE特征。

import numpy as np
from scipy import signal, integrate

def extract_de_features(eeg_segment, sfreq, bands, window_length=1.0, overlap=0.5):
    """
    从一段多通道EEG数据中提取微分熵特征。
    参数：
        eeg_segment: numpy数组，形状为 (通道数, 时间点数)。
        sfreq: 采样频率。
        bands: 字典，键为频带名，值为(低频, 高频)元组，如{'theta': (4,8), 'alpha': (8,14)}。
        window_length: 滑动窗口长度（秒）。
        overlap: 滑动窗口重叠比例（0到1之间）。
    返回：
        de_features: numpy数组，形状为 (通道数, 频带数)。
    """
    n_channels, n_points = eeg_segment.shape
    n_bands = len(bands)
    band_names = list(bands.keys())

    # 初始化特征矩阵
    de_features = np.zeros((n_channels, n_bands))

    # 计算每个通道、每个频带的DE
    for ch_idx in range(n_channels):
        channel_data = eeg_segment[ch_idx, :]
        for band_idx, (band_name, (low_freq, high_freq)) in enumerate(bands.items()):
            # 设计带通滤波器
            nyquist = sfreq / 2.0
            low = low_freq / nyquist
            high = high_freq / nyquist
            b, a = signal.butter(5, [low, high], btype='band')

            # 应用滤波器，得到该频带信号
            band_signal = signal.filtfilt(b, a, channel_data)

            # 计算该频带信号的方差，假设信号服从高斯分布 N(0, sigma^2)
            # 对于高斯分布，微分熵 h(X) = 0.5 * log(2 * pi * e * sigma^2)
            sigma2 = np.var(band_signal)
            # 防止方差为0导致对数计算错误
            if sigma2 <= 0:
                sigma2 = 1e-10
            de = 0.5 * np.log(2 * np.pi * np.e * sigma2)
            de_features[ch_idx, band_idx] = de

    return de_features, band_names

# 定义常用的情感EEG频带
EEG_BANDS = {
    'delta': (1, 4),
    'theta': (4, 8),
    'alpha': (8, 14),
    'beta': (14, 31),
    'gamma': (31, 45)
}

# 示例：从一段预处理后的数据中提取特征
if 'raw_processed' in locals():
    # 获取一段5秒的数据（假设从第10秒开始）
    start_sample = int(10 * raw_processed.info['sfreq'])
    end_sample = int(15 * raw_processed.info['sfreq'])
    data_segment, times = raw_processed[:, start_sample:end_sample]

    de_feat, bands_used = extract_de_features(data_segment, sfreq=raw_processed.info['sfreq'], bands=EEG_BANDS)
    print(f"特征提取完成。形状: {de_feat.shape} (通道数 x 频带数)")
    print(f"使用的频带: {bands_used}")

    # 可视化某个通道在不同频带的DE值
    ch_to_plot = 0
    plt.figure(figsize=(10, 5))
    plt.bar(bands_used, de_feat[ch_to_plot, :])
    plt.xlabel('频带')
    plt.ylabel('微分熵 (DE)')
    plt.title(f'通道 {raw_processed.ch_names[ch_to_plot]} 在各频带的微分熵特征')
    plt.grid(True, axis='y', linestyle='--', alpha=0.7)
    plt.show()

提取出的DE特征矩阵，其维度为（通道数 × 频带数）。对于62个通道、5个频带的情况，每个试次就得到了一个310维的特征向量。这个向量相比原始数万维的时间点数据，维度大大降低，且包含了与情感相关的频域能量信息。

4. 构建情感识别模型：从传统机器学习到深度学习

特征准备好之后，我们就可以构建分类器来识别情感了。根据任务的不同（如二分类：积极/消极；三分类：积极/中性/消极；或维度回归：预测效价、唤醒度分值），我们可以选择不同的模型。

4.1 基于Scikit-learn的传统机器学习流程

对于刚入门的研究者，从逻辑回归、支持向量机（SVM）、随机森林等传统模型开始是一个稳妥的选择。它们训练速度快，可解释性相对较强，能快速建立基线性能。

假设我们已经将多个被试者、多个试次的数据处理成了特征矩阵X（形状：[n_samples, n_features]）和标签向量y（形状：[n_samples,]）。

from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
import seaborn as sns

def train_evaluate_sklearn_model(X, y, model_type='svm', test_size=0.2, random_state=42):
    """
    使用传统机器学习模型进行训练和评估。
    """
    # 1. 划分训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=test_size, stratify=y, random_state=random_state
    )
    print(f"数据划分: 训练集 {X_train.shape}, 测试集 {X_test.shape}")

    # 2. 标准化特征（对SVM等基于距离的模型很重要）
    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    X_test_scaled = scaler.transform(X_test)

    # 3. 定义模型
    if model_type == 'svm':
        # 可以先使用默认参数快速测试
        model = SVC(kernel='rbf', C=1.0, gamma='scale', random_state=random_state)
        # 也可以进行网格搜索寻找最优参数（耗时）
        # param_grid = {'C': [0.1, 1, 10], 'gamma': ['scale', 'auto', 0.01, 0.1]}
        # grid_search = GridSearchCV(SVC(random_state=random_state), param_grid, cv=3)
        # grid_search.fit(X_train_scaled, y_train)
        # model = grid_search.best_estimator_
    elif model_type == 'random_forest':
        model = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=random_state)
    else:
        raise ValueError(f"不支持的模型类型: {model_type}")

    # 4. 训练模型
    print(f"训练 {model_type.upper()} 模型...")
    model.fit(X_train_scaled, y_train)

    # 5. 在测试集上评估
    y_pred = model.predict(X_test_scaled)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"测试集准确率: {accuracy:.4f}")
    print("\n详细分类报告:")
    print(classification_report(y_test, y_pred))

    # 6. 绘制混淆矩阵
    cm = confusion_matrix(y_test, y_pred)
    plt.figure(figsize=(8, 6))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=model.classes_, yticklabels=model.classes_)
    plt.xlabel('预测标签')
    plt.ylabel('真实标签')
    plt.title(f'{model_type.upper()} 混淆矩阵 (准确率: {accuracy:.3f})')
    plt.show()

    return model, scaler, accuracy

# 注意：此处X, y需要你从所有提取的特征和标签中整合而来。
# 以下是一个模拟数据的示例，你需要替换为真实数据
# 假设我们有100个样本，每个样本有310个特征（62通道*5频带），3类情感标签
# X_simulated = np.random.randn(100, 310)
# y_simulated = np.random.randint(0, 3, 100)
# _ = train_evaluate_sklearn_model(X_simulated, y_simulated, model_type='svm')

4.2 构建一个简单的深度学习模型（PyTorch）

对于更复杂的模式或当数据量足够大时，深度学习模型，特别是卷积神经网络（CNN）和长短时记忆网络（LSTM），在情感EEG识别中展现出了强大的潜力。CNN可以捕捉脑电信号在空间（通道）和频率上的局部相关性，而LSTM则擅长处理信号的时间动态特性。

这里我们构建一个结合了CNN和LSTM的混合模型，它先将多通道的DE特征（可以重塑为“通道×频带”的2D图像）进行空间卷积，再用LSTM捕捉时间序列上的变化。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

class EEGNet_LSTM(nn.Module):
    """
    一个用于情感EEG分类的简单CNN-LSTM混合模型。
    输入形状: (batch_size, seq_len, channels, features)
    例如: (batch, 时间步长, 62, 5)
    """
    def __init__(self, num_channels=62, num_features=5, num_classes=3, lstm_hidden=128):
        super(EEGNet_LSTM, self).__init__()
        # 第一部分：CNN处理空间-频域特征
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=(3, 3), padding=1)
        self.bn1 = nn.BatchNorm2d(16)
        self.pool1 = nn.MaxPool2d(kernel_size=(2, 2))
        self.conv2 = nn.Conv2d(16, 32, kernel_size=(3, 3), padding=1)
        self.bn2 = nn.BatchNorm2d(32)
        self.pool2 = nn.MaxPool2d(kernel_size=(2, 2))
        self.dropout1 = nn.Dropout(0.5)

        # 动态计算CNN输出展平后的尺寸
        # 这里简化计算，实际需要根据输入尺寸推导或使用自适应池化
        self.cnn_output_size = 32 * (num_channels // 4) * (num_features // 4) # 假设两次池化后尺寸

        # 第二部分：LSTM处理时间序列
        self.lstm = nn.LSTM(input_size=self.cnn_output_size, hidden_size=lstm_hidden,
                            batch_first=True, bidirectional=True)
        self.dropout2 = nn.Dropout(0.5)
        # 双向LSTM，输出维度为 hidden_size * 2
        self.fc = nn.Linear(lstm_hidden * 2, num_classes)

    def forward(self, x):
        # x shape: (batch, seq_len, channels, features)
        batch_size, seq_len, C, F = x.size()
        # 将时间步和批次合并，以便CNN独立处理每个时间步的“图像”
        x = x.view(batch_size * seq_len, 1, C, F)

        # CNN部分
        x = torch.relu(self.bn1(self.conv1(x)))
        x = self.pool1(x)
        x = torch.relu(self.bn2(self.conv2(x)))
        x = self.pool2(x)
        x = self.dropout1(x)
        # 展平
        x = x.view(batch_size * seq_len, -1)

        # 恢复时间序列维度
        x = x.view(batch_size, seq_len, -1)

        # LSTM部分
        lstm_out, (h_n, c_n) = self.lstm(x)
        # 取最后一个时间步的输出
        x = lstm_out[:, -1, :]
        x = self.dropout2(x)
        # 全连接分类层
        out = self.fc(x)
        return out

def train_deep_model(model, train_loader, val_loader, num_epochs=50, lr=0.001):
    """
    训练深度学习模型。
    """
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    print(f"使用设备: {device}")
    model.to(device)

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=lr)
    scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience=5, factor=0.5)

    train_losses, val_losses, val_accs = [], [], []

    for epoch in range(num_epochs):
        model.train()
        running_loss = 0.0
        for batch_X, batch_y in train_loader:
            batch_X, batch_y = batch_X.to(device), batch_y.to(device)
            optimizer.zero_grad()
            outputs = model(batch_X)
            loss = criterion(outputs, batch_y)
            loss.backward()
            optimizer.step()
            running_loss += loss.item() * batch_X.size(0)

        epoch_train_loss = running_loss / len(train_loader.dataset)
        train_losses.append(epoch_train_loss)

        # 验证阶段
        model.eval()
        val_loss = 0.0
        correct = 0
        total = 0
        with torch.no_grad():
            for batch_X, batch_y in val_loader:
                batch_X, batch_y = batch_X.to(device), batch_y.to(device)
                outputs = model(batch_X)
                loss = criterion(outputs, batch_y)
                val_loss += loss.item() * batch_X.size(0)
                _, predicted = torch.max(outputs.data, 1)
                total += batch_y.size(0)
                correct += (predicted == batch_y).sum().item()

        epoch_val_loss = val_loss / len(val_loader.dataset)
        epoch_val_acc = correct / total
        val_losses.append(epoch_val_loss)
        val_accs.append(epoch_val_acc)

        scheduler.step(epoch_val_loss)

        if (epoch + 1) % 10 == 0:
            print(f'Epoch [{epoch+1:03d}/{num_epochs}], '
                  f'Train Loss: {epoch_train_loss:.4f}, '
                  f'Val Loss: {epoch_val_loss:.4f}, '
                  f'Val Acc: {epoch_val_acc:.4f}')

    print('训练完成。')
    # 绘制训练曲线
    plt.figure(figsize=(12, 4))
    plt.subplot(1, 2, 1)
    plt.plot(train_losses, label='Train Loss')
    plt.plot(val_losses, label='Val Loss')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.legend()
    plt.title('训练和验证损失')

    plt.subplot(1, 2, 2)
    plt.plot(val_accs)
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.title('验证集准确率')
    plt.tight_layout()
    plt.show()

    return model

# 注意：以下代码需要真实的、按时间序列组织的数据来运行。
# 假设我们已经将数据组织成了 (样本数, 时间步长seq_len, 通道数, 频带数) 的numpy数组 X_sequence
# 以及对应的标签 y
# 然后转换为PyTorch张量并创建DataLoader
# X_tensor = torch.FloatTensor(X_sequence)
# y_tensor = torch.LongTensor(y)
# dataset = TensorDataset(X_tensor, y_tensor)
# train_size = int(0.8 * len(dataset))
# val_size = len(dataset) - train_size
# train_dataset, val_dataset = torch.utils.data.random_split(dataset, [train_size, val_size])
# train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
# val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
# model = EEGNet_LSTM(num_channels=62, num_features=5, num_classes=3)
# trained_model = train_deep_model(model, train_loader, val_loader, num_epochs=30)

5. 实验设计与性能提升技巧

搭建好基础流程后，要想获得可靠且具有竞争力的结果，还需要在实验设计上下功夫。脑电情感识别有几个独特的挑战，比如被试者间差异大、数据量相对较小、信号噪声高等。

• 被试者独立与依赖实验：这是最重要的设计决策之一。在被试者依赖实验中，同一个被试者的数据会同时出现在训练集和测试集中，模型容易学习到个体特异性特征，准确率往往虚高，但泛化能力存疑。而在被试者独立实验中，测试集的数据来自训练集未出现过的被试者，这对模型的泛化能力是真正的考验，也是更贴近实际应用的场景。在SEED-VII上做研究，我建议至少报告被试者独立的实验结果。

• 交叉验证策略：对于被试者独立实验，可以采用“留出一个被试者”（Leave-One-Subject-Out, LOSO）的交叉验证。即每次选择一个被试者作为测试集，其余所有被试者作为训练集，循环直到每个被试者都被测试过一次，最后取平均性能。这种方法能充分利用有限的数据，并给出模型泛化能力的稳健估计。

• 数据增强：针对EEG数据量小的问题，数据增强是有效的缓解过拟合手段。除了经典的添加高斯噪声、随机缩放、时间偏移外，针对EEG的增强方法还有：

  • 通道丢弃：随机屏蔽一部分通道，模拟电极接触不良。
  • 频带随机增强：随机增强或减弱某个特定频带的能量。
  • 混合样本：在特征层面或原始信号层面混合两个样本，生成新样本。

• 多模态融合：SEED-VII的优势在于多模态。不要只盯着EEG数据。可以尝试将眼动特征（如注视点、瞳孔直径变化）或生理信号特征（如皮电、心电）与EEG特征进行融合。融合可以在特征层（早期融合）、模型层（中期融合）或决策层（晚期融合）进行。例如，可以分别用两个神经网络处理EEG和眼动特征，然后在全连接层之前进行拼接。

# 一个简单的晚期融合示例（决策层平均）
def late_fusion(pred_eeg, pred_eye, method='average'):
    """
    pred_eeg, pred_eye: 来自EEG模型和眼动模型的预测概率向量（softmax输出）。
    method: 'average' 或 'weighted'
    """
    if method == 'average':
        final_pred = (pred_eeg + pred_eye) / 2
    elif method == 'weighted':
        weight_eeg = 0.7  # 假设我们更信任EEG模型
        weight_eye = 0.3
        final_pred = weight_eeg * pred_eeg + weight_eye * pred_eye
    else:
        raise ValueError("融合方法必须是 'average' 或 'weighted'")
    return final_pred

• 可视化与可解释性：模型为什么做出某个决策？我们可以通过绘制地形图来可视化不同情感状态下，各个脑区或频带的激活差异。对于深度学习模型，可以使用梯度加权类激活映射等方法，来观察输入EEG信号的哪些部分对模型的决策贡献最大。这不仅能增加研究的可信度，也能帮助我们理解情感处理的大脑机制。

整个流程走下来，你会发现处理SEED-VII这样的数据集，更像是在完成一个系统工程。从环境配置、数据清洗、特征提取到模型构建与评估，每一步都需要耐心和细致的调优。我自己的经验是，在特征工程和实验设计上多花时间，其回报往往比盲目尝试更复杂的模型架构要大得多。刚开始结果不理想很正常，可能是预处理参数需要调整，也可能是特征选择不当，或者模型不适合当前的数据分布。多看看领域内顶会论文中大家是如何处理类似数据的，复现他们的基线方法，然后再进行自己的创新，这是一个比较高效的学习路径。