往期文章
希望了解更多的道友点这里
0. 分享【脑机接口 + 人工智能】的学习之路
1.1 . 脑电EEG代码开源分享 【1.前置准备-静息态篇】
1.2 . 脑电EEG代码开源分享 【1.前置准备-任务态篇】
2.1 . 脑电EEG代码开源分享 【2.预处理-静息态篇】
2.2 . 脑电EEG代码开源分享 【2.预处理-任务态篇】
3.1 . 脑电EEG代码开源分享 【3.可视化分析-静息态篇】
3.2 . 脑电EEG代码开源分享 【3.可视化分析-任务态篇】
4.1 . 脑电EEG代码开源分享 【4.特征提取-时域篇】
4.2 . 脑电EEG代码开源分享 【4.特征提取-频域篇】
4.3 . 脑电EEG代码开源分享 【4.特征提取-时频域篇】
4.4 . 脑电EEG代码开源分享 【4.特征提取-空域篇】
5 . 脑电EEG代码开源分享 【5.特征选择】
6.1 . 脑电EEG代码开源分享 【6.分类模型-机器学习篇】
6.2 . 脑电EEG代码开源分享 【6.分类模型-深度学习篇】
汇总. 专栏：脑电EEG代码开源分享【文档+代码+经验】
0 . 【深度学习】常用网络总结
脑电EEG代码开源分享 【6. 分类模型-深度学习篇】
一、前言
本文档旨在归纳BCI-EEG-matlab的数据处理代码，作为EEG数据处理的总结，方便快速搭建处理框架的Baseline，实现自动化、模块插拔化、快速化。本文以任务态（锁时刺激，如快速序列视觉呈现）为例，分享脑电EEG的分析处理方法。
脑电数据分析系列。分为以下6个模块：
- 前置准备
- 数据预处理
- 数据可视化
- 特征提取（特征候选集）
- 特征选择（量化特征择优）
- 分类模型
本文内容：【6. 分类模型-深度学习篇】】
提示：以下为各功能代码详细介绍，若节约阅读时间，请下滑至文末的整合代码
二、分类模型 框架介绍
分类模型-深度学习篇主要介绍了 基础 的 网络结构框架 ，将深度学习解决脑电领域问题，形成【BCI + AI】的处理框架，为脑机接口的科研开辟了新赛道、新领域。
如果深入介绍 EEG+深度网络，恐怕3个系列都包含不了，本文作为 脑电+AI 的科普，和大家一起探讨深度网络的应用模式。本文介绍了3种经典模型架构，分别是：图像领域的卷积神经网络（CNN），语音领域的长短时记忆网络（LSTM）,社交领域的图神经网络（GNN）。展示了目前神经网络在脑电领域的常用方法，在此框架上优化改进的结构层出不穷，大家可以根据自己的任务需要和数据特点，神经网络的灵活性和模块化方便广大学者尝试和探索。
本文中的3种框架提供了3种思路，为最长程度发挥各神经网络结构自身长处，建议根据每种网络结构特长选择适用的脑电表征形式。例如， CNN 卷积核擅长捕捉图像轮廓和色彩信息，我们可以将脑电输入格式改为 雨谱图、脑地形图等可视化图像呈现方式。例如，LSTM能有效提取时序信号的前后语义特征，脑电信号输入格式应倾向保留原始时序信息。GNN图卷积关注拓补结构，应将脑电数据处理为导联间连接关系。
前文我们花了4篇文章讲完了时域、频域、时频域、空域的特征提取，并应用特征选择方法筛选出了优质特征，终于迎来尾声的分类模型，打通了从原始数据到分类结果的全流程。
分类模型的代码框图、流程如下所示：
分类模型的主要功能，分为以下7部分：
- CNN 卷积神经网络
- LSTM 长短时记忆网络
- GNN 图神经网络
-
CNN 卷积神经网络：卷积核（滤波器）在图片上方滑动，对相应感受野内的图像信息进行加权求和，经过卷积核处理后的输出为特征图（feature map）。多个不同卷积核分别对图像进行特征提取运算，获得多种角度的特征输出层。一般认为底层的卷积核提取明暗、色彩、轮廓等低级特征，高层的卷积核获得语义、整体的高级特征。大家了解CNN基础后会发现，卷积核一般为方形，尤其适用于计算机视觉的图像处理，因此CNN多应用于图像分析领域。若想将脑电信号也转换为相应的图像形式，推荐大家尝试将各导联脑电数据转换成时频雨谱图，再将雨谱图纵向拼接起来形成格式为 雨谱图 * 导联数，这样卷积核正面扫过的区域就有了脑电的时频图像特征。或者大家希望保留脑电时空特征，可以绘制不同时刻的脑地形图，并将脑电图纵向排列，形成脑地形图 * 时间的格式。总之，卷积核面向的脑电数据尽量具有图像结构。
脑电转换为图片形式输入：
CNN框架举例：
-
LSTM 长短时记忆网络：LSTM提出后称霸语音领域多年，其中心思想保留了RNN（循环神经网络）的前后语义关联性：本输出作为下一阶段输入，特色在于其三扇门：遗忘门，输入门，输出门，可以更长跨距的保留先前输入的信息不被遗忘。本人亲测过LSTM简单结构，在脑电原始信号处理中就很好使。个人经验在脑电领域的LSTM优于CNN，从脑电高分辨率的时序优势也可以理解，推荐大家尝试。注：建议大家入门LSTM时不要苦读代码或者原文，搜索CSDN上的LSTM动图讲解等关键词，极其方便理解。
LSTM原理示意图：
-
GNN 图神经网络：脑电信号是由分布在大脑各个区域的电极采集而来，脑电信号的各个通道之间存在空间关系或者是拓扑信息。图的构造需要3个部分：节点、特征和边集。脑电数据是由许多个电极采集，将分布在大脑不同位置的电极通道作为图的节点。不同的采集设备有不同的通道数，目前常用的有16通道、32通道、64通道和128通道。特征就是每个通道采集的数据，可以是原始采集的数据，也可以是手工提取的特征如PSD、DE特征等。
GNN网络框架举例：
三、脑电特征选择 代码
提示：Python3.8，torch1.9.1
提示：入门级框架介绍，之后会出专栏介绍【脑电 + 深度学习】
3.0 参数设置
主要参数设置：
LR学习率：0.0001
Batch_size ：128
Epoch ：30
Loss损失函数：CrossEntropyLoss
optim优化器：Adam
网络初始化：kaiming_uniform_
运算设备：GPU
3.1 深度网络-基础代码
3.1.1 CNN 卷积网络
重要参数：卷积层数、卷积核尺寸，池化层、激活函数
class my_cnn(nn.Module):
def __init__(self):
super(my_cnn, self).__init__() # 继承__init__功能
# 第一层卷积
self.feature = nn.Sequential(
#1
nn.Conv2d(
in_channels=16,
out_channels=24,
#kernel_size=(param[para_loop][0],param[para_loop][1]),
kernel_size=(9,7),
stride=1,
padding = (0,0),
),
nn.ReLU(),
nn.MaxPool2d(kernel_size=(2,2)),
#2
nn.Conv2d(
in_channels=24,
out_channels=28,
kernel_size=(12,8),
stride=1,
padding = (0,0),
),
nn.ReLU(),
nn.MaxPool2d(kernel_size=(4,4)),
#3
nn.Conv2d(
in_channels=28,
out_channels=32,
kernel_size=(6,4),
stride=1,
padding = (0,0),
),
nn.ReLU(),
# nn.MaxPool2d(kernel_size=(2,2)),
)
self.classification = nn.Sequential(
# nn.Dropout(p=0.5),
#nn.Linear(in_features=16 * param[para_loop][2] * param[para_loop][3], out_features=64),
nn.Linear(in_features=32 * 3 * 2, out_features=32), # nn.Dropout(p=0.5),
# nn.Dropout(p=0.5),
nn.Linear(in_features=32 , out_features=2),
)
def forward(self, x):
x = self.feature(x)
temp = x.view(x.shape[0], -1)
output = self.classification(temp)
return output, x
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
device ="cpu"
cnn_model = my_cnn().to(device)
print(cnn_model)
3.1.2 LSTM 长短时记忆网络
LSTM网络-网络框架核心代码：
# 定义LSTM网络模型
class my_lstm(nn.Module):
def __init__(self):
super(my_lstm, self).__init__()
self.rnn = nn.LSTM( # if use nn.RNN(), it hardly learns
input_size=INPUT_SIZE, # 输入维度
hidden_size=50, # 隐藏层神经元节点个数
num_layers=2, # 神经元层数
batch_first=True, # input & output will has batch size as 1s dimension. e.g. (batch, time_step, input_size)
bidirectional = True,
)
self.out =nn.Sequential(
nn.Dropout(p=0.5),
nn.Linear(100, 2) ,
)
def forward(self, x):
# x shape (batch, time_step, input_size)
# r_out shape (batch, time_step, output_size)
# h_n shape (n_layers, batch, hidden_size)
# h_c shape (n_layers, batch, hidden_size)
r_out, (h_n, h_c) = self.rnn(x, None) # h_n就是h状态，h_c就是细胞的状态
# choose r_out at the last time step
out = self.out(r_out[:, -1, :]) # 我们只要每一个time_step里的最后的一个。比如64个矩阵，每个28*28,我们只要每一个的第28次的那个数据。
return out
device = torch.device("cuda:3" if torch.cuda.is_available() else "cpu")
lstm_model = my_lstm().to(device)
print(lstm_model)
3.1.3 GNN-图卷积网络
GCN图卷积神经网络-网络框架核心代码：
import numpy as np
class Graph():
""" The Graph to model the skeletons extracted by the openpose
Args:
strategy (string): must be one of the follow candidates
- uniform: Uniform Labeling
- distance: Distance Partitioning
- spatial: Spatial Configuration
For more information, please refer to the section 'Partition Strategies'
in our paper (https://arxiv.org/abs/1801.07455).
layout (string): must be one of the follow candidates
- openpose: Is consists of 18 joints. For more information, please
refer to https://github.com/CMU-Perceptual-Computing-Lab/openpose#output
- ntu-rgb+d: Is consists of 25 joints. For more information, please
refer to https://github.com/shahroudy/NTURGB-D
max_hop (int): the maximal distance between two connected nodes
dilation (int): controls the spacing between the kernel points
"""
def __init__(self,
layout='openpose',
strategy='uniform',
max_hop=1,
dilation=1):
self.max_hop = max_hop
self.dilation = dilation
self.get_edge(layout)
self.hop_dis = get_hop_distance(
self.num_node, self.edge, max_hop=max_hop)
self.get_adjacency(strategy)
def __str__(self):
return self.A
def get_edge(self, layout):
if layout == 'openpose':
self.num_node = 18
self_link = [(i, i) for i in range(self.num_node)]
neighbor_link = [(4, 3), (3, 2), (7, 6), (6, 5), (13, 12), (12,
11),
(10, 9), (9, 8), (11, 5), (8, 2), (5, 1), (2, 1),
(0, 1), (15, 0), (14, 0), (17, 15), (16, 14)]
self.edge = self_link + neighbor_link
self.center = 1
elif layout == 'ntu-rgb+d':
self.num_node = 25
self_link = [(i, i) for i in range(self.num_node)]
neighbor_1base = [(1, 2), (2, 21), (3, 21), (4, 3), (5, 21),
(6, 5), (7, 6), (8, 7), (9, 21), (10, 9),
(11, 10), (12, 11), (13, 1), (14, 13), (15, 14),
(16, 15), (17, 1), (18, 17), (19, 18), (20, 19),
(22, 23), (23, 8), (24, 25), (25, 12)]
neighbor_link = [(i - 1, j - 1) for (i, j) in neighbor_1base]
self.edge = self_link + neighbor_link
self.center = 21 - 1
elif layout == 'ntu_edge':
self.num_node = 24
self_link = [(i, i) for i in range(self.num_node)]
neighbor_1base = [(1, 2), (3, 2), (4, 3), (5, 2), (6, 5), (7, 6),
(8, 7), (9, 2), (10, 9), (11, 10), (12, 11),
(13, 1), (14, 13), (15, 14), (16, 15), (17, 1),
(18, 17), (19, 18), (20, 19), (21, 22), (22, 8),
(23, 24), (24, 12)]
neighbor_link = [(i - 1, j - 1) for (i, j) in neighbor_1base]
self.edge = self_link + neighbor_link
self.center = 2
# elif layout=='customer settings'
# pass
else:
raise ValueError("Do Not Exist This Layout.")
#计算邻接矩阵A
def get_adjacency(self, strategy):
valid_hop = range(0, self.max_hop + 1, self.dilation) #range(start,stop,step)
adjacency = np.zeros((self.num_node, self.num_node))
for hop in valid_hop:
adjacency[self.hop_dis == hop] = 1
normalize_adjacency = normalize_digraph(adjacency)
unnormalize_adjacency = normalize_undigraph(adjacency)
if strategy == 'uniform':
A = np.zeros((1, self.num_node, self.num_node))
A[0] = normalize_adjacency
self.A = A
elif strategy == 'distance':
A = np.zeros((len(valid_hop), 18, 18))
for i, hop in enumerate(valid_hop):
A[i][self.hop_dis == hop] = normalize_adjacency[self.hop_dis ==
hop]
self.A = A
elif strategy == 'spatial':
A = []
for hop in valid_hop:
a_root = np.zeros((self.num_node, self.num_node))
a_close = np.zeros((self.num_node, self.num_node))
a_further = np.zeros((self.num_node, self.num_node))
for i in range(self.num_node):
for j in range(self.num_node):
if self.hop_dis[j, i] == hop:
if self.hop_dis[j, self.center] == self.hop_dis[
i, self.center]:
a_root[j, i] = normalize_adjacency[j, i]
elif self.hop_dis[j, self.
center] > self.hop_dis[i, self.
center]:
a_close[j, i] = normalize_adjacency[j, i]
else:
a_further[j, i] = normalize_adjacency[j, i]
if hop == 0:
A.append(a_root)
else:
A.append(a_root + a_close)
A.append(a_further)
A = np.stack(A)
self.A = A
else:
raise ValueError("Do Not Exist This Strategy")
# 此函数的返回值hop_dis就是图的邻接矩阵
def get_hop_distance(num_node, edge, max_hop=1):
A = np.zeros((num_node, num_node))
for i, j in edge:
A[j, i] = 1
A[i, j] = 1
# compute hop steps
hop_dis = np.zeros((num_node, num_node)) + np.inf # np.inf 表示一个无穷大的正数
# np.linalg.matrix_power(A, d)求矩阵A的d幂次方,transfer_mat矩阵(I,A)是一个将A矩阵拼接max_hop+1次的矩阵
transfer_mat = [np.linalg.matrix_power(A, d) for d in range(max_hop + 1)]
# (np.stack(transfer_mat) > 0)矩阵中大于0的返回Ture,小于0的返回False,最终arrive_mat是一个布尔矩阵,大小与transfer_mat一样
arrive_mat = (np.stack(transfer_mat) > 0)
# range(start,stop,step) step=-1表示倒着取
for d in range(max_hop, -1, -1):
# 将arrive_mat[d]矩阵中为True的对应于hop_dis[]位置的数设置为d
hop_dis[arrive_mat[d]] = d
return hop_dis
# 将矩阵A中的每一列的各个元素分别除以此列元素的形成新的矩阵
def normalize_digraph(A):
Dl = np.sum(A, 0) #将矩阵A压缩成一行
num_node = A.shape[0]
Dn = np.zeros((num_node, num_node))
for i in range(num_node):
if Dl[i] > 0:
Dn[i, i] = Dl[i]**(-1)
AD = np.dot(A, Dn)
return AD
def normalize_undigraph(A):
Dl = np.sum(A, 0)
num_node = A.shape[0]
Dn = np.zeros((num_node, num_node))
for i in range(num_node):
if Dl[i] > 0:
Dn[i, i] = Dl[i]**(-0.5)
DAD = np.dot(np.dot(Dn, A), Dn)
return DAD
总结
科学家认为深度学习目前的瓶颈需要人脑结构的启发，类脑智能逐渐兴起，
人脑智能的感知能力 + 机器智能的高效处理，混合智能在不断探索。
深度学习+脑机交互 提供了新的结合和思路，
深度网络作为工具用于脑电数据的分类和解码仅是浅层应用。
深度网络结构为研究人员提供了很大的灵活性和自由度，
在大数据的数据驱动模式下可以获得优异性能。
matlab 可视化友好，python 搭建网络友好，
建议新手在数据处理及可视化阶段使用Matlab 分析查看数据，
搭建网络时使用pytorch构建深度网络框架，可以较大发挥各平台的优势。
囿于能力，挂一漏万，如有笔误请大家指正~
感谢您耐心的观看，本系列更新了约30000字，约3000行开源代码，体量相当于一篇硕士工作。
往期内容放在了文章开头，麻烦帮忙点点赞，分享给有需要的朋友~
坚定初心，本博客永远：
免费拿走，全部开源，全部无偿分享~
To：新想法、鬼点子的道友：
自己：脑机接口+人工智领域，主攻大脑模式解码、身份认证、仿脑模型…
在读博士第3年，在最后1年，希望将代码、文档、经验、掉坑的经历分享给大家~
做的不好请大佬们多批评、多指导~ 虚心向大伙请教！
想一起做些事情 or 奇奇怪怪点子 or 单纯批评我的，请至[email protected]
)