{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":59093,"databundleVersionId":7469972,"sourceType":"competition"},{"sourceId":7392733,"sourceType":"datasetVersion","datasetId":4297749},{"sourceId":7392775,"sourceType":"datasetVersion","datasetId":4297782},{"sourceId":7447509,"sourceType":"datasetVersion","datasetId":4334995}],"dockerImageVersionId":30664,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Intro:\nSo I set myself the challenge of trying to come up with a decent model that didn't use any pre-trained components and get at least similar results to AbaoJiang's (modified from Chris Deotte's WaveNet) Dilated Inception Wavenet model: https://www.kaggle.com/code/abaojiang/lb-0-46-dilatedinception-wavenet-training.\n\nMy base idea was to try to mimick the idea that the evaluators might first look at the raw eeg signals and then look at the Kaggle spectrograms (specs) with the knowledge of the raw data partly determining what they look for in the spectrograms. The model evolved to using spectrograms of the raw eeg signals (eeg_specs) instead but the basic architecture remained the same. I first use convolutional layers to get feature maps of the raw eeg spectrograms and Kaggle spectrograms and then feed the features into 3 transformer layers in series. The raw eeg spectrogram features are fed in as queries, while the Kaggle spectrogram features are fed in as keys and values.\n\nInitially, considering the dimensions of the inputs that the transformer layers accept (and trying to be parameter efficient), I used 1D convolutional layers, treating the frequency domain as columns of factors. I then experimented and got good results with changing the middle layer of an (inverted) BottleNeck block to a 1 channel 2D convolution. Putting 3 BottleNeck blocks in parallel with kernel sizes of 3, 5 and 7 got me InceptionBottleNeck blocks.\n\nBelow is the high level architecture (Note!: kaggle specs start with a time dim of 300, resizing to 400 was an accident but fixing it didn't seem to help much for CV. I think playing around with the size could be interesting and might affect the relative regularisation effects of the XYMasking I used)\n\n![Inception BottleNeck Transformer Model Diagram.png](attachment:2e688c4c-5a42-4456-9e32-6263ff53a5ac.png)","metadata":{},"attachments":{"2e688c4c-5a42-4456-9e32-6263ff53a5ac.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"# Setup","metadata":{}},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport torch\nfrom torch import nn\nfrom torch.utils.data import Dataset, DataLoader\nfrom datetime import date, timedelta\nfrom torchvision import transforms\nimport time\nimport math\nimport gc\nimport polars as pl\nimport skimage.measure\nimport torch.optim.lr_scheduler as lr_scheduler\nimport random\nimport torch.nn.functional as F\nfrom scipy.signal import butter, lfilter\nimport skimage.measure\nimport polars as pl\nfrom sklearn.preprocessing import StandardScaler\nimport albumentations as A\nimport timm\nimport warnings\nfrom shutil import copyfile\ncopyfile(src = \"/kaggle/input/kaggle-kl-div/kaggle_kl_div.py\", dst = \"/kaggle//working/kaggle_kl_div.py\")\ncopyfile(src = \"/kaggle/input/kaggle-kl-div/kaggle_metric_utilities.py\", dst = \"/kaggle//working/kaggle_metric_utilities.py\")\nfrom kaggle_kl_div import score\n\nwarnings.filterwarnings('ignore', category=Warning)\n\n###########################################################\n\n# model params\nkdim = vdim = 32 # kaggle spec freq resize\nnum_heads = 4 # per attention layer\ndropout = 0.\nkernel_size = 3 # kernel_size for smallest conv layer\nn = 18 # total number of InceptionBottleNeck layers\nnum_channels = 32 # MultiTransBlock output channels\nnum_trans_blocks = 3\ndownsample = 8 # total amount of downsampling after all MultiConvBlocks\n\nwinsize_eeg_spec = 1024 # 4 eeg_specs stacked on top of one another in the time dimension\nwinsize_spec = 400 # Note kaggle specs start with a time dim of 300, resizing to 400 was an accident\n\n# training params\nw_decay = 0.0\nlearning_rate = 2e-3\nepochs = 25\nbatch_size = 32\nfolds = 5\nfold_idx = 2\nstarting_epoch = 0\n\nXavier_weights = True\n\nuse_amp = True\n\ndef set_seed(seed):\n    torch.backends.cudnn.deterministic = False\n    torch.backends.cudnn.benchmark = True\n    torch.manual_seed(seed)\n    np.random.seed(seed)\n    random.seed(seed)\n    \nseed = 45","metadata":{"execution":{"iopub.status.busy":"2024-03-15T01:09:52.585799Z","iopub.execute_input":"2024-03-15T01:09:52.586151Z","iopub.status.idle":"2024-03-15T01:09:52.604824Z","shell.execute_reply.started":"2024-03-15T01:09:52.586121Z","shell.execute_reply":"2024-03-15T01:09:52.603929Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Process Inputs","metadata":{}},{"cell_type":"code","source":"df = pd.read_csv('/kaggle/input/hms-harmful-brain-activity-classification/train.csv')\nTARGETS = df.columns[-6:]\n\ntrain = df.groupby('eeg_id')[['spectrogram_id','spectrogram_label_offset_seconds']].agg(\n    {'spectrogram_id':'first','spectrogram_label_offset_seconds':'min'})\ntrain.columns = ['spec_id','min']\n\ntmp = df.groupby('eeg_id')[['spectrogram_id','spectrogram_label_offset_seconds']].agg(\n    {'spectrogram_label_offset_seconds':'max'})\ntrain['max'] = tmp\n\ntmp = df.groupby('eeg_id')[['patient_id']].agg('first')\ntrain['patient_id'] = tmp\n\ntmp = df.groupby('eeg_id')[TARGETS].agg('sum')\nfor t in TARGETS:\n    train[t] = tmp[t].values\n    \ny_data = train[TARGETS].values\ny_data = y_data / y_data.sum(axis=1,keepdims=True)\ntrain[TARGETS] = y_data\n\ntmp = df.groupby('eeg_id')[['expert_consensus']].agg('first')\ntrain['target'] = tmp\n\ntrain = train.reset_index()\n\neeg_specs = np.load('/kaggle/input/brain-eeg-spectrograms/eeg_specs.npy',allow_pickle=True).item()\n\nspecs = np.load('/kaggle/input/brain-spectrograms/specs.npy',allow_pickle=True).item()","metadata":{"execution":{"iopub.status.busy":"2024-03-15T01:09:57.445955Z","iopub.execute_input":"2024-03-15T01:09:57.446824Z","iopub.status.idle":"2024-03-15T01:12:14.567692Z","shell.execute_reply.started":"2024-03-15T01:09:57.446789Z","shell.execute_reply":"2024-03-15T01:12:14.566736Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn.model_selection import GroupKFold\n\nset_seed(seed)\ngkf = GroupKFold(n_splits=folds)\nfor fold, (train_index, valid_index) in enumerate(gkf.split(train, train.target, train.patient_id)):\n    train.loc[valid_index, \"fold\"] = int(fold)\n    \ntraindata = train.loc[train['fold']!=fold_idx,:]\ntestdata = train.loc[train['fold']==fold_idx,:]\n\n###########################################################\n\nparams = {\n    \"num_masks_x\": 3,    \n    \"mask_x_length\": (0,5),\n    \"fill_value\": 0,\n    \"num_masks_y\": 3,    \n    \"mask_y_length\": (0,5),\n    \"fill_value\": 0, \n\n}\nAugment = A.Compose([A.XYMasking(**params, p=0.5),A.VerticalFlip(p=0.5)])\n#Augment = None\n\ndef getData(selection_data):\n    \n    eeg_data = np.nan_to_num(eeg_specs[selection_data.eeg_id].reshape(128,1024,order='F').T)\n    \n    spec_data = np.nan_to_num(specs[selection_data.spec_id],nan=-1.)\n    \n    r = int((selection_data['min'] + selection_data['max'])//4)\n    \n    spec_data = spec_data[r:r+300,:]\n\n    # Clip values and apply logarithmic transformation\n    spec_data = np.clip(spec_data, np.exp(-6), np.exp(10))\n    spec_data = np.log(spec_data)\n\n    # Normalize the data\n    data_mean = spec_data.mean(axis=(0, 1))\n    data_std = spec_data.std(axis=(0, 1))\n    spec_data = (spec_data - data_mean) / (data_std + 1e-6)\n    \n    cols = ['seizure_vote',\n           'lpd_vote', 'gpd_vote', 'lrda_vote', 'grda_vote', 'other_vote']\n    labels = selection_data.loc[cols]\n    \n    return labels, eeg_data, spec_data\n\nclass GetDataset(Dataset):\n    def __init__(self,seldata,transform=None,augmentations=None,train=False):\n        self.sel_data = seldata\n        self.transform = transform\n        # create index map\n        self.length = len(seldata)\n        self.augmentations = augmentations\n\n    def __len__(self):\n        return self.length\n\n    def __getitem__(self, idx):\n        if torch.is_tensor(idx):\n            idx = idx.tolist()\n        \n        labels, eeg_dat, spec_dat = getData(self.sel_data.iloc[idx,:])\n        \n        if self.augmentations:\n            eeg_dat = self.augmentations(image=eeg_dat)['image']\n            spec_dat = self.augmentations(image=spec_dat)['image']\n        \n        sample = {'eeg': eeg_dat,'spec':spec_dat, 'labels': labels}\n\n        if self.transform:\n            sample = self.transform(sample)\n\n        return sample\n    \nclass ToTensor(object):\n    def __call__(self, sample):\n        new_eeg_spec = torch.from_numpy(np.array(sample['eeg'],dtype='float32'))\n        \n        resize = transforms.Resize((winsize_spec,kdim)) \n        new_spec = torch.unsqueeze(torch.from_numpy(np.array(sample['spec'],dtype='float32')),dim=0)\n        new_spec = resize(new_spec)\n        new_spec = new_spec.squeeze()\n\n        new_labels = sample['labels']\n        new_labels = torch.from_numpy(np.array(new_labels,dtype='float32'))\n        \n        return {'eeg': new_eeg_spec,\n                'spec': new_spec,\n                'labels': new_labels}\n\ndef get_score(preds, targets):\n    oof = pd.DataFrame(preds.copy())\n    oof['id'] = np.arange(len(oof))\n\n    true = pd.DataFrame(targets.copy())\n    true['id'] = np.arange(len(true))\n\n    cv = score(solution=true, submission=oof, row_id_column_name='id')\n    return cv\n\ndevice = (\n    \"cuda\"\n    if torch.cuda.is_available()\n    else \"mps\"\n    if torch.backends.mps.is_available()\n    else \"cpu\"\n)\nprint(f\"Using {device} device\")","metadata":{"execution":{"iopub.status.busy":"2024-03-15T01:12:44.160269Z","iopub.execute_input":"2024-03-15T01:12:44.161146Z","iopub.status.idle":"2024-03-15T01:12:44.266600Z","shell.execute_reply.started":"2024-03-15T01:12:44.161107Z","shell.execute_reply":"2024-03-15T01:12:44.265612Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Model","metadata":{}},{"cell_type":"code","source":"class InceptionBottleNeck(nn.Module):\n    def __init__(self, num_channels,kernel_size=3):\n        super().__init__()\n        self.conv_expand = nn.LazyConv1d(out_channels=num_channels*2,kernel_size=1)\n        self.conv_depth = nn.LazyConv2d(out_channels=1,\n                                         kernel_size=kernel_size,\n                                         padding='same')\n        self.conv_contract = nn.LazyConv1d(out_channels=num_channels,kernel_size=1)\n        self.bn1 = nn.LazyBatchNorm1d()\n        self.bn2 = nn.LazyBatchNorm1d()\n        self.bn3 = nn.LazyBatchNorm1d()\n        self.relu1 = nn.ReLU6()\n        self.relu2 = nn.ReLU6()\n        \n        self.conv_expand_b = nn.LazyConv1d(out_channels=num_channels*2,kernel_size=1)\n        self.conv_depth_b = nn.LazyConv2d(out_channels=1,\n                                         kernel_size=kernel_size+2,\n                                         padding='same')\n        self.conv_contract_b = nn.LazyConv1d(out_channels=num_channels,kernel_size=1)\n        self.bn1_b = nn.LazyBatchNorm1d()\n        self.bn2_b = nn.LazyBatchNorm1d()\n        self.bn3_b = nn.LazyBatchNorm1d()\n        self.relu1_b = nn.ReLU6()\n        self.relu2_b = nn.ReLU6()\n        \n        self.conv_expand_c = nn.LazyConv1d(out_channels=num_channels*2,kernel_size=1)\n        self.conv_depth_c = nn.LazyConv2d(out_channels=1,\n                                         kernel_size=kernel_size+4,\n                                         padding='same')\n        self.conv_contract_c = nn.LazyConv1d(out_channels=num_channels,kernel_size=1)\n        self.bn1_c = nn.LazyBatchNorm1d()\n        self.bn2_c = nn.LazyBatchNorm1d()\n        self.bn3_c = nn.LazyBatchNorm1d()\n        self.relu1_c = nn.ReLU6()\n        self.relu2_c = nn.ReLU6()\n    \n    def forward(self,x):\n        x = x.transpose(1,2)\n        \n        y1 = self.relu1(self.bn1(self.conv_expand(x)))\n        y1 = self.conv_depth(y1.unsqueeze(1)).squeeze(1)\n        y1 = self.relu2(self.bn2(y1))\n        y1 = self.conv_contract(y1)\n        \n        y2 = self.relu1_b(self.bn1_b(self.conv_expand_b(x)))\n        y2 = self.conv_depth_b(y2.unsqueeze(1)).squeeze(1)\n        y2 = self.relu2_b(self.bn2_b(y2))\n        y2 = self.conv_contract_b(y2)\n        \n        y3 = self.relu1_c(self.bn1_c(self.conv_expand_c(x)))\n        y3 = self.conv_depth_c(y3.unsqueeze(1)).squeeze(1)\n        y3 = self.relu2_c(self.bn2_c(y3))\n        y3 = self.conv_contract_c(y3)\n        \n        out = (x + y1 + y2 + y3).transpose(1,2)\n        return out\n\nclass MultiConvBlock(nn.Module):\n    def bottleBlock(self,n,num_channels,kernel_size):\n        blk = []\n        for i in range(n):\n            blk.append(InceptionBottleNeck(num_channels=num_channels,\n                                  kernel_size=kernel_size))\n        return nn.Sequential(*blk)\n    \n    def __init__(self,n,num_channels,kernel_size,downsample):\n        super().__init__()\n        self.bottle = self.bottleBlock(n=n,\n                                num_channels=num_channels,\n                                kernel_size=kernel_size)\n        self.pool = nn.MaxPool1d(kernel_size=downsample)\n    \n    def forward(self,x):\n        skip = x\n        x = self.bottle(x)\n        x = 0.9*x + 0.1*skip\n        x = self.pool(x.transpose(1,2)).transpose(1,2)\n        return x\n        \nclass PositionalEncoding(nn.Module):\n    def __init__(self, d_model: int, dropout: float = 0.1, max_len: int = 5000):\n        super().__init__()\n        self.dropout = nn.Dropout(p=dropout)\n\n        position = torch.arange(max_len).unsqueeze(1)\n        div_term = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model))\n        pe = torch.zeros(1, max_len, d_model)\n        pe[0, :, 0::2] = torch.sin(position * div_term)\n        pe[0, :, 1::2] = torch.cos(position * div_term)\n        self.register_buffer('pe', pe)\n\n    def forward(self,x):\n        x = x + self.pe[:x.size(0)]\n        return self.dropout(x)\n\nclass TransBlock(nn.Module):\n    def __init__(self,embed_dim,num_heads,kdim,vdim,num_channels,dropout):\n        super().__init__()\n        self.attn = nn.MultiheadAttention(embed_dim=embed_dim,\n                                               num_heads=num_heads,\n                                               batch_first=True,\n                                               kdim=kdim,\n                                               vdim=vdim)\n        self.ff1 = nn.LazyLinear(num_channels)\n        self.ff2 = nn.LazyLinear(num_channels)\n        self.ln1 = nn.LayerNorm(num_channels)\n        self.ln2 = nn.LayerNorm(num_channels)\n        self.drop = nn.Dropout(dropout)\n        self.gelu = nn.GELU()\n    \n    def forward(self,query,key,value):\n        y,y_weights = self.attn(query,key,value,need_weights=False)\n        x = self.ln1(query + y)\n        z = self.drop(self.ff2(self.gelu(self.ff1(x))))\n        x = self.ln2(x + z)\n        return x\n\nclass InceptBottleTrans(nn.Module):\n    def __init__(self,\n                 num_trans_blocks,\n                 kdim,num_channels,\n                 winsize_eeg_spec,\n                 winsize_spec,\n                 num_heads,\n                 n,\n                 kernel_size,\n                 downsample):\n        super().__init__()\n        self.pos_enc_eeg_spec = PositionalEncoding(d_model=num_channels,max_len=int(winsize_eeg_spec/downsample))\n        self.pos_enc_spec = PositionalEncoding(d_model=kdim,max_len=winsize_spec)\n        \n        self.ff_eeg_spec = nn.LazyLinear(num_channels)\n        self.ff_spec = nn.LazyLinear(kdim)\n        \n        self.convBlock_eeg_spec = nn.Sequential(MultiConvBlock(int(n/3),\n                                                          num_channels,\n                                                          kernel_size,\n                                                          int(downsample**(1/3))),\n                                           MultiConvBlock(int(n/3),\n                                                          num_channels,\n                                                          kernel_size,\n                                                          int(downsample**(1/3))),\n                                           MultiConvBlock(int(n/3),\n                                                          num_channels,\n                                                          kernel_size,\n                                                          int(downsample**(1/3))))\n        \n        self.convBlock_spec = nn.Sequential(MultiConvBlock(int(n/3),\n                                                           kdim,\n                                                           kernel_size,\n                                                           1),\n                                            MultiConvBlock(int(n/3),\n                                                           kdim,\n                                                           kernel_size,\n                                                           1),\n                                            MultiConvBlock(int(n/3),\n                                                           kdim,\n                                                           kernel_size,\n                                                           1))\n        \n        self.transblock_list = nn.ModuleList()\n        for _ in range(num_trans_blocks):\n            self.transblock_list.append(TransBlock(num_channels,\n                                                   num_heads,\n                                                   kdim,\n                                                   kdim,\n                                                   num_channels,\n                                                   dropout))\n        self.final_pool = nn.AdaptiveAvgPool1d(32)\n        self.flatten = nn.Flatten()\n        self.head = nn.Sequential(nn.LazyLinear(64),nn.ReLU(),nn.LazyLinear(6))\n        \n    def forward(self,eeg_spec,spec):\n        eeg_spec = self.ff_eeg_spec(eeg_spec)\n        spec = self.ff_spec(spec)\n        \n        eeg_spec = self.convBlock_eeg_spec(eeg_spec)\n        spec = self.convBlock_spec(spec)\n        \n        eeg_spec = self.pos_enc_eeg_spec(eeg_spec)\n        spec = self.pos_enc_spec(spec)\n        \n        for i in range(num_trans_blocks):\n            eeg_spec = self.transblock_list[i](eeg_spec,spec,spec)\n        \n        eeg_spec = self.final_pool(eeg_spec.transpose(1,2))\n        eeg_spec = self.flatten(eeg_spec)\n        eeg_spec = self.head(eeg_spec)\n        return eeg_spec","metadata":{"execution":{"iopub.status.busy":"2024-03-15T01:12:49.074452Z","iopub.execute_input":"2024-03-15T01:12:49.074902Z","iopub.status.idle":"2024-03-15T01:12:49.113516Z","shell.execute_reply.started":"2024-03-15T01:12:49.074874Z","shell.execute_reply":"2024-03-15T01:12:49.112778Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Train and Test fns","metadata":{}},{"cell_type":"code","source":"def train_loop(seldata,model,loss_fn,optimizer,loss_vals,log):\n\n    train_data = GetDataset(seldata=seldata,\n                            transform=transforms.Compose([ToTensor()]),\n                            augmentations=Augment,\n                            train=False)\n    \n    dataloader = DataLoader(train_data,batch_size=batch_size,shuffle=True)\n    \n    model.train()\n    for i,batch in enumerate(dataloader):\n        eeg_spec = batch['eeg'].to(device)\n        spec = batch['spec'].to(device)\n        y = batch['labels'].to(device)\n        \n        if torch.any(torch.isnan(eeg_spec.to('cpu'))) or torch.any(torch.isnan(y.to('cpu'))):\n            print('Nan!')\n            break\n        \n        with torch.autocast(device_type=device, dtype=torch.float16, enabled=use_amp):\n            pred = model(eeg_spec,spec)\n            loss = loss_fn(F.log_softmax(pred,dim=1),y)\n        \n        scaler.scale(loss).backward()\n        torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1)\n        scaler.step(optimizer)\n        scaler.update()\n        optimizer.zero_grad()\n        scheduler.step()\n        \n    ### Testing\n    if log:\n        model.eval()\n        with torch.no_grad():\n            pred_tot = torch.tensor([])\n            y_tot = torch.tensor([])\n            for i,batch in enumerate(dataloader):\n                eeg_spec = batch['eeg'].to(device)\n                spec = batch['spec'].to(device)\n                y1 = batch['labels']\n                \n                with torch.autocast(device_type=device, dtype=torch.float16, enabled=use_amp):\n                    train_pred = model(eeg_spec,spec).to('cpu')\n                \n                pred_tot = torch.cat((pred_tot,train_pred))\n                y_tot = torch.cat((y_tot,y1))\n                \n            with torch.autocast(device_type=device, dtype=torch.float16, enabled=use_amp):\n                train_loss = loss_fn(F.log_softmax(pred_tot,dim=1),y_tot).item()\n            loss_vals.append(train_loss)\n    \n    gc.collect()\n            \ndef test_loop(seldata,model,loss_fn,loss_vals,log):\n    \n    test_data = GetDataset(seldata=seldata,\n                            transform=transforms.Compose([ToTensor()]),\n                            train=False)\n    \n    dataloader = DataLoader(test_data,batch_size=batch_size,shuffle=True)\n    \n    if log:\n        pred_tot = torch.tensor([])\n        y_tot = torch.tensor([])\n        with torch.no_grad():\n            for i,batch in enumerate(dataloader):\n                eeg_spec = batch['eeg'].to(device)\n                spec = batch['spec'].to(device)\n                y = batch['labels']\n                \n                with torch.autocast(device_type=device, dtype=torch.float16, enabled=use_amp):\n                    pred = model(eeg_spec,spec).to('cpu')\n                \n                pred_tot = torch.cat((pred_tot,pred))\n                y_tot = torch.cat((y_tot,y))\n        \n            with torch.autocast(device_type=device, dtype=torch.float16, enabled=use_amp):\n                test_loss = loss_fn(F.log_softmax(pred_tot,dim=1),y_tot).item()\n            loss_vals.append(test_loss)\n    \n    gc.collect()\n    \ndef init_weights(m):\n    if isinstance(m,nn.Conv1d):\n        torch.nn.init.xavier_uniform_(m.weight)\n        nn.init.zeros_(m.bias)\n\ndef update_oof(seldata,model):\n    test_data = GetDataset(seldata=seldata,\n                            transform=transforms.Compose([ToTensor()]),\n                            train=False)\n    \n    dataloader = DataLoader(test_data,batch_size=batch_size,shuffle=False)\n    \n    pred_tot = torch.tensor([])\n    y_tot = torch.tensor([])\n    with torch.no_grad():\n        for i,batch in enumerate(dataloader):\n            eeg_spec = batch['eeg'].to(device)\n            spec = batch['spec'].to(device)\n            y = batch['labels']\n            \n            with torch.autocast(device_type=device, dtype=torch.float16, enabled=use_amp):\n                pred = model(eeg_spec,spec).to('cpu')\n            \n            pred_tot = torch.cat((pred_tot,pred))\n            y_tot = torch.cat((y_tot,y))\n    \n        _oof_df = pd.DataFrame()\n        _oof_df[[f\"pred_{c}\" for c in list(TARGETS)]] = F.softmax(pred_tot,dim=1).numpy()\n        _oof_df[[f\"actual_{c}\" for c in list(TARGETS)]] = y_tot.numpy()\n    \n    gc.collect()\n    return _oof_df","metadata":{"execution":{"iopub.status.busy":"2024-03-15T01:13:24.273324Z","iopub.execute_input":"2024-03-15T01:13:24.273726Z","iopub.status.idle":"2024-03-15T01:13:24.299094Z","shell.execute_reply.started":"2024-03-15T01:13:24.273695Z","shell.execute_reply":"2024-03-15T01:13:24.298159Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Train Model","metadata":{}},{"cell_type":"code","source":"name = \"InceptBottleTransformer_\"\n\nset_seed(seed)\noof = []\noof_df = pd.DataFrame()\nfor fold in range(folds):\n    print(f'Fold {fold+1}')\n    traindata = train.loc[train['fold']!=fold,:]\n    testdata = train.loc[train['fold']==fold,:]\n    \n    model = InceptBottleTrans(num_trans_blocks,\n                       kdim,\n                       num_channels,\n                       winsize_eeg_spec,\n                       winsize_spec,\n                       num_heads,\n                       n,\n                       kernel_size,\n                       downsample).to(device)\n\n    if Xavier_weights:\n        dat = GetDataset(seldata=traindata,\n                         transform=transforms.Compose([ToTensor()])).__getitem__(0)\n        e = dat['eeg'].unsqueeze(0).to(device)\n        s = dat['spec'].unsqueeze(0).to(device)\n        model(e,s)\n        model.apply(init_weights)\n\n    loss_fn = nn.KLDivLoss(reduction=\"batchmean\")\n\n    optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=w_decay)\n    scheduler = lr_scheduler.OneCycleLR(optimizer=optimizer,\n                                        max_lr=learning_rate,\n                                        epochs=epochs,\n                                        steps_per_epoch=math.ceil(len(traindata)/batch_size))\n    scaler = torch.cuda.amp.GradScaler(enabled=use_amp)\n    \n    loss_values = []\n    test_loss_values = []\n    best_test_loss = None\n    for t in range(0,epochs):\n        train_loop(traindata, model, loss_fn, optimizer,loss_values,log=True)\n        test_loop(testdata,model,loss_fn,test_loss_values,log=True)\n        \n        if test_loss_values[-1]==np.min(test_loss_values):\n            print(f'Epoch {t+1} Test loss - {test_loss_values[-1]}')\n            torch.save(model.state_dict(), f'{name}_fold{fold}.pt')\n            best_test_loss = test_loss_values[-1]\n            _oof_df = update_oof(testdata, model)\n        \n        gc.collect()\n    \n    oof.append(best_test_loss)\n    del model\n    torch.cuda.empty_cache()\n    oof_df = pd.concat([oof_df,_oof_df])\n\nprint(\"Mean OOF loss:\" + str(np.mean(oof)))\noof_pred = oof_df[[f\"pred_{c}\" for c in list(TARGETS)]]\noof_pred.columns = TARGETS\noof_pred['id'] = np.arange(len(oof_df))\noof_pred.reset_index(inplace=True, drop=True)\noof_actual = oof_df[[f\"actual_{c}\" for c in list(TARGETS)]]\noof_actual.columns = TARGETS\noof_actual['id'] = np.arange(len(oof_df))\noof_actual.reset_index(inplace=True, drop=True)\nprint('OOF Score:' + str(score(submission=oof_pred,solution=oof_actual,row_id_column_name='id')))","metadata":{},"execution_count":null,"outputs":[]}]}