{ "cells": [ { "cell_type": "markdown", "id": "1c6056e6-86ea-4c92-9e95-a64b38d6f4c9", "metadata": {}, "source": [ "# Use case with the EEGMMI Dataset" ] }, { "cell_type": "markdown", "id": "4790085d-fc09-4c01-9816-8c7e0fbd5115", "metadata": {}, "source": [ "
\n", "WARNING \n", " \n", "This notebook includes multiple trainings that can extend its total run time. We strongly suggest to run it with a device with CUDA installed.\n", "\n", "
\n", "\n", "**Notebook Structure:**\n", "\n", "\n", "* [Introduction](#Introduction)\n", "* [Self-Supervised Learning Pipeline](#Self-Supervised-Learning-Pipeline)\n", "* [Dataset description and problem design](#Dataset-Description-and-problem-design)\n", "* [Notebook start](#Package-Import)\n", " * [Data Preparation](#Data-Preparation)\n", " * [Pretraining Phase](#Pretraining-Phase)\n", " * [Define Dataloaders](#Define-Pretraining-dataloaders)\n", " * [Define Augmenter](#Define-the-data-augmenter)\n", " * [Define Pretraining Model](#Define-pretraining-model-and-other-training-objects)\n", " * [Run Pretraining](#Pretrain-the-model)\n", " * [Fine-Tuning Phase](#Fine-tuning-Phase)\n", " * [Define Dataloaders](#Define-fine-tuning-dataloaders)\n", " * [Model Transfer](#Define-fine-tuning-model-and-other-training-objects)\n", " * [Run Fine-Tuning](#Fine-tuning)\n", " * [Model Evaluation](#Evaluate-fine-tuned-model)\n", " * [Comparison with Full Supervised Strategy](#Comparison-with-full-supervised)" ] }, { "cell_type": "markdown", "id": "8b700a40-f4c2-45fc-8fc5-bd1f7952c9ec", "metadata": {}, "source": [ "## Introduction\n", "\n", "This notebook will provide an additional example on how to use the selfeeg library on a real-world dataset. \n", "To do that, we will use the EEGMMI Dataset, which can be downloaded [**here**](https://physionet.org/content/eegmmidb/1.0.0/). However, to facilitate things, we will work with an already preprocessed version of such dataset made available as a resource for the book\n", "\n", "```\n", "Deep Learning for EEG-based Brain-Computer Interface: Representations, \n", "Algorithms and Applications, by Dr. Xiang Zhang and Prof. Lina Yao\n", "```\n", "\n", "Preprocessed data can be downloaded [**here**](https://github.com/neergaard/eegbci-data/tree/master)\n", "\n", "
\n", "INFO \n", " \n", "Self-Supervised Learning is usually beneficial when there is a small amount of supervision but several datasets to aggregate. In this case, we will work with a single dataset to keep things simple.\n", "\n", "
" ] }, { "cell_type": "markdown", "id": "7965f413-5152-45f2-b1e6-bcf1fd8ccb2c", "metadata": {}, "source": [ "## Self-Supervised Learning Pipeline\n", "\n", "The notebook [**Build a self-supervised learning pipeline**](https://selfeeg.readthedocs.io/en/latest/SSL_guide.html) already provides a description on how to build a Self-Supervised Learning Pipeline with selfEEG. To summarize, typical steps include:\n", "\n", "1. PRETRAINING:\n", " 1. define the pretraining dataloaders\n", " 2. define the data augmenter\n", " 3. define the pretraining model and optional training elements\n", " 4. pretrain the model\n", "2. FINE-TUNING\n", " 1. define the fine-tuning dataloaders\n", " 2. define the fine-tuning model and optional training elements\n", " 3. transfer the pretrained encoder\n", " 4. fine-tune the model\n", "3. FINAL EVALUATION\n", "\n", "In addition, you can consult the following [**Review Paper**](https://ieeexplore.ieee.org/abstract/document/10365170), which provides additional references and datasets used to build EEG-Based Self-Supervised Learning Pipelines as well as a clear description on critical aspects to consider when designing SSL applications on biomedical signals.\n" ] }, { "cell_type": "markdown", "id": "47b3e034-f1cd-49ca-a6c2-2851ef6ac85c", "metadata": {}, "source": [ "## Dataset Description and problem design\n", "\n", "**Dataset Description**\n", "\n", "\n", "As described in the official documentation, the EEGMMI dataset consists of over 1500 one- and two-minute EEG recordings, obtained from 109 volunteers. Subjects performed different motor/imagery tasks while **64-channel EEG** were recorded using the **BCI2000 system**, with a sampling rate of **160 Hz**. In particolar, the following tasks were performed, giving a total of **14 records** per subjects:\n", "\n", "1. Baseline, eyes open\n", "2. Baseline, eyes closed\n", "3. Task 1 (open and close left or right fist)\n", "4. Task 2 (imagine opening and closing left or right fist)\n", "5. Task 3 (open and close both fists or both feet)\n", "6. Task 4 (imagine opening and closing both fists or both feet)\n", "7. Task 1\n", "8. Task 2\n", "9. Task 3\n", "10. Task 4\n", "11. Task 1\n", "12. Task 2\n", "13. Task 3\n", "14. Task 4\n", "\n", "**Designed Task**\n", "\n", "The investigated problem is a binary task based on *Task 2 (imagine opening and closing left or right fist)*. Task 2 data will be used for the *fine-tuning phase*, while data from *other tasks* will be used for the *pretraining phase*. Training, validation, and test sets will be created via subject-based splits." ] }, { "cell_type": "markdown", "id": "bd50e924-e2af-4c0b-8d2b-b3a27a0b51a9", "metadata": {}, "source": [ "## Package Import" ] }, { "cell_type": "markdown", "id": "2813d14e-e23b-4cec-8490-6e92ed1bc02a", "metadata": {}, "source": [ "First, let's import all the packages necessary to run this notebook.\n", "\n", "
\n", "WARNING \n", " \n", "to run this notebook you will also need matplotlib and scikit-learn, which are not dependecies of the selfeeg library. Be sure to install them in your environment.\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 1, "id": "1732513d-39eb-4ddd-a6de-51e9574e515b", "metadata": {}, "outputs": [], "source": [ "# IMPORT BASE PACKAGES\n", "import os\n", "import random\n", "import pickle\n", "import copy\n", "import sys\n", "sys.path.append('..') # needed if you run this inside the selfeeg/doc folder\n", "\n", "import selfeeg\n", "import selfeeg.augmentation as aug\n", "import selfeeg.dataloading as dl\n", "\n", "# IMPORT CLASSICAL PACKAGES\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "from sklearn.metrics import classification_report\n", "\n", "# Draw figures inline with this notebook\n", "%matplotlib inline\n", "\n", "# IMPORT TORCH\n", "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "from torch.utils.data import DataLoader, Dataset\n", "\n", "# set seeds for reproducibility\n", "seed = 1234\n", "random.seed( seed )\n", "np.random.seed( seed )\n", "torch.manual_seed( seed )\n", "plt.style.use('seaborn-v0_8-white')\n", "plt.rcParams['figure.figsize'] = (15.0, 6.0)" ] }, { "cell_type": "markdown", "id": "475f25ac-e564-45df-9fb2-76edd8665d11", "metadata": {}, "source": [ "## Data Preparation\n", "\n", "To run this notebook, it is necessary to download the preprocessed dataset from the following [**GitHub repository**](https://github.com/neergaard/eegbci-data/tree/master). In short, it necessary to:\n", "\n", "1. clone the repository with ``git clone https://github.com/xiangzhang1015/Deep-Learning-for-BCI.git`` (or download its zip version)\n", "2. Unzip all the files in the repository's ``dataset`` folder\n", "3. Put all the unzipped files in a folder with the name ``Data``, placed in the current working directory, or, alternatively, just set the path below accordingly\n", "\n", "Steps are simple but, just in case, here is a set of commands to include in a cell to automatically download and unzip the data in a Data folder\n", "\n", " !mkdir Data\n", " !wget https://github.com/xiangzhang1015/Deep-Learning-for-BCI/archive/refs/heads/master.zip\n", " !unzip master.zip \"Deep-Learning-for-BCI-master/dataset/*\"\n", " !mv -v Deep-Learning-for-BCI-master/dataset/* Data\n", " !rm master.zip\n", "\n", "Downloaded data are 109 2-dimensional numpy arrays where each file collects all the records of the same subject, already well-preprocessed. \n", "\n", "Since we are working with a single dataset that can be totally preloaded, there's no need to use the **dataloading** module, which is designed for a collection of datasets impossible to directly load on your device. Therefore, we will just preload all the samples and create a basic Dataset class to fed to the Dataloader." ] }, { "cell_type": "code", "execution_count": 2, "id": "735d985c-b4f6-4f7c-8e34-0900abac44a0", "metadata": {}, "outputs": [], "source": [ "# ----------- Set Dataset path -------------\n", "# If not this, change it with the right path\n", "dataPath = 'Data/'" ] }, { "cell_type": "code", "execution_count": 3, "id": "43149659-5653-4bb7-b8a7-ac319cddb0ce", "metadata": {}, "outputs": [], "source": [ "def get_MMI_subject_data(\n", " path: str,\n", " subject: int, \n", " pretrain_label: list[int]=[0,1,2,3,6,7,8,9], \n", " finetune_label: list[int]=[4,5],\n", " window: float=4.1,\n", " overlap: float=0., \n", "):\n", " \"\"\"\n", " ``get_MMI_subject_data`` will load and separate subject-specific \n", " data from the Physionet EEG Motor Movement/Imagery (EEGMMI) Dataset\n", " for Self-Supervised Learning (SSL) applications. Loaded data are those \n", " already well-preprocessed and provided as a resource for the book: \n", " \n", " Deep Learning for EEG-based Brain-Computer Interface: Representations, \n", " Algorithms and Applications, by Dr. Xiang Zhang and Prof. Lina Yao \n", "\n", " Data, tutorials, and more info about the provided format can be found \n", " in the official git repository available at:\n", " \n", " https://github.com/xiangzhang1015/Deep-Learning-for-BCI\n", " \n", " Parameters\n", " ----------\n", " path: str\n", " Path to the data root folder. It will be concatenated with the subj's file name.\n", " subject: int\n", " An integer defining the subject ID. Must be in [1, 109].\n", " pretrain_label: list[int]\n", " A list of label to put in the pretraining dataset. Must be in [0,10].\n", " Values are associated with the following labels are: 0: open eyes,\n", " 1: close eyes, 2: left hand, 3: right hand, 4: image left hand,\n", " 5: image right hand, 6: open fists, 7: open feet, 8: image fist,\n", " 9: image feet, 10: rest. Default = [0,1,2,3,6,7,8,9]\n", " finetune_label: list[int]\n", " Same as pretrain_label but for the fine-tuning dataset. Default = [4,5]\n", " window: float\n", " The length of the window to consider. Must be a float lower than 4.1.\n", " Default = 4.1\n", " overlap: float\n", " The overlap between consecutive windows of the same trial. Must be in \n", " [0,1). Default = 0\n", "\n", " Returns\n", " -------\n", " pretrain_data: numpy array\n", " Numpy array of shape [sample, channel, time] with all the subject's\n", " samples to use for the pretraining\n", " pretrain_lab: numpy array\n", " Numpy array with the pretrain_data samples label\n", " finetune_data: numpy array\n", " Numpy array of shape [sample, channel, time] with all the subject's\n", " samples to use for the fine-tuning\n", " finetune_lab: numpy array\n", " Numpy array with the finetune_data samples label\n", " \n", " \"\"\"\n", " # Just some checks to make this function more robust\n", " if int(subject)<1 or int(subject)>109:\n", " raise ValueError('wrong subject ID')\n", " if not(isinstance(path,str)):\n", " raise ValueError('path must be a string')\n", " elif path[-1] != os.sep:\n", " path = path + os.sep\n", " if len(set(pretrain_label).intersection(set(finetune_label)))>0:\n", " raise ValueError('pretraining and finetuning labels must be different')\n", " if window<0 or window>4.1:\n", " raise ValueError('window must be in [0,4.1]') \n", " \n", " # load data\n", " data = np.load(f'{dataPath}{int(subject)}.npy')\n", " # get time points where the label change to speed up extraction\n", " label_change = np.ediff1d(data[:,64]).nonzero()[0]\n", " pretrain_data = []\n", " pretrain_lab = []\n", " finetune_data = []\n", " finetune_lab = []\n", " Nwindow = int(160*window) # Sampling rate is 160\n", " Noverlap = int(Nwindow*overlap) # Round everything\n", " idx = 0\n", "\n", " # basically this block will scroll the loaded array from start to end\n", " # jumping by (Nwindow-Noverlap) sample at a time. Conditions are:\n", " # 1. The idx has a label to exclude, jump to the next segment\n", " # 2. The idx has a label to include but there are not enough time samples\n", " # to fill the entire window. Jump to the next segment.\n", " # 3. The ids has a label to include and there are enough samples to fill\n", " # the entire window. Add sample and jump by (Nwindow-Noverlap) steps.\n", " while ( (idx+Nwindow) < data.shape[0]):\n", " if data[idx,64] in pretrain_label:\n", " if data[idx+Nwindow-1,64] == data[idx,64]:\n", " pretrain_data.append(data[idx:idx+Nwindow,:64])\n", " pretrain_lab.append(data[idx,64])\n", " idx = idx+Nwindow-Noverlap\n", " else:\n", " idx = label_change[np.searchsorted(label_change,[idx],side='right')[0]]+1\n", " elif data[idx,64] in finetune_label:\n", " if data[idx+Nwindow-1,64] == data[idx,64]:\n", " finetune_data.append(data[idx:idx+Nwindow,:64])\n", " finetune_lab.append(data[idx,64])\n", " idx = idx+Nwindow-Noverlap\n", " else:\n", " idx = label_change[np.searchsorted(label_change,[idx],side='right')[0]]+1\n", " else:\n", " idx = label_change[np.searchsorted(label_change,[idx],side='right')[0]]+1\n", "\n", " pretrain_data = np.stack(pretrain_data, 0).astype('float32')\n", " pretrain_data = np.transpose(pretrain_data, (0,2,1))\n", " pretrain_lab = np.array(pretrain_lab).astype('float32')\n", " \n", " finetune_data = np.stack(finetune_data, 0).astype('float32')\n", " finetune_data = np.transpose(finetune_data, (0,2,1))\n", " finetune_lab = np.array(finetune_lab).astype('float32')\n", " \n", " return pretrain_data, pretrain_lab, finetune_data, finetune_lab\n", "\n", "\n", "def gather_subjects_data(\n", " path: str, \n", " subject_ids: list, \n", " pretrain_label: list[int]=[0,1,2,3,6,7,8,9], \n", " finetune_label: list[int]=[4,5],\n", " window: float=4.1,\n", " overlap: float=0.0\n", "):\n", " \"\"\"\n", " ``gather_subjects_data`` calls the ``get_MMI_subject_data``\n", " for each subject listed in subject_ids, then concatenate all the arrays.\n", " \"\"\"\n", " N = len(subject_ids)\n", " Xpre = [None]*N \n", " Ypre = [None]*N \n", " Xfine = [None]*N \n", " Yfine = [None]*N \n", " for n, i in enumerate(subject_ids):\n", " Xpre[n], Ypre[n], Xfine[n], Yfine[n] = get_MMI_subject_data(\n", " dataPath, \n", " subject = i,\n", " pretrain_label = pretrain_label,\n", " finetune_label = finetune_label,\n", " window = window,\n", " overlap = overlap\n", " )\n", " Xpre = torch.from_numpy( np.concatenate(Xpre,0))\n", " Ypre = torch.from_numpy( np.concatenate(Ypre,0))\n", " Xfine = torch.from_numpy( np.concatenate(Xfine,0))\n", " Yfine = torch.from_numpy( np.concatenate(Yfine,0))\n", " return Xpre, Ypre, Xfine, Yfine\n", " " ] }, { "cell_type": "code", "execution_count": 4, "id": "8d6f4b59-a324-44cb-a3d4-cb53fa8b0192", "metadata": { "scrolled": true }, "outputs": [], "source": [ "# random select subjects to put in train, val, and test\n", "all_id = [i for i in range(1, 110)]\n", "random.shuffle(all_id)\n", "train_id = all_id[0:70]\n", "val_id = all_id[70:70+17]\n", "test_id = all_id[70+17:]\n", "\n", "# create train tensors\n", "Xpre_train, Ypre_train, Xfine_train, Yfine_train = gather_subjects_data(\n", " path = dataPath, subject_ids = train_id\n", ")\n", "# create validation tensors\n", "Xpre_val, Ypre_val, Xfine_val, Yfine_val = gather_subjects_data(\n", " path = dataPath, subject_ids = val_id\n", ")\n", "\n", "# There's no need to have a test set during pretraining\n", "_, _, Xfine_test, Yfine_test = gather_subjects_data(\n", " path = dataPath, subject_ids = test_id\n", ")\n", "\n", "# directly rescale and encode fine_tuning data\n", "Xfine_train = selfeeg.utils.scale_range_soft_clip(Xfine_train, 80, 3.5, 'uV', True)\n", "Yfine_train = (Yfine_train > 4).to(dtype=torch.float32)\n", "Xfine_val = selfeeg.utils.scale_range_soft_clip(Xfine_val, 80, 3.5, 'uV', True)\n", "Yfine_val = (Yfine_val > 4).to(dtype=torch.float32)\n", "Xfine_test = selfeeg.utils.scale_range_soft_clip(Xfine_test, 80, 3.5, 'uV', True)\n", "Yfine_test = (Yfine_test > 4).to(dtype=torch.float32)" ] }, { "cell_type": "markdown", "id": "757400f9-2a70-4802-8896-08dd44addf15", "metadata": {}, "source": [ "## Pretraining Phase" ] }, { "cell_type": "markdown", "id": "2b6a7253-65e1-4ace-afc7-9c2c8fcadc2c", "metadata": {}, "source": [ "### Define Pretraining dataloaders\n", "\n", "Since we have directly preloaded the entire dataset, there is no need to use the custom classes and function of the selfEEG's dataloading module." ] }, { "cell_type": "code", "execution_count": 5, "id": "27746e75-87ad-4c3e-8a9f-6bc0b7310d6a", "metadata": {}, "outputs": [], "source": [ "# define some parameters\n", "Chan = 64\n", "freq = 160\n", "window = 4.1\n", "batchsize = 64\n", "nb_classes=2\n", "Samples = int(freq*window)" ] }, { "cell_type": "code", "execution_count": 6, "id": "f6e029f5-72db-46df-b5f0-cd4bf77b66df", "metadata": {}, "outputs": [], "source": [ "class EEGMMIDataset(Dataset):\n", " def __init__(self, X, Y=None):\n", " super().__init__()\n", " self.X = X\n", " self.Y = Y\n", "\n", " def __len__(self):\n", " return self.X.shape[0]\n", "\n", " def __getitem__(self,index):\n", " if self.Y is None:\n", " return self.X[index]\n", " else:\n", " return self.X[index], self.Y[index]" ] }, { "cell_type": "code", "execution_count": 7, "id": "f862b8c0-b7cc-466c-ac51-5aa35daff630", "metadata": {}, "outputs": [], "source": [ "# define training dataloader\n", "trainset = EEGMMIDataset(Xpre_train)\n", "trainloader = DataLoader(dataset = trainset, batch_size = batchsize)\n", "\n", "# define validation dataloader\n", "valset = EEGMMIDataset(Xpre_val)\n", "valloader = DataLoader(dataset = valset, batch_size = batchsize, shuffle = False)" ] }, { "cell_type": "markdown", "id": "4415f14b-4d59-4628-a2f1-d81e2d3d414f", "metadata": {}, "source": [ "### Define the data augmenter\n", "\n", "Now we need to define an augmenter. To keep things simple, we define an augmenter which combines:\n", "\n", "1. the addition of some noise or channel lost from ``add_band_noise`` or ``masking``.\n", "2. the ``warp`` or ``crop_and_resize`` or ``permute`` augmentation.\n", "3. a final rescale of the range [-80, 80] uV in [-1, 1] with soft clipping with horizontal asintote of 3.5.\n", "\n", "This is similar to the augmentation proposed in the augmentation module introductory book" ] }, { "cell_type": "code", "execution_count": 8, "id": "2add4f69-1b57-4e19-b72f-3e7323feac81", "metadata": {}, "outputs": [], "source": [ "# DEFINE AUGMENTER\n", "# First block: noise addition\n", "AUG_band = aug.DynamicSingleAug(\n", " aug.add_band_noise, \n", " discrete_arg={\n", " 'bandwidth': [\"delta\", \"theta\", \"alpha\", \"beta\", (30,49) ], \n", " 'samplerate': freq,\n", " 'noise_range': 1\n", " }\n", ")\n", "AUG_mask = aug.DynamicSingleAug(\n", " aug.masking,\n", " discrete_arg = {'mask_number': [1,2,3,4], 'masked_ratio': 0.25}\n", ")\n", "Block1 = aug.RandomAug(AUG_band, AUG_mask, p = [0.7, 0.3])\n", "\n", "# second block: warp or crop and resize\n", "AUG_crop = aug.DynamicSingleAug(\n", " aug.crop_and_resize,\n", " discrete_arg = {'batch_equal': True},\n", " range_arg = {'N_cut': [1, 4], 'segments': [12,15]},\n", " range_type = {'N_cut': True, 'segments': True}\n", ")\n", "\n", "AUG_permute = aug.DynamicSingleAug(\n", " aug.permutation_signal,\n", " discrete_arg = {'segments': [15], 'batch_equal': True},\n", " range_arg = {'seg_to_per': [2, 5]},\n", " range_type = {'seg_to_per': True}\n", ")\n", "AUG_warp = aug.DynamicSingleAug(\n", " aug.warp_signal,\n", " discrete_arg = {'segments': [10], 'batch_equal': True},\n", " range_arg = {'squeeze_strength': [0.75,0.9], 'stretch_strength': [1.1,1.5]},\n", " range_type = {'squeeze_strength': False, 'stretch_strength': False}\n", ")\n", "Block2 = aug.RandomAug(AUG_crop, AUG_permute, AUG_warp, p = [0.3,0.3,0.4])\n", "\n", "# third block: rescale\n", "Block3 = lambda x: selfeeg.utils.scale_range_soft_clip(x, 80, 3.5, 'uV', True)\n", "\n", "# FINAL AUGMENTER: SEQUENCE OF THE THREE RANDOM LISTS\n", "Augmenter = aug.SequentialAug(Block1, Block2, Block3)" ] }, { "cell_type": "code", "execution_count": 9, "id": "c89c01e0-1701-4c02-b908-b523fba80620", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# visualize a random data augmentation\n", "Sample = trainset.__getitem__(random.randint(0,len(trainset)))\n", "t = np.linspace(0, Sample.shape[1]-1, Sample.shape[1])/freq\n", "SampleAug = Augmenter(Sample)\n", "RandChan= random.randint(0,Chan-1)\n", "\n", "fig, ax1 = plt.subplots()\n", "color = 'tab:blue'\n", "ax1.set_xlabel('time [s]', fontsize=15)\n", "ax1.set_ylabel('[uV]', color=color, fontsize=15)\n", "ax1.plot(t, Sample[RandChan,:], color=color)\n", "ax1.tick_params(axis='y', labelcolor=color, labelsize=15)\n", "ax1.tick_params(axis='x', labelsize=15)\n", "ax2 = ax1.twinx()\n", "color = 'tab:orange'\n", "ax2.set_ylabel('[ ]', color=color, fontsize=15) # we've already handled the x-label\n", "ax2.plot(t, SampleAug[RandChan,:],color=color, linewidth=2.5)\n", "ax2.tick_params(axis='y', labelsize=15, labelcolor=color)\n", "plt.title('Same random channel from one sample: augmented version', fontsize=20)\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "a93fd97f-e732-4a2e-82be-eaac4c0db58a", "metadata": {}, "source": [ "### Define pretraining model and other training objects\n", "\n", "Now we need to define the pretraining model. To do that, we need to:\n", "\n", "1. instantiate an nn.Module defining the encoder (backbone)\n", "2. instantiate the right SSL module, giving the encoder and the network head's spec.\n", "\n", "For now, let's use a simple EEGNet with default parameters, and SimCLR as the SSL algorithm.\n", "\n", "
\n", "NOTE 1 \n", " \n", "each model in the models module have an extra class with only the encoder with the name modelnameEncoder (e.g., EEGNetEncoder). This will make model creation much easier. \n", "\n", "
\n", "\n", "
\n", "NOTE 2 \n", " \n", "each model in the ssl module can accept a list or a nn.Module to create the network head. In case of a list, the head will be a sequence of dense layer with input and output size equal to the values of the list. Batchnorm and activation are based on the original works.\n", "\n", "
\n", "\n", "
\n", "WARNING \n", " \n", "Remember to check if the encoder output size matches the head input size. All modules in the ssl class doesn't check that.\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 10, "id": "144a6e7e-98dd-4c4c-8884-295c7b523103", "metadata": {}, "outputs": [], "source": [ "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", "\n", "# Encoder\n", "NNencoder= selfeeg.models.EEGNetEncoder(Chans=Chan)\n", "\n", "# SSL model\n", "head_size=[320, 64, 32]\n", "SelfMdl = selfeeg.ssl.SimCLR(\n", " encoder = NNencoder,\n", " projection_head = head_size\n", ").to(device=device)\n", "\n", "# loss (fit method has a default loss based on the SSL algorithm)\n", "loss=selfeeg.losses.simclr_loss\n", "loss_arg={'temperature': 0.15}\n", "\n", "# optimizer\n", "optimizer = torch.optim.Adam(SelfMdl.parameters(), lr=1e-3)\n", "\n", "# lr scheduler\n", "scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.97)" ] }, { "cell_type": "markdown", "id": "8e211933-5c74-4acc-8cf3-99730f6c8fcf", "metadata": {}, "source": [ "### Pretrain the model\n", "\n", "Each SSL algorithm has an already implemented fit method, similar to scikitlearn or Keras. Of course it's not complete as the fit of bigger framewoks, but it certainly save you lots of lines of code and help you monitorate the training. Since this is just a tutorial we will run only 50 epochs of training" ] }, { "cell_type": "code", "execution_count": 11, "id": "228a4a30-365f-4713-a6db-5617edfaabdb", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/delpup/miniconda3/envs/selfdlp/lib/python3.11/site-packages/torch/nn/modules/conv.py:459: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at /opt/conda/conda-bld/pytorch_1682343995622/work/aten/src/ATen/native/Convolution.cpp:1003.)\n", " return F.conv2d(input, weight, bias, self.stride,\n" ] } ], "source": [ "loss_info = SelfMdl.fit(\n", " train_dataloader = trainloader, \n", " augmenter = Augmenter, \n", " epochs = 50,\n", " optimizer = optimizer, \n", " loss_func = loss, \n", " loss_args = loss_arg,\n", " lr_scheduler = scheduler, \n", " validation_dataloader = valloader,\n", " verbose = False, \n", " device = device, \n", " return_loss_info = True\n", ")" ] }, { "cell_type": "markdown", "id": "08381a75-fbe4-4153-b482-1934eaa2d2bb", "metadata": {}, "source": [ "## Fine-tuning Phase\n", "\n", "Now that the encoder is pretrained, let's perform fine-tuning. To do that, we need to recreate the right dataloaders and models. After that, the **selfeeg** library provides a **fine-tuning** function that is similar to the fit method." ] }, { "cell_type": "markdown", "id": "02e8dc32-4b9a-45cd-9615-77f2ff00c3a8", "metadata": {}, "source": [ "### Define fine-tuning dataloaders\n", "\n", "This phase is basically the same as the previous one. The only differences are:\n", "\n", "1. We are using the fine-tuning data\n", "2. We are creating a test set for evaluation\n", "3. We need to extract a label from each sample.\n", "\n", "The used classes and methods are the same already used from the dataloading module" ] }, { "cell_type": "code", "execution_count": 12, "id": "576a2c11-b6e7-4898-91bb-c7a19d096129", "metadata": {}, "outputs": [], "source": [ "# define training dataloader\n", "trainsetFT = EEGMMIDataset(Xfine_train, Yfine_train)\n", "trainloaderFT = DataLoader(dataset = trainsetFT, batch_size= batchsize)\n", "\n", "# define validation dataloader\n", "valsetFT = EEGMMIDataset(Xfine_val, Yfine_val)\n", "valloaderFT = DataLoader(dataset = valsetFT, batch_size= batchsize, shuffle=False)\n", "\n", "# define test dataloader\n", "testsetFT = EEGMMIDataset(Xfine_test, Yfine_test)\n", "testloaderFT = DataLoader(dataset = testsetFT, batch_size= batchsize, shuffle=False)" ] }, { "cell_type": "markdown", "id": "2abb4ed0-f149-4a62-9d1d-ba32c0895c9f", "metadata": {}, "source": [ "### Define fine-tuning model and other training objects\n", "\n", "Remember that in this phase you need to transfer the pretrained encoder" ] }, { "cell_type": "code", "execution_count": 21, "id": "5bb89f11-7ade-4722-b3b5-78f24cc34665", "metadata": {}, "outputs": [], "source": [ "FinalMdl = selfeeg.models.EEGNet(nb_classes = 2, Chans = Chan, Samples = Samples)\n", "\n", "# Transfer the pretrained backbone and \n", "# move the final model to the chosen device\n", "SelfMdl.train() \n", "SelfMdl.to(device='cpu') \n", "FinalMdl.encoder = SelfMdl.get_encoder()\n", "FinalMdl.train()\n", "FinalMdl.to(device=device)\n", "\n", "# Define Loss\n", "def loss_fineTuning(yhat, ytrue):\n", " yhat = torch.squeeze(yhat)\n", " return F.binary_cross_entropy_with_logits(yhat, ytrue)\n", "\n", "# Define EarlyStopper\n", "earlystopFT = selfeeg.ssl.EarlyStopping(\n", " patience=20, min_delta=1e-03, record_best_weights=True)" ] }, { "cell_type": "markdown", "id": "069787cc-1a7a-4698-b777-fdd5918c3c33", "metadata": {}, "source": [ "### Fine-tuning\n", "\n", "Fine-tuning can be easily performed with the ``fine-tuning`` method.\n", "\n", "
\n", "NOTE 1 \n", " \n", "it is better to first pretrain only the new head, then update all model's weights.\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 22, "id": "9718dab2-4b6a-45d7-aef8-909d15d988db", "metadata": {}, "outputs": [], "source": [ "# Define Optimizer for warm-up\n", "optimizerFT = torch.optim.Adam(FinalMdl.parameters(), lr=0.001)\n", "\n", "# Define Optimizer\n", "gamma = 0.995\n", "optimizerFT2 = torch.optim.Adam(FinalMdl.parameters(), lr=0.0009)\n", "schedulerFT2 = torch.optim.lr_scheduler.ExponentialLR(optimizerFT2, gamma=gamma)" ] }, { "cell_type": "code", "execution_count": 23, "id": "cd036c7a-3de5-4898-a8b7-71869429f488", "metadata": { "scrolled": true }, "outputs": [], "source": [ "# START FINE-TUNING\n", "# First warm up by freezing the backbone\n", "do_warmup=True\n", "if do_warmup:\n", " FinalMdl.encoder.requires_grad_(False)\n", " finetuning_loss=selfeeg.ssl.fine_tune(\n", " model = FinalMdl,\n", " train_dataloader = trainloaderFT,\n", " epochs = 20,\n", " optimizer = optimizerFT,\n", " loss_func = loss_fineTuning, \n", " validation_dataloader = valloaderFT,\n", " verbose = False,\n", " device = device,\n", " return_loss_info = True\n", " )\n", "if do_warmup:\n", " FinalMdl.encoder.requires_grad_(True)\n", "\n", "finetuning_loss=selfeeg.ssl.fine_tune(\n", " model = FinalMdl,\n", " train_dataloader = trainloaderFT,\n", " epochs = 150,\n", " optimizer = optimizerFT2,\n", " loss_func = loss_fineTuning, \n", " lr_scheduler = schedulerFT2,\n", " EarlyStopper = earlystopFT,\n", " validation_dataloader = valloaderFT,\n", " verbose = False,\n", " device = device,\n", " return_loss_info = True\n", ")" ] }, { "cell_type": "code", "execution_count": 24, "id": "d204489d-2c80-41c0-a488-2e4cbc80ff19", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot([i for i in range(len(finetuning_loss))],\n", " [finetuning_loss[i][0] for i in range(len(finetuning_loss))],\n", " linewidth=2.5)\n", "plt.plot([i for i in range(len(finetuning_loss))],\n", " [finetuning_loss[i][1] for i in range(len(finetuning_loss))],\n", " linewidth=2.5)\n", "plt.title('Loss Progression Full Supervised')\n", "plt.xlabel('Epoch', fontsize=15)\n", "plt.ylabel('Loss', fontsize=15)\n", "plt.legend(['training', 'validation'],fontsize=15 )\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "93c66d5a-e56b-4bc3-9bee-0943880ed454", "metadata": {}, "source": [ "## Evaluate fine-tuned model\n", "\n", "Now you can evaluate your model in whatever method you prefer. Here is a simple example with the classification report from sklearn." ] }, { "cell_type": "code", "execution_count": 25, "id": "076b9201-f10d-460d-8722-50984f66b778", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Results of trivial Example\n", "\n", " precision recall f1-score support\n", "\n", " 0.0 0.81 0.83 0.82 486\n", " 1.0 0.83 0.80 0.81 483\n", "\n", " accuracy 0.82 969\n", " macro avg 0.82 0.82 0.82 969\n", "weighted avg 0.82 0.82 0.82 969\n", "\n" ] } ], "source": [ "nb_classes=2\n", "FinalMdl.to(device=device)\n", "FinalMdl.eval()\n", "ytrue=torch.zeros(len(testloaderFT.dataset))\n", "ypred=torch.zeros_like(ytrue)\n", "cnt=0\n", "for i, (X, Y) in enumerate(testloaderFT):\n", " X=X.to(device=device)\n", " ytrue[cnt:cnt+X.shape[0]]= Y \n", " with torch.no_grad():\n", " yhat = torch.sigmoid(FinalMdl(X)).to(device='cpu')\n", " ypred[cnt:cnt+X.shape[0]] = torch.squeeze(yhat) \n", " cnt += X.shape[0]\n", "\n", "print('Results of trivial Example\\n')\n", "print(classification_report(ytrue,ypred>0.5))" ] }, { "cell_type": "markdown", "id": "c70248ee-5f8e-4821-8038-fe761bd6f2f9", "metadata": {}, "source": [ "## Comparison with full supervised" ] }, { "cell_type": "markdown", "id": "38026248-261c-4bb4-a6c4-076865669b7e", "metadata": {}, "source": [ "Just for comparison, let's see if there is at least a slightly improvement compared to a standard full supervised pipeline" ] }, { "cell_type": "code", "execution_count": 26, "id": "4686d313-e48d-4ca0-866b-8d37a2816f33", "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Additional Model is EEGNet, which will perform slightly better in this case\n", "FinalMdl2 = selfeeg.models.EEGNet(nb_classes = 2, Chans = Chan, Samples = Samples)\n", "\n", "FinalMdl2.to(device=device)\n", "\n", "gamma = 0.995\n", "optimizerFT = torch.optim.Adam(FinalMdl2.parameters(), lr=0.0001)\n", "schedulerFT = torch.optim.lr_scheduler.ExponentialLR(optimizerFT, gamma=gamma)\n", "\n", "earlystopFT2 = selfeeg.ssl.EarlyStopping(\n", " patience=10, min_delta=1e-03, record_best_weights=True\n", ")\n", "\n", "finetuning_loss = selfeeg.ssl.fine_tune(\n", " model = FinalMdl2,\n", " train_dataloader = trainloaderFT,\n", " epochs = 150,\n", " optimizer = optimizerFT,\n", " loss_func = loss_fineTuning, \n", " lr_scheduler = schedulerFT,\n", " EarlyStopper = earlystopFT2,\n", " validation_dataloader = valloaderFT,\n", " verbose = False,\n", " device = device,\n", " return_loss_info = True\n", ")" ] }, { "cell_type": "code", "execution_count": 27, "id": "5ed95be5-e19d-43b3-a61e-a21dc320fbf0", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot([i for i in range(len(finetuning_loss))],\n", " [finetuning_loss[i][0] for i in range(len(finetuning_loss))],\n", " linewidth=2.5)\n", "plt.plot([i for i in range(len(finetuning_loss))],\n", " [finetuning_loss[i][1] for i in range(len(finetuning_loss))],\n", " linewidth=2.5)\n", "plt.title('Loss Progression Full Supervised')\n", "plt.xlabel('Epoch', fontsize=15)\n", "plt.ylabel('Loss', fontsize=15)\n", "plt.legend(['training', 'validation'],fontsize=15 )\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 28, "id": "a9021a27-d749-4e0f-b1a6-e1ef4f00832a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Results of trivial Example\n", "\n", " precision recall f1-score support\n", "\n", " 0.0 0.81 0.80 0.80 486\n", " 1.0 0.80 0.81 0.80 483\n", "\n", " accuracy 0.80 969\n", " macro avg 0.80 0.80 0.80 969\n", "weighted avg 0.80 0.80 0.80 969\n", "\n" ] } ], "source": [ "FinalMdl2.to(device=device)\n", "FinalMdl2.eval()\n", "ytrue=torch.zeros(len(testloaderFT.dataset))\n", "ypred=torch.zeros_like(ytrue)\n", "cnt=0\n", "for i, (X, Y) in enumerate(testloaderFT):\n", " X=X.to(device=device)\n", " ytrue[cnt:cnt+X.shape[0]]= Y \n", " with torch.no_grad():\n", " yhat = torch.sigmoid(FinalMdl2(X)).to(device='cpu')\n", " ypred[cnt:cnt+X.shape[0]] = torch.squeeze(yhat) \n", " cnt += X.shape[0]\n", "\n", "print('Results of trivial Example\\n')\n", "print(classification_report(ytrue,ypred>0.5))" ] }, { "cell_type": "markdown", "id": "027bb03b-00cf-4ea1-9a40-6ac46393eb1a", "metadata": {}, "source": [ "We can see that the pretrained model has achieved a better validation loss in less epochs compared to the full-supervised strategy. Accuracies and F1-scores are almost identical, but this is expected considering that this tutorial uses only a small dataset and EEGNet, which is a very small model." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.6" } }, "nbformat": 4, "nbformat_minor": 5 }