企业官网建设流程全解析

简介：本资源是一个基于PyTorch实现的单通道脑电信号（EEG）睡眠分期系统，面向计算机科学、生物医学工程及人工智能方向的高年级本科生与研究生，解决神经生理信号自动分类中的模型构建与工程落地问题。压缩包共26个文件（25KB），含7个核心Python模块（如model.py、dataset.py、train.py）、4个XML配置与IDE设置文件、3个编译缓存pyc文件、2个Markdown文档（含README备份）及LICENSE等辅助文件，结构清晰、模块解耦，便于教学复现与算法调优。已有133人学习下载，资源提供完整可运行代码、技术文档及多轮验证通过的混合CNN-RNN模型实现，涵盖数据预处理、时序特征建模、训练评估全流程，并支持向多模态生理信号分析拓展。

1. 项目缘起：从临床痛点到一个可复现的代码方案

如果你接触过神经科学、生物医学工程或者睡眠研究，大概率听说过“睡眠分期”这个概念。简单来说，就是把一整晚的睡眠脑电图（EEG）信号，按照国际标准（通常是AASM标准）切成一个个30秒的“片段”，然后给每个片段打上标签：清醒期（Wake）、快速眼动期（REM）、非快速眼动1期（N1）、2期（N2）、3期（N3）。这活儿以前是睡眠技师拿着放大镜，对着波形图，根据脑电波的频率、振幅、波形特征（比如纺锤波、K复合波）手动标注的，费时费力，还容易受主观判断影响。一个病人8小时的睡眠数据，人工分期可能要花上1-2个小时。

所以，用算法自动化这件事，一直是研究热点。从早期的时频分析加传统机器学习（比如支持向量机、随机森林），到后来基于卷积神经网络（CNN）和循环神经网络（RNN）的深度学习模型，准确率一直在提升。但很多研究论文里的代码要么不开源，要么环境依赖复杂得让人头疼，对于想快速上手、验证想法或者用于教学的同学来说，门槛不低。

我这个项目，就是想用PyTorch这个当下最主流的深度学习框架之一，搭建一个清晰、完整、可复现的单通道脑电信号睡眠分期系统。所谓“单通道”，意味着我们只使用一个导联的脑电信号（比如C4-A1或Fpz-Cz），这更贴近一些可穿戴设备的应用场景，数据获取和处理成本都更低。整个流程会从最原始的数据加载开始，涵盖数据预处理、特征工程（可选）、模型构建、训练、评估到最终预测，我会把每一步的“为什么这么做”和“具体怎么做”都讲清楚，并分享我在这个过程中踩过的坑和总结的经验。无论你是刚入门PyTorch想找个实战项目练手，还是相关领域的研究者需要一套基线代码，希望这篇内容都能帮到你。

2. 环境搭建与数据准备：避开版本依赖的“暗礁”

工欲善其事，必先利其器。深度学习项目的第一步，永远是配环境。根据网络热词来看，大家最头疼的似乎就是PyTorch的安装，尤其是GPU版本。这里我结合最新的情况（2024年），给出一个稳妥的方案。

2.1 PyTorch与CUDA版本匹配：一次配好，省心百倍

首先，强烈建议使用Anaconda或Miniconda来管理Python环境。这能完美解决不同项目间包版本冲突的问题。创建一个新的虚拟环境是标准操作：

conda create -n sleep_eeg python=3.9 conda activate sleep_eeg

接下来是安装PyTorch。去官网（pytorch.org）获取安装命令是最佳实践。关键点在于CUDA版本必须与你的NVIDIA显卡驱动兼容。以目前较稳定的组合为例：

• 如果你的驱动版本较新（>=545），可以考虑CUDA 12.1。
• 如果想求稳，CUDA 11.8是兼容性非常广的选择。

我个人的选择是CUDA 11.8，对应的PyTorch安装命令如下（通过pip安装）：

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

注意：网络热词里提到了“pytorch安装教程gpu”和“安装pytorch gpu版本总失败”。失败原因90%是CUDA版本、PyTorch版本和显卡驱动版本三者不匹配。务必先使用nvidia-smi命令查看你的驱动版本，然后去PyTorch官网对照兼容的CUDA版本。如果环境复杂，先尝试安装CPU版本 (pip install torch) 验证基础功能，再攻克GPU版本。

除了PyTorch，我们还需要一些数据处理和科学计算的库：

pip install numpy pandas scipy scikit-learn matplotlib seaborn mne

这里特别提一下mne库，它是处理脑电/磁图数据的瑞士军刀，能极大简化我们读取.edf等格式数据、进行滤波、重参考等预处理操作。

2.2 睡眠数据集获取与初探：公开数据是起点

对于睡眠分期，有几个权威的公开数据集，比如Sleep-EDF（包含SC和ST扩展）、SHHS、MASS等。其中Sleep-EDF Database（Sleep-EDF Expanded）是最常用且易于获取的入门数据集，它包含健康的青年和中年人的整夜PSG记录。

我们可以从PhysioNet官网下载。这里假设我们已经下载了某个受试者的数据，通常是一个.edf文件（存储多导生理信号）和一个对应的.xml或.txt文件（存储专家分期标注）。

使用mne库读取数据非常方便：

import mne # 读取EDF文件 raw = mne.io.read_raw_edf('SC4001E0-PSG.edf', preload=True) # 提取我们感兴趣的脑电通道，例如'EEG Fpz-Cz' eeg_channel = 'EEG Fpz-Cz' raw.pick_channels([eeg_channel]) # 查看信号信息 print(raw.info)

接下来，我们需要读取分期标注文件。标注文件通常将整夜睡眠划分为30秒一个的Epoch，并给出每个Epoch的标签（W, R, N1, N2, N3, ?等）。我们需要解析这个文件，将其转换为与信号数据对应的标签数组。

import numpy as np # 假设我们有一个解析标注的函数，返回标签列表 # labels = ['W', 'N1', 'N2', 'W', 'R', ...] # 将字母标签映射为数字，便于模型处理 label_mapping = {'W': 0, 'N1': 1, 'N2': 2, 'N3': 3, 'R': 4} y = np.array([label_mapping[l] for l in labels if l in label_mapping])

一个关键步骤是对齐信号数据与标签。需要计算每个30秒Epoch对应的信号数据点索引。假设采样频率为sfreqHz，那么每个Epoch的长度就是30 * sfreq个采样点。我们需要将连续的脑电信号切割成一个个Epoch，并确保其顺序与标签y完全一致。

sfreq = raw.info['sfreq'] epoch_length_samples = int(30 * sfreq) # 获取原始数据 data, times = raw.get_data(return_times=True) # 计算总共有多少个完整的30秒Epoch n_epochs = len(y) # 确保标签数不超过信号能提供的Epoch数 n_epochs = min(n_epochs, data.shape[1] // epoch_length_samples) # 预分配存储Epoch数据的数组 X = np.zeros((n_epochs, 1, epoch_length_samples)) # 形状: (样本数, 通道数, 时间点) for i in range(n_epochs): start = i * epoch_length_samples end = start + epoch_length_samples X[i, 0, :] = data[0, start:end] # 假设我们只取了一个通道 # 同步裁剪标签 y = y[:n_epochs]

至此，我们得到了特征X和标签y。但直接把这30秒的原始波形扔进模型，往往不是最优解。接下来，我们要进入预处理和特征工程环节。

3. 信号预处理与特征工程：从“毛坯”数据到模型“食材”

原始脑电信号含有大量噪声（工频干扰、肌电、眼电等），且不同受试者间幅度差异可能很大。直接使用原始信号训练，模型可能难以收敛，或把精力浪费在学习无关噪声上。

3.1 必不可少的预处理三板斧

1. 带通滤波：保留睡眠分期相关的有效频率成分。通常，睡眠脑电的活跃频率在0.5Hz到35Hz之间。我们可以使用MNE或Scipy的滤波器。

   from scipy import signal # 设计一个4阶的巴特沃斯带通滤波器 lowcut, highcut = 0.5, 35.0 b, a = signal.butter(4, [lowcut/(sfreq/2), highcut/(sfreq/2)], btype='band') # 对每个Epoch进行滤波（注意避免相位失真，使用filtfilt） for i in range(X.shape[0]): X[i, 0, :] = signal.filtfilt(b, a, X[i, 0, :])

   实操心得：使用filtfilt（零相位滤波）比lfilter更重要，因为它避免了滤波带来的相位偏移，不会扭曲波形时序特征，这对于依赖波形形态的睡眠分期至关重要。

2. 重参考与去噪：对于单通道数据，重参考（比如减去共同平均）不适用。但我们可以考虑简单的去基线漂移，即减去每个Epoch的均值。

   X = X - np.mean(X, axis=2, keepdims=True)

3. 标准化/归一化：这是加速模型收敛的关键。通常采用每个Epoch独立标准化（Epoch-wise Z-score），而不是整个数据集统一标准化。因为睡眠不同阶段的脑电幅度本身差异就很大（N3期慢波振幅很高），全局标准化会压缩这种差异。

   eps = 1e-10 # 防止除零 X = (X - np.mean(X, axis=2, keepdims=True)) / (np.std(X, axis=2, keepdims=True) + eps)

3.2 特征工程：给模型更直接的“线索”

虽然端到端的深度学习模型可以直接从原始信号中学习特征，但对于数据量有限的睡眠分期任务（公开数据集通常只有几十到上百个受试者），引入一些先验知识作为特征，能有效提升模型性能，尤其是缓解N1期（通常最难分）识别率低的问题。

我们可以为每个30秒的Epoch计算一组时域、频域和非线性特征：

• 时域特征：均值、方差、偏度、峰度、Hjorth参数（活动性、移动性、复杂性）。
• 频域特征：这是重中之重。将0.5-35Hz划分为几个经典频带：Delta (0.5-4 Hz), Theta (4-8 Hz), Alpha (8-13 Hz), Beta (13-30 Hz)。计算每个频带的相对功率（该频带功率占总功率的比例）、绝对功率、以及频带功率比（如Alpha/Theta）。
• 非线性特征：近似熵、样本熵、排列熵等，刻画信号的复杂度。

使用scipy.signal的welch方法可以方便地计算功率谱密度（PSD）：

def compute_band_powers(epoch, sfreq): """计算一个Epoch各频带的相对功率""" freqs, psd = signal.welch(epoch, sfreq, nperseg=256) band_def = {'delta': (0.5, 4), 'theta': (4, 8), 'alpha': (8, 13), 'beta': (13, 30)} band_powers = {} total_power = np.trapz(psd, freqs) # 总功率 for band, (low, high) in band_def.items(): idx = np.logical_and(freqs >= low, freqs <= high) band_power = np.trapz(psd[idx], freqs[idx]) band_powers[f'{band}_rel'] = band_power / total_power band_powers[f'{band}_abs'] = band_power # 计算一些比率特征 band_powers['alpha_theta_ratio'] = band_powers['alpha_abs'] / (band_powers['theta_abs'] + eps) return band_powers

然后，我们可以选择将计算出的特征向量与原始的标准化波形拼接起来，作为模型的输入。也可以构建一个双分支模型，一个分支处理波形，一个分支处理特征，最后融合。在项目初期，我建议先尝试纯波形模型和波形+特征拼接模型，对比效果。

4. 模型架构设计与PyTorch实现：构建睡眠分期“专家网络”

睡眠分期是一个典型的序列分类问题，每个样本（30秒Epoch）不是完全独立的，其前后Epoch的状态（上下文）包含了重要信息。例如，从N2期过渡到N3期是常见的，但从REM期直接跳到N3期则很罕见。因此，我们的模型需要具备捕捉时序依赖关系的能力。

4.1 模型选型：为什么是CNN+RNN的混合结构？

目前主流且有效的睡眠分期模型架构通常是CNN（卷积神经网络）与 RNN（循环神经网络）或其变体（如LSTM, GRU）的结合体，有时还会加入注意力机制（Attention）。

• CNN部分：充当“特征提取器”。一维卷积核在时间轴上滑动，可以自动学习到类似Delta波、纺锤波（Sigma波）等局部波形模式。多层卷积和池化能构建层次化的特征表示。
• RNN部分：充当“上下文建模器”。接收CNN提取的每个Epoch的特征序列，学习Epoch之间的转移规律和长程依赖，利用睡眠结构的时序连续性来提升分期准确性，特别是纠正孤立的误分类。

我在这里实现一个较为经典且有效的CNN-LSTM混合模型。

import torch import torch.nn as nn import torch.nn.functional as F class SleepStageCNNLSTM(nn.Module): def __init__(self, input_channels=1, num_classes=5, hidden_size=128, num_lstm_layers=2): super(SleepStageCNNLSTM, self).__init__() # CNN特征提取部分 self.conv1 = nn.Conv1d(in_channels=input_channels, out_channels=64, kernel_size=50, stride=6, padding=25) self.bn1 = nn.BatchNorm1d(64) self.pool1 = nn.MaxPool1d(kernel_size=8, stride=8) self.dropout1 = nn.Dropout(0.5) self.conv2 = nn.Conv1d(in_channels=64, out_channels=128, kernel_size=8, stride=1, padding=4) self.bn2 = nn.BatchNorm1d(128) self.pool2 = nn.MaxPool1d(kernel_size=4, stride=4) self.dropout2 = nn.Dropout(0.5) self.conv3 = nn.Conv1d(in_channels=128, out_channels=256, kernel_size=8, stride=1, padding=4) self.bn3 = nn.BatchNorm1d(256) self.pool3 = nn.MaxPool1d(kernel_size=4, stride=4) self.dropout3 = nn.Dropout(0.5) # 计算经过CNN后的特征维度（需要根据输入长度推算，这里假设输入为30*100=3000点） # 或者更优雅的方式，使用一个前向传播来计算 self._to_linear = None self._get_conv_output((1, 1, 3000)) # LSTM时序建模部分 self.lstm = nn.LSTM(input_size=self._to_linear, hidden_size=hidden_size, num_layers=num_lstm_layers, batch_first=True, bidirectional=True, dropout=0.3) # 全连接分类层 self.fc = nn.Linear(hidden_size * 2, num_classes) # 双向LSTM，所以是hidden_size*2 def _get_conv_output(self, shape): """前向传播一次以计算CNN输出展平后的维度""" batch_size = 1 input = torch.rand(batch_size, *shape[1:]) output = self._forward_features(input) self._to_linear = output.view(batch_size, -1).size(1) return self._to_linear def _forward_features(self, x): """CNN部分的前向传播""" x = F.relu(self.bn1(self.conv1(x))) x = self.pool1(x) x = self.dropout1(x) x = F.relu(self.bn2(self.conv2(x))) x = self.pool2(x) x = self.dropout2(x) x = F.relu(self.bn3(self.conv3(x))) x = self.pool3(x) x = self.dropout3(x) return x def forward(self, x): # x shape: (batch_size, channels, time_points) batch_size, channels, time_points = x.size() # 首先通过CNN提取每个样本的特征 cnn_features = self._forward_features(x) # shape: (batch_size, 256, L') # 将特征图展平，准备送入LSTM cnn_features_flat = cnn_features.view(batch_size, 256, -1).permute(0, 2, 1) # shape: (batch_size, seq_len, feature_size) # seq_len是CNN输出在时间维度上的长度，feature_size是256 # LSTM处理序列 lstm_out, _ = self.lstm(cnn_features_flat) # lstm_out shape: (batch_size, seq_len, hidden_size*2) # 我们取最后一个时间步的输出，或者对所有时间步的输出做平均/最大池化。这里取最后一个时间步。 lstm_last = lstm_out[:, -1, :] # 分类 out = self.fc(lstm_last) return out

设计解析与避坑点：

1. 卷积核大小与步长：第一层用了较大的核（50）和步长（6），目的是快速下采样并捕获较长的波形模式（如慢波）。后续卷积核较小，用于精细特征提取。
2. BatchNorm与Dropout：BatchNorm加速收敛并有一定正则化效果；Dropout是防止过拟合的关键，尤其在数据量不大的睡眠数据上，丢弃率可以设得高一些（0.5）。
3. 双向LSTM：睡眠状态既依赖过去，也依赖未来（回顾性判断）。双向LSTM能同时利用前后上下文信息，在实践中通常比单向LSTM效果更好。
4. 维度计算：CNN输出维度的计算容易出错。上述代码使用_get_conv_output方法进行动态计算，是一种稳健的做法。你需要根据你的输入长度（30 * 采样率）来调整网络结构，确保展平后的维度正确。
5. 输入形状：注意PyTorch中一维卷积的输入形状是(batch_size, channels, length)。我们的数据X形状是(n_epochs, 1, epoch_length_samples)，刚好符合。

4.2 数据处理管道（DataLoader）的构建

PyTorch使用Dataset和DataLoader来高效加载数据。我们需要自定义一个Dataset类。

from torch.utils.data import Dataset, DataLoader class SleepEEGDataset(Dataset): def __init__(self, signals, labels, transform=None): """ signals: numpy array of shape (num_samples, 1, time_points) labels: numpy array of shape (num_samples,) """ self.signals = torch.FloatTensor(signals) self.labels = torch.LongTensor(labels) self.transform = transform def __len__(self): return len(self.labels) def __getitem__(self, idx): signal = self.signals[idx] label = self.labels[idx] if self.transform: signal = self.transform(signal) return signal, label

在划分训练集、验证集和测试集时，务必按受试者划分，而不是随机打乱所有Epoch。这是脑电数据分析的黄金准则，即“留出受试者”（Leave-Subject-Out），以确保评估的是模型对新受试者的泛化能力，而不是记住了特定受试者的噪声模式。

from sklearn.model_selection import train_test_split # 假设我们有多个受试者的数据，存储在一个列表里，每个元素是一个(subject_signals, subject_labels) all_subjects_data = [...] # 列表，每个元素是(信号数组，标签数组) train_subjects, test_subjects = train_test_split(all_subjects_data, test_size=0.2, random_state=42) # 进一步从训练集中划分验证集 train_subjects, val_subjects = train_test_split(train_subjects, test_size=0.125, random_state=42) # 0.125*0.8=0.1 # 将划分好的受试者数据分别合并 def combine_subjects(subject_list): signals = np.vstack([s[0] for s in subject_list]) labels = np.hstack([s[1] for s in subject_list]) return signals, labels X_train, y_train = combine_subjects(train_subjects) X_val, y_val = combine_subjects(val_subjects) X_test, y_test = combine_subjects(test_subjects) # 创建Dataset和DataLoader train_dataset = SleepEEGDataset(X_train, y_train) val_dataset = SleepEEGDataset(X_val, y_val) test_dataset = SleepEEGDataset(X_test, y_test) train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=2) val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=2) test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False, num_workers=2)

5. 模型训练、评估与调优实战：让模型真正学会“分阶段”

有了数据和模型，接下来就是训练循环。这里面的门道也不少。

5.1 损失函数与优化器选择：处理类别不平衡

睡眠分期数据存在严重的类别不平衡。清醒期（W）和N2期通常占大部分，而N1期和REM期占比较少，N3期比例居中。如果使用普通的交叉熵损失，模型会倾向于忽略少数类。

解决方案是使用加权交叉熵损失（Weighted CrossEntropyLoss）。权重与类别频率成反比。

from sklearn.utils.class_weight import compute_class_weight # 计算训练集的类别权重 classes = np.unique(y_train) class_weights = compute_class_weight('balanced', classes=classes, y=y_train) # 转换为Tensor class_weights = torch.FloatTensor(class_weights).to(device) criterion = nn.CrossEntropyLoss(weight=class_weights)

优化器选择Adam或AdamW，学习率初始值设为3e-4或1e-3是比较好的起点。同时，使用学习率调度器（如ReduceLROnPlateau）在验证集性能停滞时降低学习率。

import torch.optim as optim from torch.optim.lr_scheduler import ReduceLROnPlateau model = SleepStageCNNLSTM(input_channels=1, num_classes=5).to(device) optimizer = optim.AdamW(model.parameters(), lr=3e-4, weight_decay=1e-4) scheduler = ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=10, verbose=True) # 监控验证集准确率

5.2 训练循环与早停策略

训练循环是标准流程，但需要仔细设计验证和保存最佳模型的逻辑。

def train_epoch(model, loader, criterion, optimizer, device): model.train() running_loss = 0.0 correct = 0 total = 0 for batch_idx, (data, target) in enumerate(loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() # 梯度裁剪，防止梯度爆炸，在RNN/LSTM中尤其有用 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) optimizer.step() running_loss += loss.item() _, predicted = output.max(1) total += target.size(0) correct += predicted.eq(target).sum().item() epoch_loss = running_loss / len(loader) epoch_acc = 100. * correct / total return epoch_loss, epoch_acc def evaluate(model, loader, criterion, device): model.eval() running_loss = 0.0 correct = 0 total = 0 all_preds = [] all_targets = [] with torch.no_grad(): for data, target in loader: data, target = data.to(device), target.to(device) output = model(data) loss = criterion(output, target) running_loss += loss.item() _, predicted = output.max(1) total += target.size(0) correct += predicted.eq(target).sum().item() all_preds.extend(predicted.cpu().numpy()) all_targets.extend(target.cpu().numpy()) epoch_loss = running_loss / len(loader) epoch_acc = 100. * correct / total return epoch_loss, epoch_acc, np.array(all_preds), np.array(all_targets) # 训练主循环 num_epochs = 100 best_val_acc = 0.0 patience = 20 patience_counter = 0 for epoch in range(num_epochs): train_loss, train_acc = train_epoch(model, train_loader, criterion, optimizer, device) val_loss, val_acc, _, _ = evaluate(model, val_loader, criterion, device) # 学习率调度 scheduler.step(val_acc) print(f'Epoch {epoch+1:03d}: Train Loss: {train_loss:.4f}, Acc: {train_acc:.2f}% | Val Loss: {val_loss:.4f}, Acc: {val_acc:.2f}%') # 保存最佳模型 if val_acc > best_val_acc: print(f'Validation accuracy improved ({best_val_acc:.2f}% --> {val_acc:.2f}%). Saving model...') best_val_acc = val_acc torch.save(model.state_dict(), 'best_sleep_model.pth') patience_counter = 0 else: patience_counter += 1 if patience_counter >= patience: print(f'Early stopping triggered after {epoch+1} epochs.') break

训练技巧：

1. 梯度裁剪：LSTM训练中梯度可能爆炸，裁剪梯度是稳定训练的有效手段。
2. 早停（Early Stopping）：根据验证集性能不再提升来提前终止训练，防止过拟合。耐心值（patience）设为10-20个epoch比较合适。
3. 监控验证集损失和准确率：这是判断模型是否过拟合或欠拟合的核心指标。如果训练损失持续下降但验证损失上升，就是典型的过拟合。

5.3 模型评估：超越整体准确率

在睡眠分期中，由于类别不平衡，整体准确率（Overall Accuracy, OA）会虚高，因为它被大类别主导。我们必须看每个类别的性能。

• 混淆矩阵（Confusion Matrix）：直观展示模型在每个类别上的分类情况，哪里混淆最多（通常是N1期容易被误分为Wake或N2）。
• 宏平均F1分数（Macro-F1）：对每个类别的F1分数取平均，能更好地反映模型对少数类的识别能力。
• Cohen's Kappa系数：衡量分类结果与真实标签的一致性，考虑了随机猜测的概率，比简单准确率更可靠。

from sklearn.metrics import confusion_matrix, classification_report, cohen_kappa_score # 在测试集上评估最佳模型 model.load_state_dict(torch.load('best_sleep_model.pth')) test_loss, test_acc, all_preds, all_targets = evaluate(model, test_loader, criterion, device) print(f'Test Accuracy: {test_acc:.2f}%') print('Cohen\'s Kappa:', cohen_kappa_score(all_targets, all_preds)) print('\nClassification Report:') print(classification_report(all_targets, all_preds, target_names=['Wake', 'N1', 'N2', 'N3', 'REM'])) # 绘制混淆矩阵 import seaborn as sns import matplotlib.pyplot as plt cm = confusion_matrix(all_targets, all_preds) plt.figure(figsize=(8,6)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['W','N1','N2','N3','R'], yticklabels=['W','N1','N2','N3','R']) plt.ylabel('True Label') plt.xlabel('Predicted Label') plt.title('Confusion Matrix') plt.show()

5.4 性能瓶颈分析与调优思路

如果模型性能不佳（比如宏平均F1低于0.7，或N1期召回率极低），可以从以下几个方向排查和优化：

1. 数据层面：

   • 数据增强：对脑电信号进行小幅度的时域拉伸、压缩、添加高斯噪声、随机切片等，可以有限地增加数据多样性。但需谨慎，避免破坏睡眠波形的生理意义。
   • 解决类别不平衡：除了加权损失，可以尝试过采样少数类（如SMOTE的时序变体）或欠采样多数类。更高级的方法是使用焦点损失（Focal Loss），它让模型更关注难分类的样本。
   • 输入表示：除了原始波形，可以尝试将信号转换为时频图（如频谱图、小波变换图）作为二维输入，使用CNN处理图像。这有时能取得更好效果。

2. 模型层面：

   • 更复杂的时序模型：将LSTM替换为Transformer编码器。Transformer的自注意力机制能更好地捕捉长程依赖和全局上下文，近年来在睡眠分期中表现出色。你可以使用PyTorch内置的nn.TransformerEncoder或nn.MultiheadAttention来构建。
   • 多尺度特征融合：在CNN部分使用不同大小的卷积核并行提取特征（Inception思想），以捕获不同时间尺度的波形模式。
   • 注意力机制：在CNN和LSTM之间，或LSTM之后加入注意力层，让模型学会关注对分类最重要的时间点或特征通道。

3. 训练策略：

   • 分层学习率：对CNN特征提取部分设置较小的学习率（微调），对顶部的LSTM和分类层设置较大的学习率。
   • 标签平滑（Label Smoothing）：在损失函数中引入一点不确定性，防止模型对训练数据过度自信，可能提升泛化能力。
   • 集成学习：训练多个不同初始化或不同结构的模型，对它们的预测结果进行投票或平均，这是提升最终性能的“大杀器”。

6. 部署推理与未来展望：从实验代码到实用工具

训练出一个满意的模型后，下一步就是用它对新数据进行分期预测。

6.1 构建推理管道

推理时需要模拟训练时的预处理流程。最好将预处理步骤（滤波、标准化）封装成函数或类，确保训练和推理时的一致性。

def preprocess_single_epoch(raw_signal, sfreq=100): """预处理单个30秒Epoch的信号""" # 1. 滤波 lowcut, highcut = 0.5, 35.0 b, a = signal.butter(4, [lowcut/(sfreq/2), highcut/(sfreq/2)], btype='band') filtered = signal.filtfilt(b, a, raw_signal) # 2. 去基线 filtered = filtered - np.mean(filtered) # 3. 标准化 (使用训练集的全局统计量？还是Epoch自身？推理时建议使用自身统计量，与训练时Epoch-wise保持一致) eps = 1e-10 normalized = (filtered - np.mean(filtered)) / (np.std(filtered) + eps) # 转换为Tensor tensor_signal = torch.FloatTensor(normalized).unsqueeze(0).unsqueeze(0) # shape: (1, 1, time_points) return tensor_signal def predict_sleep_stage(model, raw_signal, device='cpu'): model.eval() with torch.no_grad(): input_tensor = preprocess_single_epoch(raw_signal).to(device) output = model(input_tensor) prob = F.softmax(output, dim=1) pred_class = output.argmax(dim=1).item() return pred_class, prob.cpu().numpy()

对于一整夜的连续数据，你需要滑动窗口（通常是非重叠的30秒窗口）进行预测，并将预测结果拼接成整夜的分期序列。

6.2 项目总结与扩展方向

通过这个项目，我们完整实现了一个基于PyTorch的单通道脑电睡眠分期系统。从数据准备、预处理、模型构建、训练调优到评估推理，覆盖了深度学习项目的全流程。关键经验在于：数据预处理（特别是滤波和标准化）的严谨性、按受试者划分数据的重要性、处理类别不平衡的必要性，以及利用时序上下文（LSTM/Transformer）对提升性能的关键作用。

这个系统可以作为一个强大的基线。在此基础上，你可以尝试以下扩展：

1. 多模态输入：除了单通道脑电，加入眼电（EOG）和肌电（EMG）信号。这些信号对区分REM期（快速眼动）和Wake期（肌电活跃）非常有帮助。模型可以扩展为多通道并行CNN或早期融合。
2. 端到端优化：探索完全端到端的架构，如使用更深的CNN（如ResNet1D）或纯Transformer，省去手工特征工程，让模型自己学习最佳表示。
3. 知识蒸馏：用一个大而复杂的教师模型（如多模态模型）去指导一个小而快的学生模型（如轻量级CNN），使其适合部署在移动或边缘设备上。
4. 迁移学习：在一个大型睡眠数据集上预训练模型，然后在小规模、特定人群（如失眠患者、儿童）的数据集上进行微调，解决数据稀缺问题。

睡眠分期只是脑电信号分析的一个经典应用。这套基于PyTorch的框架，经过适当调整，完全可以迁移到其他脑电分析任务中，比如情绪识别、癫痫检测、脑机接口等。深度学习的魅力就在于，一旦你打通了一个领域的流程，就获得了一把打开许多相似问题之门的钥匙。希望这个详细的实现过程能为你提供扎实的起点和清晰的路径。

本文还有配套的精品资源，点击获取