python实现运动想象二分类任务

最新推荐文章于 2024-05-09 20:43:47 发布

酱龙搬砖王

最新推荐文章于 2024-05-09 20:43:47 发布

阅读量776

点赞数 20

文章标签： python 分类

本文链接：https://blog.csdn.net/frankprok/article/details/135899905

版权

一、前言

本次实验利用python进行运动想象二分类任务，被本次分类任务是这几个星期以来做的第一次分类实验也是本人进行运动想象学习的第一个分类，代码简单希望对大家有帮助这个实验也是本人在这段学习时间当中的一些心得，大家也可以一起在评论区下面发表自己的见解，一起交流学习进步

本人的运动想象学习笔记与心得都已上传至GitHub:https://github.com/XCZchaos/python-implementation-of-motion-imagination-classificationhttps://github.com/XCZchaos/python-implementation-of-motion-imagination-classification

二、数据集获取

百度网盘：

链接：https://pan.baidu.com/s/1ZmiMT3vNFb0XsBd30K7TZA
提取码：2424

三、代码部分

1.导包

import numpy as np
import matplotlib.pyplot as plt
import mne
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.metrics import accuracy_score,roc_curve,auc  
from make_mymodel.csp import CSP
import os
from sklearn.svm import SVC

2.文件读取

本次文件的读取使用了比较笨的方法，也可以利用os中的方法快速进行文件夹下的文件读取，并创建raw对象，再对raw对象进行滤波处理，本文处理的脑电数据步骤较为简单，可以继续尝试完成脑电数据的预处理操作，如在运动想象中可以对raw对象处理，比如使用选择C3、Cz、C4这三个通道，这三个通道对运动想象的影响较其他通道更大，可以减少数据噪声。

另外在本人学习的途中需要学习一些滤波知识，推荐了解一下scipy科学计算库，其中有构建滤波器的部分，但是在mne中的filter方法有传统的滤波器可供选择。其中值得注意的是，当对象是Epochs的时候，这个时候就要使用get_data()方法进行滤波了。

ps：可以利用plot_pds()方法观察raw对象的频谱图，本次实验中没有演示

raw = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R03.edf',preload=True)
raw.filter(8,15)
raw1 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R04.edf',preload=True)
raw1.filter(8,15)
raw2 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R05.edf',preload=True)
raw2.filter(8,15)
raw3 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R06.edf',preload=True)
raw3.filter(8,15)
raw4 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R07.edf',preload=True)
raw4.filter(8,15)
raw5 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R08.edf',preload=True)
raw5.filter(8,15)
raw6 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R09.edf',preload=True)
raw6.filter(8,15)
raw7 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R10.edf',preload=True)
raw7.filter(8,15)
raw8 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R11.edf',preload=True)
raw8.filter(8,15)
raw9 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R12.edf',preload=True)
raw9.filter(8,15)
raw10 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R13.edf',preload=True)
raw10.filter(8,15)
raw11 = mne.io.read_raw_edf('C:\\Users\\24242\\Desktop\\AI_Reference\\data_bag\\EEG-files\\S001\\S001R11.edf',preload=True)
raw11.filter(8,15)

3.选取指定的事件数据和标签

自定义函数进行事件的选取，得到数据和标签

本次也是用最笨的方法获取数据和标签，也可以进行优化代码的操作

def choose_event_Epochs_data(raw):
    event,event_id = mne.events_from_annotations(raw)
    event_pick_id = [2,3]
    pick_event = mne.pick_events(event,include=event_pick_id)
    event_new_id = {'T1':2,'T2':3}
    epochs = mne.Epochs(raw,pick_event,event_new_id,tmin=-1,tmax=5,preload=True)
    label = epochs.events[:,-1]
    epochs.load_data().filter(l_freq=8,h_freq=12)
    data = epochs.get_data()
    print(data.shape,label.shape)
    return data,label

data,label = choose_event_Epochs_data(raw)
data1,label1 = choose_event_Epochs_data(raw1)
data2,label2 = choose_event_Epochs_data(raw2)
data3,label3 = choose_event_Epochs_data(raw3)
data4,label4 = choose_event_Epochs_data(raw4)
data5,label5 = choose_event_Epochs_data(raw5)
data6,label6 = choose_event_Epochs_data(raw6)
data7,label7 = choose_event_Epochs_data(raw7)
data8,label8 = choose_event_Epochs_data(raw8)
data9,label9 = choose_event_Epochs_data(raw9)
data10,label10 = choose_event_Epochs_data(raw10)
data11,label11 = choose_event_Epochs_data(raw11)

4.将选取的事件数据和标签联合

进行数据联合和标签联合从而得到训练数据和测试数据

def gather_data(data,data1,label,label1):
    data2 = np.concatenate((data,data1),axis=0)
    label2 = np.append(label,label1)
    return data2,label2

data_2,label_2 = gather_data(data,data1,label,label1)
data_3,label_3 = gather_data(data_2,data2,label_2,label2)
data_4,label_4 = gather_data(data_3,data3,label_3,label3)
data_5,label_5 = gather_data(data_4,data4,label_4,label4)
data_6,label_6 = gather_data(data_5,data5,label_5,label5)
data_all,label_all = gather_data(data_6,data6,label_6,label6)
data_all,label_all = gather_data(data_all,data7,label_all,label7)
Test_data,Test_label = gather_data(data8,data9,label8,label9)
Test_data,Test_label = gather_data(Test_data,data10,Test_label,label10)
Test_data,Test_label = gather_data(Test_data,data11,Test_label,label11)

5.构建CSP并将数据进行转换

csp = CSP(n_components=10)
X_csp_all = csp.fit_transform(data_all,label_all)
Test_data_csp = csp.transform(Test_data)
X_csp_all.shape,Test_data_csp.shape

6.利用SVM进行分类

svc = SVC(kernel='linear')
svc.fit(X_csp_all,label_all)
y_pred = svc.predict(Test_data_csp)
acc = accuracy_score(Test_label,y_pred)

7.LDA分类器进行分类

构建lda模型进行分类，并将标签进行转换成-1和1 进行ROC曲线的绘制

lda = LinearDiscriminantAnalysis()
lda.fit(X_csp_all,label_all)
pred_lda = lda.predict(Test_data_csp)
print(accuracy_score(y_pred=pred_lda,y_true=Test_label))
y_score = lda.predict_proba(Test_data_csp)[:,1]
print(y_score)
print(lda.predict(Test_data_csp))
new_Test_label = []
for i in Test_label:
    if i == 2:
        new_Test_label.append(-1)
    else:
        new_Test_label.append(1)
print(new_Test_label)

fpr,tpr,thresholds = roc_curve(y_true=new_Test_label,y_score=y_score)
roc_acu = auc(fpr,tpr)

plt.figure(figsize=(8,8))
plt.plot(fpr,tpr,color='darkorange',lw=2,label='ROC curve(ACU={:.2f})'.format(roc_acu))
plt.plot([0, 1], [0, 1],color='navy',lw=2,linestyle='--',label='Random Guess')

plt.xlabel('Flase Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC) Curve')
plt.legend(loc='lower right')
plt.show()

8.研究CSP中的n_component参数对分类结果的影响

# 计算精度与CSP共空间模式中n_component的数量对LDA分类器的影响
component_num = [2,4,6,8,10,12,14,16,18,20]
acc_list = []
for i in component_num:
    csp = CSP(n_components=i)
    X_csp_all = csp.fit_transform(data_all,label_all)
    Test_data_csp = csp.transform(Test_data)
    lda = LinearDiscriminantAnalysis()
    lda.fit(X_csp_all,label_all)
    pred_lda = lda.predict(Test_data_csp)
    acc_lda = accuracy_score(y_true=Test_label,y_pred=pred_lda)
    acc_list.append(acc_lda)
print(acc_list)

def plot_acc(X,Y):
    plt.figure(figsize=(8,8))
    plt.plot(X,Y)
    plt.xlabel('different model')
    plt.ylabel('Acc')

plot_acc(component_num,acc_list)

四、总结

本次实验知识一次简单的分类任务，不涉及复杂的数据预处理，可以视为一个小demo。

在运动想象中CSP共空间模式较为重要，推荐脑机接口社区的CSP共空间模式原理讲解。

本人水平有限，但是会持续分享相关的学习心得，分享也是学习动力之一，也欢迎大家在评论区分享讨论。