2 lines (1 with data), 78.9 kB

{"cells":[{"cell_type":"markdown","metadata":{"id":"USaorKo7DP9B"},"source":["# Base"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":85525,"status":"ok","timestamp":1662649476293,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"gr2Cj9rxQ_NT","outputId":"3f7f61be-7b4e-408b-d8ff-c648db5aa11f"},"outputs":[],"source":["import os\n","import torch\n","import torch.nn as nn\n","import torch.optim as optim\n","from torch.utils.data import Dataset\n","import matplotlib.pyplot as plt \n","import numpy as np\n","import random\n","import json\n","import seaborn as sns\n","from tqdm import tqdm"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["DIR_DATA=\"/content/data/Dataset/\" #Path where your dataset (training) files are stored, this folder contains WESADECG_S2.json,WESADECG_S3.json,...WESADECG_Sk.json files\n","DIR_NET_SAVING=\"/content/data/Testing/net/\" #Path where model's weights are saved for each training\n","DIR_DATA_TEST=\"/content/data/Testing/\" # Path to your file that contains subject test folder (S17 for my case). eg : DIR_TESTING_FOLDER=/content/data/Testing/\n","SUBJECT_USED_FOR_TESTING = \"S17\""]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":260,"status":"ok","timestamp":1662654370451,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"tD21rCOk06Zx","outputId":"b172ea09-50d8-4548-a7fe-244d47a6879c"},"outputs":[],"source":["manualSeed=1\n","torch.manual_seed(manualSeed)\n","random.seed(manualSeed)\n","np.random.seed(manualSeed)\n","g = torch.Generator()\n","g.manual_seed(manualSeed)"]},{"cell_type":"markdown","metadata":{"id":"o4lE6XdnkRCt"},"source":["# Functions"]},{"cell_type":"code","execution_count":3,"metadata":{"executionInfo":{"elapsed":244,"status":"ok","timestamp":1662652451549,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"emSxBk7ikS5m"},"outputs":[],"source":["def suppr(dic):\n","  bornemax=np.quantile(dic[\"features\"],0.99,axis=0)\n","  bornemin=np.quantile(dic[\"features\"],0.01,axis=0)\n","  indicesmauvais=np.where(np.sum(np.add(bornemin>np.array(dic[\"features\"]),np.array(dic[\"features\"])>bornemax),axis=1)>0)[0]\n","  k=0\n","  for i in indicesmauvais:\n","    del dic[\"features\"][i-k]\n","    del dic[\"label\"][i-k]\n","    k+=1\n","  return dic\n","\n","def extract_ds_from_dict(data):\n","  Letat=[]\n","  for i in range(0,4):\n","    dictio={}\n","    features=[data[\"features\"][j] for j in np.where(np.array(data[\"label\"])==i+1)[0]] \n","    label=[data[\"label\"][j] for j in np.where(np.array(data[\"label\"])==i+1)[0]]\n","    dictio[\"features\"]=features\n","    dictio[\"label\"]=label\n","    Letat.append(dictio.copy())\n","  neutr=Letat[0]\n","  stress=Letat[1]\n","  amu=Letat[2]\n","  med=Letat[3]\n","  neutr=suppr(neutr)\n","  stress=suppr(stress)\n","  amu=suppr(amu)\n","  med=suppr(med)\n","  features=[]\n","  label=[]\n","  dict_id={}\n","  for m in range(0,4):\n","    dictio=Letat[m]\n","    features+=[x for x in dictio[\"features\"]] \n","    label+=[x for x in dictio[\"label\"]]\n","  dict_id[\"features\"]=features\n","  dict_id[\"label\"]=label\n","  return dict_id.copy()   #retourne une liste avec tt\n","\n","def conf_mat(net,datal,trsh):\n","  x=datal[0].float().to(device)\n","  y=net(x).view(-1)\n","  pred=(y>trsh).int()\n","  label=datal[1].float().to(device).view(-1).int()\n","  num=datal[2].float().to(device).int()\n","  comp=torch.eq(label,pred).int()\n","  mat_label=np.zeros((2,4))\n","  mat_nolbl=np.zeros((2,2))\n","  for i in range(0,4):\n","    tens=torch.where(num==i+1,1,0)\n","    numtot=torch.sum(tens).item()\n","    num_G=torch.sum(torch.where(torch.mul(tens,comp)==1,1,0)).item()\n","    if i ==1:\n","      mat_nolbl[0,0]+=num_G\n","      mat_nolbl[1,0]+=numtot-num_G\n","      mat_label[0,i]=num_G\n","      mat_label[1,i]=numtot-num_G\n","    else:\n","      mat_nolbl[1,1]+=num_G\n","      mat_nolbl[0,1]+=numtot-num_G\n","      mat_label[1,i]=num_G\n","      mat_label[0,i]=numtot-num_G\n","  return mat_label,mat_nolbl\n","\n","def fusion_dic(list_dic):\n","  features=[]\n","  label=[]\n","  dic_f={}\n","  for dic in list_dic:\n","    features+=dic[\"features\"]\n","    label+=dic[\"label\"]\n","  dic_f[\"features\"]=features\n","  dic_f[\"label\"]=label\n","  return dic_f\n","\n","def proportion(dic, indice, prop):\n","  tot=len(indice)\n","  features=[dic[\"features\"][j] for j in indice[::int(np.ceil(tot/prop))]]\n","  label=[dic[\"label\"][j] for j in indice[::int(np.ceil(tot/prop))]]\n","  return features,label\n","\n","def eq_dic(dic):\n","  indice_neutr=np.where(np.array(dic[\"label\"])==1)[0]\n","  indice_stress=np.where(np.array(dic[\"label\"])==2)[0]\n","  indice_amu=np.where(np.array(dic[\"label\"])==3)[0]\n","  indice_med=np.where(np.array(dic[\"label\"])==4)[0]\n","  nbr_neutr=len(indice_neutr)\n","  nbr_stress=len(indice_stress)\n","  nbr_amu=len(indice_amu)\n","  nbr_med=len(indice_med)\n","  prop=min([3*nbr_neutr,nbr_stress,3*nbr_amu,3*nbr_med])\n","  prop_stress=prop\n","  prop_neutr=int(0.333*prop)\n","  prop_amu=int(0.333*prop)\n","  prop_med=int(0.333*prop)\n","  features=[]\n","  label=[]\n","  dic_f={}\n","  tempf,templ=proportion(dic,indice_neutr,prop_neutr)\n","  features+=tempf\n","  label+=templ\n","  tempf,templ=proportion(dic,indice_stress,prop_stress)\n","  features+=tempf\n","  label+=templ\n","  tempf,templ=proportion(dic,indice_amu,prop_amu)\n","  features+=tempf\n","  label+=templ\n","  tempf,templ=proportion(dic,indice_med,prop_med)\n","  features+=tempf\n","  label+=templ\n","  dic_f[\"features\"]=features\n","  dic_f[\"label\"]=label\n","  return dic_f"]},{"cell_type":"markdown","metadata":{"id":"88CdoUVQrpaA"},"source":["# DS creation kfold"]},{"cell_type":"code","execution_count":4,"metadata":{"executionInfo":{"elapsed":269,"status":"ok","timestamp":1662652455279,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"UNrIGSslSwbF"},"outputs":[],"source":["class ds_wesad(Dataset):\n","    def __init__(self, dic):\n","        self.samples = []\n","        self.dic=dic\n","        for i in range(0,len(dic[\"label\"])):\n","            num=dic[\"label\"][i]\n","            stress=num==2\n","            x=np.array(dic[\"features\"][i])\n","            self.samples.append((x,int(stress),num))\n","\n","    def __len__(self):\n","        return len(self.samples)\n","\n","    def __getitem__(self, id):\n","        return self.samples[id]"]},{"cell_type":"code","execution_count":10,"metadata":{"executionInfo":{"elapsed":684,"status":"ok","timestamp":1662652641841,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"b4IOf8QSykqB"},"outputs":[],"source":["\"\"\"Handles the cross validation process, generates the multiple training and validation data dictionnaries for the cross validation\"\"\"\n","\n","\n","name_list= ['WESADECG_S2.json', 'WESADECG_S3.json', 'WESADECG_S4.json', 'WESADECG_S5.json', 'WESADECG_S6.json', 'WESADECG_S7.json',\n"," 'WESADECG_S8.json', 'WESADECG_S9.json', 'WESADECG_S10.json', 'WESADECG_S11.json', 'WESADECG_S13.json', 'WESADECG_S14.json',\n"," 'WESADECG_S15.json', 'WESADECG_S16.json']\n","\n","#assert (len(name_list)==14)  ONE Subject for testing S17\n","list_dic_ds=[]\n","cntr=0\n","\n","L=[]\n","for i in range(0,len(name_list)):\n","    f=open(DIR_DATA+name_list[i])\n","    data = json.load(f)\n","    dic=eq_dic(data)\n","    L.append(dic)\n","dic_merge = fusion_dic(L)\n","dic_training=extract_ds_from_dict(dic_merge)\n","ds_training=ds_wesad(dic_training)"]},{"cell_type":"code","execution_count":13,"metadata":{"executionInfo":{"elapsed":262,"status":"ok","timestamp":1662652668441,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"pXi9BUzeMZ0I"},"outputs":[],"source":["os.chdir(\"/content/data/Testing\")\n","name= 'WESADECG_{}.json'.format(SUBJECT_USED_FOR_TESTING)\n","f=open(DIR_DATA_TEST+name)\n","data = json.load(f)\n","ds_test = ds_wesad(data)"]},{"cell_type":"markdown","metadata":{"id":"VZVLgHmjVhGa"},"source":["# Model"]},{"cell_type":"code","execution_count":17,"metadata":{"executionInfo":{"elapsed":253,"status":"ok","timestamp":1662654385865,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"PN7Ya-GyVgDe"},"outputs":[],"source":["from torch.nn.modules.activation import LeakyReLU\n","\"\"\" DNN Model \"\"\"\n","\n","def init_weight(m):\n","    \"\"\"Initialization of the weights\"\"\"\n","    if isinstance(m,nn.Linear):\n","        nn.init.xavier_uniform_(m.weight)\n","        m.bias.data.fill_(0.01)\n","    if isinstance(m, nn.BatchNorm1d):\n","        m.weight.data.fill_(1)\n","        m.bias.data.zero_() \n","\n","class ClassifierECG(nn.Module):\n","    \"\"\"DNN model, see the model architecture in the report for more details\"\"\"\n","    def __init__(self, ngpu):\n","        super(ClassifierECG, self).__init__()\n","        self.ngpu = ngpu\n","        self.nnECG = nn.Sequential(\n","            nn.Linear(12,128,bias=True),\n","            nn.BatchNorm1d(128),\n","            nn.Dropout(0.5),\n","            nn.LeakyReLU(0.2),\n","            nn.Linear(128,64,bias=True),\n","            nn.BatchNorm1d(64),\n","            nn.Dropout(0.5),\n","            nn.LeakyReLU(0.2),\n","            nn.Linear(64,16,bias=True),\n","            nn.BatchNorm1d(16),\n","            nn.Dropout(0.5),\n","            nn.LeakyReLU(0.2),\n","            nn.Linear(16,4,bias=True),\n","            nn.BatchNorm1d(4),\n","            nn.Dropout(0.5),\n","            nn.LeakyReLU(0.2),\n","            nn.Linear(4,1,bias=True),\n","            nn.Sigmoid()\n","        )\n","        self.nnECG.apply(init_weight)\n","\n","    def forward(self, input):\n","        return self.nnECG(input)"]},{"cell_type":"markdown","metadata":{"id":"rJ20BRfxq9ME"},"source":["# Training"]},{"cell_type":"code","execution_count":19,"metadata":{"executionInfo":{"elapsed":257,"status":"ok","timestamp":1662655078091,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"3XLm855B9g_p"},"outputs":[],"source":["def training(net,dataloader_t,dataloader_v,num_epochs,j,k):\n","  \"\"\" Training with a BCELoss on the dataset, for each epoch the net weights are saved and the mean error is computed to plot the loss\n","  for training and valdiation dataset\n","  \"\"\"\n","  Loss = []\n","  Lossv= []\n","  for epoch in range(num_epochs):\n","      L_t=[]\n","      L_v=[]\n","      for i, dataj in enumerate(dataloader_t, 0):\n","          net.zero_grad()\n","          x=dataj[0].float().to(device)\n","          yhat=dataj[1].float().to(device)\n","          yhat=yhat.view(-1,1)\n","          y=net(x)\n","          err_t=nn.BCELoss()(y.float(),yhat.float())\n","          err_t.backward()\n","          optimizer.step()\n","          L_t.append(err_t.item())\n","      for i, dataj in enumerate(dataloader_v, 0):\n","        net.eval()     \n","        x=dataj[0].float().to(device)\n","        yhat=dataj[1].float().to(device)\n","        yhat=yhat.view(-1,1)\n","        y=net(x)\n","        err_v=nn.BCELoss()(y.float(),yhat.float())\n","        L_v.append(err_v.item())\n","      err=np.mean(L_t)\n","      errv=np.mean(L_v)\n","      Loss.append(err)\n","      Lossv.append(errv)\n","      torch.save(net.state_dict(), DIR_NET_SAVING+\"net_\"+str(j)+\"_\"+str(k)+\"_epoch_\"+str(epoch)+\".pth\")\n","  return [Lossv,np.argmin(Lossv)]"]},{"cell_type":"code","execution_count":18,"metadata":{"executionInfo":{"elapsed":239,"status":"ok","timestamp":1662654729386,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"p1swnhoPWDsD"},"outputs":[],"source":["def seed_worker(worker_id):\n","    worker_seed = torch.initial_seed() % 2**32\n","    np.random.seed(worker_seed)\n","    random.seed(worker_seed)\n","\n","num_workers = 2\n","batch_size = 32\n","ngpu = 1\n","device = torch.device(\"cuda:0\" if (torch.cuda.is_available() and ngpu > 0) else \"cpu\") "]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":41931,"status":"ok","timestamp":1662655181552,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"dXTz0x-Hhd-Q","outputId":"b0b42beb-d24c-40ef-a57d-bbe402bd4c4d"},"outputs":[],"source":["net= ClassifierECG(ngpu).to(\"cuda\")\n","lr=0.0001\n","beta1=0.9\n","optimizer = optim.Adam(net.parameters(), lr=lr, betas=(beta1, 0.999))\n","dataloader_t = torch.utils.data.DataLoader(ds_training,batch_size=batch_size,shuffle=True,num_workers=num_workers,worker_init_fn=seed_worker,generator=g, drop_last=True)\n","dataloader_test = torch.utils.data.DataLoader(ds_test,batch_size=batch_size,shuffle=True,num_workers=num_workers,worker_init_fn=seed_worker,generator=g, drop_last=True)\n","Lossv,argmin=training(net,dataloader_t,dataloader_test,10,0,0)"]},{"cell_type":"markdown","metadata":{},"source":["# Results"]},{"cell_type":"code","execution_count":24,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":283},"executionInfo":{"elapsed":358,"status":"ok","timestamp":1662655908463,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"nTAlh7toA3Pk","outputId":"a0380fa4-2618-4a70-a559-2628dadd1470"},"outputs":[{"data":{"text/plain":["[<matplotlib.lines.Line2D at 0x7f00662bfe10>]"]},"execution_count":24,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["plt.plot(Lossv)"]},{"cell_type":"code","execution_count":25,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":247,"status":"ok","timestamp":1662655990940,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"OV_v7Rov-QOM","outputId":"17ffbec7-c605-4415-bb18-a90b5065c1da"},"outputs":[{"data":{"text/plain":["<All keys matched successfully>"]},"execution_count":25,"metadata":{},"output_type":"execute_result"}],"source":["net.load_state_dict(torch.load(DIR_NET_SAVING+\"net_0_0_epoch_{}.pth\".format(argmin)))"]},{"cell_type":"code","execution_count":56,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":603},"executionInfo":{"elapsed":1674,"status":"ok","timestamp":1662657595901,"user":{"displayName":"Edouard .C","userId":"07320798258634684264"},"user_tz":-120},"id":"_u0X9t2yWV_H","outputId":"b10788c6-4783-4eb2-f4f0-910cce7d85ad"},"outputs":[{"name":"stdout","output_type":"stream","text":["accuracy 0.9614583333333333\n","precision 0.8617683686176837\n","recall 1.0\n","F1score 0.925752508361204\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 2376x648 with 4 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# Results\n","Loss = []\n","trsh=0.5\n","net.eval()\n","confusionlabel=np.zeros((2,4))\n","confusion=np.zeros((2,2))\n","length_ds=0\n","for i, datal in enumerate(dataloader_test, 0):\n","      confusionlabelt,confusiont=conf_mat(datal,trsh)\n","      confusion+=confusiont\n","      confusionlabel+=confusionlabelt\n","      length_ds+=batch_size\n","x_axis_confl = ['neutral','stress','amusement','meditation'] # labels for x-axis\n","y_axis_confl = ['stress','no stress'] # labels for y-axis\n","x_axis_conf = ['stress','no stress']\n","y_axis_conf = ['stress','no stress']\n","\n","# create seabvorn heatmap with required labels\n","confusion_annot=np.array([str(x) for x in np.round(100*confusion/length_ds,3).reshape(-1).tolist()]).reshape(confusion.shape)\n","confusionlabel_annot=np.array([str(x) for x in np.round(100*confusionlabel/length_ds,3).reshape(-1).tolist()]).reshape(confusionlabel.shape)\n","sns.set(rc={\"figure.figsize\":(15, 5)})\n","fig, axs = plt.subplots(ncols=2,figsize=(33,9))\n","sns.heatmap((100*confusion/length_ds), xticklabels=x_axis_conf, yticklabels=y_axis_conf,annot=confusion_annot,ax=axs[0],fmt = '')\n","axs[0].set_xlabel('Ground Truth')\n","axs[0].set_ylabel('Prediction')\n","sns.heatmap((100*confusionlabel/length_ds), xticklabels=x_axis_confl, yticklabels=y_axis_confl, annot=confusionlabel_annot,ax=axs[1],fmt = '')\n","axs[1].set_xlabel('Ground Truth')\n","axs[1].set_ylabel('Prediction')\n","TP=confusion[0,0]\n","TN=confusion[1,1]\n","FN=confusion[1,0]\n","FP=confusion[0,1]\n","acc=(TP+TN)/(TP+FP+FN+TN)\n","precision=TP/(TP+FP)\n","recall=TP/(TP+FN)\n","F1score=(2*recall*precision)/(recall+precision)\n","print(\"accuracy \" +str(acc))\n","print(\"precision \" +str(precision))\n","print(\"recall \" +str(recall))\n","print(\"F1score \"+str(F1score))"]}],"metadata":{"accelerator":"GPU","colab":{"authorship_tag":"ABX9TyPJrUQdTC8jRAoXukVvmiwi","collapsed_sections":["USaorKo7DP9B","88CdoUVQrpaA","VZVLgHmjVhGa"],"machine_shape":"hm","provenance":[{"file_id":"1ld2p47ZTErsIlGf9WxpENlxS5g3G6Nea","timestamp":1645823451673},{"file_id":"16DbLIaJKMKs6INHP1tJ_d7p_rPw2OXjP","timestamp":1645764498495},{"file_id":"1qTsAzF2xab3lOSky0DXfIoUUiqD1UHWF","timestamp":1645763189709}]},"kernelspec":{"display_name":"Python 3.9.7 64-bit","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.9.7"},"vscode":{"interpreter":{"hash":"acb408c112aa627a318ac6bee697c54a21dc0d988d17c05deacc60f98e48531a"}}},"nbformat":4,"nbformat_minor":0}