features-head-starter-train.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0fb01e46",
   "metadata": {
    "papermill": {
     "duration": 0.027685,
     "end_time": "2024-03-04T16:39:26.467058",
     "exception": false,
     "start_time": "2024-03-04T16:39:26.439373",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "This is based on the [EfficientNetB0 Starter](https://www.kaggle.com/code/cdeotte/efficientnetb0-starter-lb-0-43) notebook, modified for Pytorch. The original notebook is implemented in Tensorflow.\n",
    "\n",
    "* Change to pytorch's Dataset and Dataloader\n",
    "* Use efficientnet_b0 from torchvision\n",
    "* Use pytorch lightning for building the model and training\n",
    "* Inference using Trainer on multiple GPUs (DDP strategy) requires adding predictions gathering code, otherwise it will hang waiting for other nodes. So the raw pytorch's inference loop is used in the CV part. This needs to be done after training all the folds since the manual torch's GPU device initialization can't be mixed with lightning's DDP strategy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e8c76062",
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "papermill": {
     "duration": 13.776949,
     "end_time": "2024-03-04T16:39:40.272705",
     "exception": false,
     "start_time": "2024-03-04T16:39:26.495756",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import gc\n",
    "from time import time\n",
    "import random\n",
    "sys.path.append('/root/autodl-tmp/kaggle-kl-div')\n",
    "from kaggle_kl_div import score\n",
    "import typing as tp\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torch import optim\n",
    "from torch.optim import lr_scheduler\n",
    "from torch.cuda import amp\n",
    "import pandas as pd, numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import albumentations as albu\n",
    "from sklearn.model_selection import KFold, GroupKFold\n",
    "import timm\n",
    "from pathlib import Path\n",
    "import shutil\n",
    "from tqdm.notebook import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "914766d4-1215-419a-a1c3-647c6dcfae40",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import subprocess\n",
    "import os\n",
    "\n",
    "result = subprocess.run('bash -c \"source /etc/network_turbo && env | grep proxy\"', shell=True, capture_output=True, text=True)\n",
    "output = result.stdout\n",
    "for line in output.splitlines():\n",
    "    if '=' in line:\n",
    "        var, value = line.split('=', 1)\n",
    "        os.environ[var] = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9eeb210f",
   "metadata": {
    "papermill": {
     "duration": 0.036261,
     "end_time": "2024-03-04T16:39:40.335394",
     "exception": false,
     "start_time": "2024-03-04T16:39:40.299133",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class CFG:\n",
    "    model_name = 'tf_efficientnet_b0_ns'#\"resnet34d\"\n",
    "    img_size = 512\n",
    "    max_epoch = 15\n",
    "    batch_size = 32\n",
    "    lr = 1.0e-03\n",
    "    weight_decay = 1.0e-02\n",
    "    es_patience =  10\n",
    "    seed = 1086\n",
    "    enable_amp = True\n",
    "    device = \"cuda\"\n",
    "    USE_KAGGLE_SPECTROGRAMS = True\n",
    "    USE_EEG_SPECTROGRAMS = True\n",
    "    READ_SPEC_FILES = False\n",
    "    READ_EEG_SPEC_FILES = False\n",
    "    READ_RAW_EEGS = False\n",
    "    VER = 5\n",
    "    data_type = 'both'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84472083",
   "metadata": {
    "papermill": {
     "duration": 0.029054,
     "end_time": "2024-03-04T16:39:40.394027",
     "exception": false,
     "start_time": "2024-03-04T16:39:40.364973",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "524feb03",
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "papermill": {
     "duration": 0.038353,
     "end_time": "2024-03-04T16:39:40.460078",
     "exception": false,
     "start_time": "2024-03-04T16:39:40.421725",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def add_kl(data):\n",
    "    import torch\n",
    "    labels = data[TARGETS].values + 1e-5\n",
    "\n",
    "    # compute kl-loss with uniform distribution by pytorch\n",
    "    data['kl'] = torch.nn.functional.kl_div(\n",
    "        torch.log(torch.tensor(labels)),\n",
    "        torch.tensor([1 / 6] * 6),\n",
    "        reduction='none'\n",
    "    ).sum(dim=1).numpy()\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "82b03128",
   "metadata": {
    "papermill": {
     "duration": 0.47463,
     "end_time": "2024-03-04T16:39:40.965118",
     "exception": false,
     "start_time": "2024-03-04T16:39:40.490488",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train shape: (106800, 15)\n",
      "Targets ['seizure_vote', 'lpd_vote', 'gpd_vote', 'lrda_vote', 'grda_vote', 'other_vote']\n",
      "       eeg_id  eeg_sub_id  eeg_label_offset_seconds  spectrogram_id  \\\n",
      "0  1628180742           0                       0.0          353733   \n",
      "1  1628180742           1                       6.0          353733   \n",
      "2  1628180742           2                       8.0          353733   \n",
      "3  1628180742           3                      18.0          353733   \n",
      "4  1628180742           4                      24.0          353733   \n",
      "\n",
      "   spectrogram_sub_id  spectrogram_label_offset_seconds    label_id  \\\n",
      "0                   0                               0.0   127492639   \n",
      "1                   1                               6.0  3887563113   \n",
      "2                   2                               8.0  1142670488   \n",
      "3                   3                              18.0  2718991173   \n",
      "4                   4                              24.0  3080632009   \n",
      "\n",
      "   patient_id expert_consensus  seizure_vote  lpd_vote  gpd_vote  lrda_vote  \\\n",
      "0       42516          Seizure             3         0         0          0   \n",
      "1       42516          Seizure             3         0         0          0   \n",
      "2       42516          Seizure             3         0         0          0   \n",
      "3       42516          Seizure             3         0         0          0   \n",
      "4       42516          Seizure             3         0         0          0   \n",
      "\n",
      "   grda_vote  other_vote  \n",
      "0          0           0  \n",
      "1          0           0  \n",
      "2          0           0  \n",
      "3          0           0  \n",
      "4          0           0  \n",
      "   eeg_id    spec_id  offset  patient_id target  seizure_vote  lpd_vote  gpd_vote  lrda_vote  grda_vote  other_vote        kl\n",
      "0  568657  789577333     0.0       20654  Other           0.0       0.0      0.25        0.0   0.166667    0.583333  4.584192\n"
     ]
    }
   ],
   "source": [
    "train = pd.read_csv('/root/autodl-tmp/hms-harmful-brain-activity-classification/train.csv')\n",
    "TARGETS = ['seizure_vote', 'lpd_vote', 'gpd_vote', 'lrda_vote', 'grda_vote', 'other_vote']\n",
    "\n",
    "print('Train shape:', train.shape )\n",
    "print('Targets', list(TARGETS))\n",
    "print(train.head())\n",
    "META = ['spectrogram_id','spectrogram_label_offset_seconds','patient_id','expert_consensus']\n",
    "train = train.groupby('eeg_id')[META+TARGETS\n",
    "                       ].agg({**{m:'first' for m in META},**{t:'sum' for t in TARGETS}}).reset_index() \n",
    "train[TARGETS] = train[TARGETS]/train[TARGETS].values.sum(axis=1,keepdims=True)\n",
    "train.columns = ['eeg_id','spec_id','offset','patient_id','target'] + TARGETS\n",
    "train = add_kl(train)\n",
    "print(train.head(1).to_string())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "257eff67",
   "metadata": {
    "papermill": {
     "duration": 0.037448,
     "end_time": "2024-03-04T16:39:41.033444",
     "exception": false,
     "start_time": "2024-03-04T16:39:40.995996",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(17089, 12)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "21867c0b",
   "metadata": {
    "papermill": {
     "duration": 124.956108,
     "end_time": "2024-03-04T16:41:46.015761",
     "exception": false,
     "start_time": "2024-03-04T16:39:41.059653",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 11138 spectrogram parquets\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# READ ALL SPECTROGRAMS\n",
    "PATH = '/root/autodl-tmp/hms-harmful-brain-activity-classification/train_spectrograms/'\n",
    "files = os.listdir(PATH)\n",
    "print(f'There are {len(files)} spectrogram parquets')\n",
    "\n",
    "if CFG.READ_SPEC_FILES:    \n",
    "    spectrograms = {}\n",
    "    for i,f in enumerate(files):\n",
    "        if i % 100 == 0:\n",
    "            print(i, ', ', end='')\n",
    "        tmp = pd.read_parquet(f'{PATH}{f}')\n",
    "        name = int(f.split('.')[0])\n",
    "        spectrograms[name] = tmp.iloc[:,1:].values\n",
    "else:\n",
    "    spectrograms = np.load('/root/autodl-tmp/brain-spectrograms/specs.npy',allow_pickle=True).item()\n",
    "    \n",
    "\n",
    "\n",
    "if CFG.READ_EEG_SPEC_FILES:\n",
    "    all_eegs = {}\n",
    "    for i,e in enumerate(train.eeg_id.values):\n",
    "        if i % 100 == 0:\n",
    "            print(i, ', ', end='')\n",
    "        x = np.load(f'/root/autodl-tmp/brain-eeg-spectrograms/EEG_Spectrograms/{e}.npy')\n",
    "        all_eegs[e] = x\n",
    "else:\n",
    "#     all_eegs = np.load('/kaggle/input/brain-eeg-spectrograms/eeg_specs.npy',allow_pickle=True).item()\n",
    "    all_eegs = np.load('/root/autodl-tmp/eeg-spectrograms/eeg_specs.npy',allow_pickle=True).item()\n",
    "    \n",
    "if CFG.READ_RAW_EEGS:\n",
    "    all_raw_eegs = np.load('/root/autodl-tmp/brain-eegs/eegs.npy',allow_pickle=True).item()\n",
    "else:\n",
    "    all_raw_eegs = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "653e16a4",
   "metadata": {
    "papermill": {
     "duration": 0.026386,
     "end_time": "2024-03-04T16:41:46.069010",
     "exception": false,
     "start_time": "2024-03-04T16:41:46.042624",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7affd7f",
   "metadata": {
    "papermill": {
     "duration": 0.025725,
     "end_time": "2024-03-04T16:41:46.120786",
     "exception": false,
     "start_time": "2024-03-04T16:41:46.095061",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "79de9214",
   "metadata": {
    "papermill": {
     "duration": 0.078792,
     "end_time": "2024-03-04T16:41:46.225162",
     "exception": false,
     "start_time": "2024-03-04T16:41:46.146370",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "TARS = {'Seizure':0, 'LPD':1, 'GPD':2, 'LRDA':3, 'GRDA':4, 'Other':5}\n",
    "TARS2 = {x: y for y, x in TARS.items()}\n",
    "\n",
    "\n",
    "class EEGDataset(Dataset):\n",
    "    \n",
    "    def __init__(self, data, augment=False, mode='train', specs=None, eeg_specs=None, raw_eegs=None, data_type='both'): \n",
    "        self.data = data\n",
    "        self.augment = augment\n",
    "        self.mode = mode\n",
    "        self.specs = specs\n",
    "        self.eeg_specs = eeg_specs\n",
    "        self.raw_eegs = raw_eegs\n",
    "        self.data_type = data_type\n",
    "        \n",
    "    def __len__(self):\n",
    "        return self.data.shape[0]\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        X, y = self._generate_data(index)\n",
    "        if self.augment:\n",
    "            X = self._augment(X) \n",
    "#         if self.mode == 'train':\n",
    "        return X, y\n",
    "#         else:\n",
    "#             return X\n",
    "    \n",
    "#     def __getitems__(self, index):\n",
    "#         print(index)\n",
    "#         X, y = self._generate_data(index)\n",
    "#         if self.augment:\n",
    "#             X = self._augment(X) \n",
    "#         return list(zip(X, y))\n",
    "    \n",
    "    def _generate_data(self, index):\n",
    "        if self.data_type == 'both':\n",
    "            X,y = self.generate_all_specs(index)\n",
    "        elif self.data_type == 'eeg' or self.data_type == 'kaggle':\n",
    "            X,y = self.generate_specs(index)\n",
    "        elif self.data_type == 'raw':\n",
    "            X,y = self.generate_raw(index)\n",
    "\n",
    "        return X,y\n",
    "        \n",
    "    def generate_all_specs(self, index):\n",
    "        X = np.zeros((512,512,3),dtype='float32')\n",
    "        y = np.zeros((6,),dtype='float32')\n",
    "    \n",
    "        row = self.data.iloc[index]\n",
    "        if self.mode == 'test': \n",
    "            offset = 0\n",
    "        else:\n",
    "            offset = int(row.offset/2)\n",
    "        eeg = self.eeg_specs[row.eeg_id]\n",
    "        spec = self.specs[row.spec_id]\n",
    "            \n",
    "        imgs = [spec[offset:offset+300,k*100:(k+1)*100].T for k in range(4)]\n",
    "        img = np.stack(imgs,axis=-1)\n",
    "        # LOG TRANSFORM SPECTROGRAM\n",
    "        img = np.clip(img,np.exp(-4),np.exp(8))\n",
    "        img = np.log(img)\n",
    "\n",
    "        # STANDARDIZE PER IMAGE\n",
    "        img = np.nan_to_num(img, nan=0.0)    \n",
    "            \n",
    "        mn = img.flatten().min()\n",
    "        mx = img.flatten().max()\n",
    "        ep = 1e-5\n",
    "        img = 255 * (img - mn) / (mx - mn + ep)\n",
    "        X[0_0+56:100+56,:256,0] = img[:,22:-22,0] # LL_k\n",
    "        X[100+56:200+56,:256,0] = img[:,22:-22,2] # LP_k\n",
    "        X[0_0+56:100+56,:256,1] = img[:,22:-22,1] # RL_k\n",
    "        X[100+56:200+56,:256,1] = img[:,22:-22,3] # RP_k\n",
    "\n",
    "        X[0_0+56:100+56,256:,0] = img[:,22:-22,0] # LL_k\n",
    "        X[100+56:200+56,256:,0] = img[:,22:-22,1] # RL_k\n",
    "        X[0_0+56:100+56,256:,1] = img[:,22:-22,2] # LP_k\n",
    "        X[100+56:200+56,256:,1] = img[:,22:-22,3] # RP_K\n",
    "\n",
    "        # EEG\n",
    "        img = eeg\n",
    "        mn = img.flatten().min()\n",
    "        mx = img.flatten().max()\n",
    "        ep = 1e-5\n",
    "        img = 255 * (img - mn) / (mx - mn + ep)\n",
    "        X[200+56:300+56,:256,0] = img[:,22:-22,0] # LL_e\n",
    "        X[300+56:400+56,:256,0] = img[:,22:-22,2] # RL_e\n",
    "        X[200+56:300+56,:256,1] = img[:,22:-22,1] # LP_e\n",
    "        X[300+56:400+56,:256,1] = img[:,22:-22,3] # RP_e\n",
    "\n",
    "        X[200+56:300+56,256:,0] = img[:,22:-22,0] # LL_e\n",
    "        X[300+56:400+56,256:,0] = img[:,22:-22,1] # LP_e\n",
    "        X[200+56:300+56,256:,1] = img[:,22:-22,2] # RL_e\n",
    "        X[300+56:400+56,256:,1] = img[:,22:-22,3] # RP_e\n",
    "        \n",
    "        if self.mode!='test':\n",
    "            y[:] = row[TARGETS]\n",
    "        \n",
    "        return X,y\n",
    "    \n",
    "    def generate_specs(self, index):\n",
    "        X = np.zeros((512,512,3),dtype='float32')\n",
    "        y = np.zeros((6,),dtype='float32')\n",
    "        \n",
    "        row = self.data.iloc[index]\n",
    "        if self.mode=='test': \n",
    "            offset = 0\n",
    "        else:\n",
    "            offset = int(row.offset/2)\n",
    "            \n",
    "        if self.data_type == 'eeg':\n",
    "            img = self.eeg_specs[row.eeg_id]\n",
    "        elif self.data_type == 'kaggle':\n",
    "            spec = self.specs[row.spec_id]\n",
    "            imgs = [spec[offset:offset+300,k*100:(k+1)*100].T for k in range(4)]\n",
    "            img = np.stack(imgs,axis=-1)\n",
    "            # LOG TRANSFORM SPECTROGRAM\n",
    "            img = np.clip(img,np.exp(-4),np.exp(8))\n",
    "            img = np.log(img)\n",
    "            \n",
    "            # STANDARDIZE PER IMAGE\n",
    "            img = np.nan_to_num(img, nan=0.0)    \n",
    "            \n",
    "        mn = img.flatten().min()\n",
    "        mx = img.flatten().max()\n",
    "        ep = 1e-5\n",
    "        img = 255 * (img - mn) / (mx - mn + ep)\n",
    "        \n",
    "        X[0_0+56:100+56,:256,0] = img[:,22:-22,0]\n",
    "        X[100+56:200+56,:256,0] = img[:,22:-22,2]\n",
    "        X[0_0+56:100+56,:256,1] = img[:,22:-22,1]\n",
    "        X[100+56:200+56,:256,1] = img[:,22:-22,3]\n",
    "        \n",
    "        X[0_0+56:100+56,256:,0] = img[:,22:-22,0]\n",
    "        X[100+56:200+56,256:,0] = img[:,22:-22,1]\n",
    "        X[0_0+56:100+56,256:,1] = img[:,22:-22,2]\n",
    "        X[100+56:200+56,256:,1] = img[:,22:-22,3]\n",
    "        \n",
    "        X[200+56:300+56,:256,0] = img[:,22:-22,0]\n",
    "        X[300+56:400+56,:256,0] = img[:,22:-22,2]\n",
    "        X[200+56:300+56,:256,1] = img[:,22:-22,1]\n",
    "        X[300+56:400+56,:256,1] = img[:,22:-22,3]\n",
    "        \n",
    "        X[200+56:300+56,256:,0] = img[:,22:-22,0]\n",
    "        X[300+56:400+56,256:,0] = img[:,22:-22,1]\n",
    "        X[200+56:300+56,256:,1] = img[:,22:-22,2]\n",
    "        X[300+56:400+56,256:,1] = img[:,22:-22,3]\n",
    "        \n",
    "        if self.mode!='test':\n",
    "            y[:] = row[TARGETS]\n",
    "        \n",
    "        return X,y\n",
    "    \n",
    "    def generate_raw(self,index):\n",
    "        X = np.zeros((10_000,8),dtype='float32')\n",
    "        y = np.zeros((6,),dtype='float32')\n",
    "        \n",
    "        row = self.data.iloc[index]\n",
    "        eeg = self.raw_eegs[row.eeg_id]\n",
    "            \n",
    "        # FEATURE ENGINEER\n",
    "        X[:,0] = eeg[:,FEAT2IDX['Fp1']] - eeg[:,FEAT2IDX['T3']]\n",
    "        X[:,1] = eeg[:,FEAT2IDX['T3']] - eeg[:,FEAT2IDX['O1']]\n",
    "            \n",
    "        X[:,2] = eeg[:,FEAT2IDX['Fp1']] - eeg[:,FEAT2IDX['C3']]\n",
    "        X[:,3] = eeg[:,FEAT2IDX['C3']] - eeg[:,FEAT2IDX['O1']]\n",
    "            \n",
    "        X[:,4] = eeg[:,FEAT2IDX['Fp2']] - eeg[:,FEAT2IDX['C4']]\n",
    "        X[:,5] = eeg[:,FEAT2IDX['C4']] - eeg[:,FEAT2IDX['O2']]\n",
    "            \n",
    "        X[:,6] = eeg[:,FEAT2IDX['Fp2']] - eeg[:,FEAT2IDX['T4']]\n",
    "        X[:,7] = eeg[:,FEAT2IDX['T4']] - eeg[:,FEAT2IDX['O2']]\n",
    "            \n",
    "        # STANDARDIZE\n",
    "        X = np.clip(X,-1024,1024)\n",
    "        X = np.nan_to_num(X, nan=0) / 32.0\n",
    "            \n",
    "        # BUTTER LOW-PASS FILTER\n",
    "        X = self.butter_lowpass_filter(X)\n",
    "        # Downsample\n",
    "        X = X[::5,:]\n",
    "        \n",
    "        if self.mode!='test':\n",
    "            y[:] = row[TARGETS]\n",
    "                \n",
    "        return X,y\n",
    "    \n",
    "    \n",
    "    def butter_lowpass_filter(self, data, cutoff_freq=20, sampling_rate=200, order=4):\n",
    "        nyquist = 0.5 * sampling_rate\n",
    "        normal_cutoff = cutoff_freq / nyquist\n",
    "        b, a = butter(order, normal_cutoff, btype='low', analog=False)\n",
    "        filtered_data = lfilter(b, a, data, axis=0)\n",
    "        return filtered_data\n",
    "    \n",
    "    def _random_transform(self, img):\n",
    "        composition = albu.Compose([\n",
    "#             albu.Resize(p=1.0, height=CFG.img_size, width=CFG.img_size),\n",
    "            albu.HorizontalFlip(p=0.4),\n",
    "            # albu.CoarseDropout(max_holes=8,max_height=32,max_width=32,fill_value=0,p=0.5),\n",
    "        ])\n",
    "        return composition(image=img)['image']\n",
    "            \n",
    "    def _augment(self, img_batch):\n",
    "        for i in range(img_batch.shape[0]):\n",
    "            img_batch[i,] = self._random_transform(img_batch[i,])\n",
    "        return img_batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "913ab060",
   "metadata": {
    "papermill": {
     "duration": 0.034379,
     "end_time": "2024-03-04T16:41:46.286856",
     "exception": false,
     "start_time": "2024-03-04T16:41:46.252477",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "dataset = EEGDataset(train,augment=False, specs=spectrograms, eeg_specs=all_eegs,data_type='both')\n",
    "dataloader = DataLoader(dataset, batch_size=CFG.batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "118ecb54",
   "metadata": {
    "papermill": {
     "duration": 0.590283,
     "end_time": "2024-03-04T16:41:46.902888",
     "exception": false,
     "start_time": "2024-03-04T16:41:46.312605",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ROWS = 2\n",
    "COLS = 3\n",
    "BATCHES = 2\n",
    "\n",
    "for i, (x,y) in enumerate(dataloader):\n",
    "    break\n",
    "plt.imshow(x[0,:,:,0])\n",
    "# plt.title(f'Target = {y[0].round(1)}',size=12)\n",
    "plt.yticks([])\n",
    "plt.ylabel('Frequencies (Hz)',size=12)\n",
    "plt.xlabel('Time (sec)',size=12)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "402ab6e8",
   "metadata": {
    "papermill": {
     "duration": 0.267367,
     "end_time": "2024-03-04T16:41:47.263718",
     "exception": false,
     "start_time": "2024-03-04T16:41:46.996351",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2719"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del dataset, dataloader\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee8a37cf",
   "metadata": {
    "papermill": {
     "duration": 0.028104,
     "end_time": "2024-03-04T16:41:47.320257",
     "exception": false,
     "start_time": "2024-03-04T16:41:47.292153",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "df4ad0ff",
   "metadata": {
    "papermill": {
     "duration": 0.03961,
     "end_time": "2024-03-04T16:41:47.387878",
     "exception": false,
     "start_time": "2024-03-04T16:41:47.348268",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class GeM(nn.Module):\n",
    "    def __init__(self, p=3, eps=1e-6):\n",
    "        super(GeM, self).__init__()\n",
    "        self.p = nn.Parameter(torch.ones(1)*p)\n",
    "        self.eps = eps\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.gem(x, p=self.p, eps=self.eps)\n",
    "        \n",
    "    def gem(self, x, p=3, eps=1e-6):\n",
    "        return F.avg_pool2d(x.clamp(min=eps).pow(p), (x.size(-2), x.size(-1))).pow(1./p)\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return self.__class__.__name__ + \\\n",
    "                '(' + 'p=' + '{:.4f}'.format(self.p.data.tolist()[0]) + \\\n",
    "                ', ' + 'eps=' + str(self.eps) + ')'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "64cd2f5b",
   "metadata": {
    "papermill": {
     "duration": 0.035891,
     "end_time": "2024-03-04T16:41:47.451800",
     "exception": false,
     "start_time": "2024-03-04T16:41:47.415909",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# class HMSHBACSpecModel(nn.Module):\n",
    "\n",
    "#     def __init__(\n",
    "#             self,\n",
    "#             model_name: str,\n",
    "#             pretrained: bool,\n",
    "#             in_channels: int,\n",
    "#             num_classes: int,\n",
    "#         ):\n",
    "#         super().__init__()\n",
    "# #         self.model = timm.create_model(\n",
    "# #             model_name=model_name, pretrained=pretrained,\n",
    "# #             num_classes=num_classes, in_chans=in_channels)\n",
    "#         self.model = timm.create_model(\n",
    "#             model_name=model_name, pretrained=pretrained, in_chans=in_channels)\n",
    "#         in_features = self.model.classifier.in_features\n",
    "#         self.model.classifier = nn.Identity()\n",
    "#         self.model.global_pool = nn.Identity()\n",
    "#         self.pooling = GeM()\n",
    "#         self.linear = nn.Linear(in_features, num_classes)\n",
    "\n",
    "#     def forward(self, x):   \n",
    "#         x = torch.Tensor(x)\n",
    "#         x = x.permute(0, 3, 1, 2)\n",
    "#         features = self.model(x)\n",
    "#         pooled_features = self.pooling(features).flatten(1)\n",
    "#         out = self.linear(pooled_features)\n",
    "#         return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0c0f08c1",
   "metadata": {
    "papermill": {
     "duration": 0.036469,
     "end_time": "2024-03-04T16:41:47.566859",
     "exception": false,
     "start_time": "2024-03-04T16:41:47.530390",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# class HMSHBACSpecModel(nn.Module):\n",
    "\n",
    "#     def __init__(\n",
    "#             self,\n",
    "#             model_name: str,\n",
    "#             pretrained: bool,\n",
    "#             in_channels: int,\n",
    "#             num_classes: int,\n",
    "#         ):\n",
    "#         super().__init__()\n",
    "#         self.model = timm.create_model(\n",
    "#             model_name=model_name, pretrained=pretrained,\n",
    "#             num_classes=num_classes, in_chans=in_channels)\n",
    "\n",
    "\n",
    "#     def forward(self, x):   \n",
    "#         x = torch.Tensor(x)\n",
    "#         x = x.permute(0, 3, 1, 2)\n",
    "#         out = self.model(x)\n",
    "#         return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e78c463d",
   "metadata": {
    "papermill": {
     "duration": 0.036874,
     "end_time": "2024-03-04T16:41:47.632106",
     "exception": false,
     "start_time": "2024-03-04T16:41:47.595232",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# class HMSHBACSpecModel(nn.Module):\n",
    "\n",
    "#     def __init__(\n",
    "#             self,\n",
    "#             model_name: str,\n",
    "#             pretrained: bool,\n",
    "#             in_channels: int,\n",
    "#             num_classes: int,\n",
    "#         ):\n",
    "#         super().__init__()\n",
    "#         self.model = timm.create_model(\n",
    "#             model_name=model_name, pretrained=pretrained, in_chans=in_channels)\n",
    "#         in_features = self.model.classifier.in_features\n",
    "#         self.model.classifier = nn.Identity()\n",
    "#         self.linear = nn.Linear(in_features, num_classes)\n",
    "\n",
    "#     def forward(self, x):   \n",
    "#         x = torch.Tensor(x)\n",
    "#         x = x.permute(0, 3, 1, 2)\n",
    "#         features = self.model(x)\n",
    "#         out = self.linear(features)\n",
    "#         return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "75b1f135",
   "metadata": {
    "papermill": {
     "duration": 0.045498,
     "end_time": "2024-03-04T16:41:47.705928",
     "exception": false,
     "start_time": "2024-03-04T16:41:47.660430",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# class HMSHBACSpecModel(nn.Module):\n",
    "\n",
    "#     def __init__(\n",
    "#             self,\n",
    "#             model_name: str,\n",
    "#             pretrained: bool,\n",
    "#             in_channels: int,\n",
    "#             num_classes: int,\n",
    "#         ):\n",
    "#         super().__init__()\n",
    "#         self.backbone = timm.create_model(\n",
    "#             model_name=model_name, pretrained=pretrained, in_chans=in_channels)\n",
    "#         feature_info = self.backbone.feature_info\n",
    "#         self.block_out_idx = [1, 2, 4]\n",
    "\n",
    "#         self.aux_block1 = nn.Sequential(\n",
    "#             nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.BatchNorm1d(feature_info[1][\"num_chs\"])\n",
    "#         )\n",
    "#         self.aux_block2 = nn.Sequential(\n",
    "#             nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.BatchNorm1d(feature_info[2][\"num_chs\"])\n",
    "#         )\n",
    "#         self.aux_block4 = nn.Sequential(\n",
    "#             nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.BatchNorm1d(feature_info[3][\"num_chs\"])\n",
    "#         )\n",
    "\n",
    "#         self.aux_linear1 = nn.Linear(feature_info[1][\"num_chs\"], num_classes)\n",
    "#         self.aux_linear2 = nn.Linear(feature_info[2][\"num_chs\"], num_classes)\n",
    "#         self.aux_linear4 = nn.Linear(feature_info[3][\"num_chs\"], num_classes)\n",
    "#         self.num_features = (\n",
    "#             self.backbone.num_features\n",
    "#             + feature_info[1][\"num_chs\"]\n",
    "#             + feature_info[2][\"num_chs\"]\n",
    "#             + feature_info[3][\"num_chs\"]\n",
    "#         )\n",
    "#         self.linear = nn.Linear(self.num_features, num_classes)\n",
    "\n",
    "#     def forward_features(self, x):\n",
    "#         x = self.backbone.conv_stem(x)\n",
    "#         x = self.backbone.bn1(x)\n",
    "#         features = []\n",
    "#         for i, b in enumerate(self.backbone.blocks):\n",
    "#             x = b(x)\n",
    "#             if i in self.block_out_idx:\n",
    "#                 features.append(x)\n",
    "\n",
    "#         features[0] = self.aux_block1(features[0])\n",
    "#         features[1] = self.aux_block2(features[1])\n",
    "#         features[2] = self.aux_block4(features[2])\n",
    "#         features.append(self.backbone.global_pool(self.backbone.bn2(self.backbone.conv_head(x))))\n",
    "#         return features\n",
    "\n",
    "\n",
    "#     def forward(self, x):   \n",
    "#         x = torch.Tensor(x)\n",
    "#         x = x.permute(0, 3, 1, 2)\n",
    "#         features = self.forward_features(x)\n",
    "#         features = torch.cat(features, dim=1)\n",
    "        \n",
    "#         out = self.linear(features)\n",
    "#         return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a4ee5aad",
   "metadata": {
    "papermill": {
     "duration": 0.028242,
     "end_time": "2024-03-04T16:41:47.762521",
     "exception": false,
     "start_time": "2024-03-04T16:41:47.734279",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class HMSHBACSpecModel(nn.Module):\n",
    "\n",
    "    def __init__(\n",
    "            self,\n",
    "            model_name: str,\n",
    "            pretrained: bool,\n",
    "            in_channels: int,\n",
    "            num_classes: int,\n",
    "        ):\n",
    "        super().__init__()\n",
    "        self.model = timm.create_model(\n",
    "            model_name=model_name, pretrained=pretrained, in_chans=in_channels)\n",
    "        print(self.model)\n",
    "        in_features = self.model.classifier.in_features\n",
    "        self.model.classifier = nn.Identity()\n",
    "        self.mlp = nn.Sequential(\n",
    "            nn.Linear(in_features, 1024),\n",
    "            nn.GELU(),\n",
    "            nn.Dropout(0.2),\n",
    "            nn.Linear(1024, 128),\n",
    "            nn.GELU(),\n",
    "            nn.Dropout(0.2),\n",
    "            nn.Linear(128, num_classes),\n",
    "\n",
    "        )\n",
    "        self.linear = nn.Linear(in_features, num_classes)\n",
    "\n",
    "    def forward(self, x):   \n",
    "        x = torch.Tensor(x)\n",
    "        x = x.permute(0, 3, 1, 2)\n",
    "        features = self.model(x)\n",
    "        out = self.mlp(features)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95c924f9-5f34-42ea-9db0-61f8a39add28",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "23abb8dd",
   "metadata": {
    "papermill": {
     "duration": 0.041353,
     "end_time": "2024-03-04T16:41:47.831948",
     "exception": false,
     "start_time": "2024-03-04T16:41:47.790595",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class KLDivLossWithLogits(nn.KLDivLoss):\n",
    "\n",
    "    def __init__(self):\n",
    "        super().__init__(reduction=\"batchmean\")\n",
    "\n",
    "    def forward(self, y, t):\n",
    "        y = nn.functional.log_softmax(y,  dim=1)\n",
    "        loss = super().forward(y, t)\n",
    "\n",
    "        return loss\n",
    "    \n",
    "class KLDivLossWithLogitsForVal(nn.KLDivLoss):\n",
    "    \n",
    "    def __init__(self):\n",
    "        \"\"\"\"\"\"\n",
    "        super().__init__(reduction=\"batchmean\")\n",
    "        self.log_prob_list  = []\n",
    "        self.label_list = []\n",
    "\n",
    "    def forward(self, y, t):\n",
    "        y = nn.functional.log_softmax(y, dim=1)\n",
    "        self.log_prob_list.append(y.cpu().numpy())\n",
    "        self.label_list.append(t.cpu().numpy())\n",
    "        \n",
    "    def compute(self):\n",
    "        log_prob = np.concatenate(self.log_prob_list, axis=0)\n",
    "        label = np.concatenate(self.label_list, axis=0)\n",
    "        final_metric = super().forward(\n",
    "            torch.from_numpy(log_prob),\n",
    "            torch.from_numpy(label)\n",
    "        ).item()\n",
    "        self.log_prob_list = []\n",
    "        self.label_list = []\n",
    "        \n",
    "        return final_metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "27f1c5b9",
   "metadata": {
    "papermill": {
     "duration": 0.039796,
     "end_time": "2024-03-04T16:41:47.900496",
     "exception": false,
     "start_time": "2024-03-04T16:41:47.860700",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def set_random_seed(seed: int = 42):\n",
    "    \"\"\"Set seeds\"\"\"\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    os.environ[\"PYTHONHASHSEED\"] = str(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed)  # type: ignore\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    torch.backends.cudnn.deterministic = True  # type: ignore\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "def to_device(\n",
    "    tensors: tp.Union[tp.Tuple[torch.Tensor], tp.Dict[str, torch.Tensor]],\n",
    "    device: torch.device, *args, **kwargs\n",
    "):\n",
    "    if isinstance(tensors, tuple):\n",
    "        return (t.to(device, *args, **kwargs) for t in tensors)\n",
    "    elif isinstance(tensors, dict):\n",
    "        return {\n",
    "            k: t.to(device, *args, **kwargs) for k, t in tensors.items()}\n",
    "    else:\n",
    "        return tensors.to(device, *args, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "13b4d2bf",
   "metadata": {
    "papermill": {
     "duration": 0.052958,
     "end_time": "2024-03-04T16:41:47.981971",
     "exception": false,
     "start_time": "2024-03-04T16:41:47.929013",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def train_one_fold(CFG, fold,train_index, valid_index, output_path,stage='first'):\n",
    "    \"\"\"Main\"\"\"\n",
    "    set_random_seed(CFG.seed)\n",
    "    device = torch.device(CFG.device)\n",
    "    model = HMSHBACSpecModel(\n",
    "        model_name=CFG.model_name, pretrained=True, num_classes=6, in_channels=3)\n",
    "    model.to(device)\n",
    "    \n",
    "    train_data, valid_data = train.iloc[train_index], train.iloc[valid_index]\n",
    "    train_ds = EEGDataset(data=train_data, augment=False, mode='train', specs=spectrograms, eeg_specs=all_eegs, raw_eegs=all_raw_eegs, data_type=CFG.data_type)\n",
    "    train_loader = DataLoader(train_ds, shuffle=True, batch_size=CFG.batch_size, num_workers=10)\n",
    "    valid_ds = EEGDataset(valid_data, mode='valid', specs=spectrograms, eeg_specs=all_eegs, raw_eegs=all_raw_eegs, data_type=CFG.data_type)\n",
    "    val_loader = DataLoader(valid_ds, shuffle=False, batch_size=CFG.batch_size*2, num_workers=10)\n",
    "    \n",
    "    if stage !='first':\n",
    "        train_data= train_data[train_data['kl']<5.5]\n",
    "        train_ds = EEGDataset(data=train_data, augment=False, mode='train', specs=spectrograms, eeg_specs=all_eegs, raw_eegs=all_raw_eegs, data_type=CFG.data_type)\n",
    "        train_loader = DataLoader(train_ds, shuffle=True, batch_size=CFG.batch_size, num_workers=10)\n",
    "        model_path = './'+ f\"best_model_fold{fold}.pth\"\n",
    "        model.load_state_dict(torch.load(model_path, map_location=device))\n",
    "        print('init success')\n",
    "    print(f'### Train size: {len(train_index)}, Valid size: {len(valid_index)}')\n",
    "    print('#'*25)\n",
    "    \n",
    "\n",
    "    \n",
    "    optimizer = optim.AdamW(params=model.parameters(), lr=CFG.lr, weight_decay=CFG.weight_decay)\n",
    "    scheduler = lr_scheduler.OneCycleLR(\n",
    "        optimizer=optimizer, epochs=CFG.max_epoch,\n",
    "        pct_start=0.0, steps_per_epoch=len(train_loader),\n",
    "        max_lr=CFG.lr, div_factor=25, final_div_factor=4.0e-01\n",
    "    )\n",
    "    \n",
    "    loss_func = KLDivLossWithLogits()\n",
    "    loss_func.to(device)\n",
    "    loss_func_val = KLDivLossWithLogitsForVal()\n",
    "    \n",
    "    use_amp = CFG.enable_amp\n",
    "    scaler = amp.GradScaler(enabled=use_amp)\n",
    "    \n",
    "    best_val_loss = 1.0e+09\n",
    "    best_epoch = 0\n",
    "    train_loss = 0\n",
    "    for epoch in range(1, CFG.max_epoch + 1):\n",
    "        epoch_start = time()\n",
    "        model.train()\n",
    "        for batch in train_loader:\n",
    "#             batch = to_device(batch, device)\n",
    "            x, t = batch\n",
    "            x = x.to(device)\n",
    "            t = t.to(device)\n",
    "            optimizer.zero_grad()\n",
    "            with amp.autocast(use_amp):\n",
    "                y = model(x)\n",
    "                loss = loss_func(y, t)\n",
    "            scaler.scale(loss).backward()\n",
    "            scaler.step(optimizer)\n",
    "            scaler.update()\n",
    "            scheduler.step()\n",
    "            train_loss += loss.item()\n",
    "        train_loss /= len(train_loader)\n",
    "            \n",
    "        model.eval()\n",
    "        for batch in val_loader:\n",
    "#             batch = to_device(batch, device)\n",
    "            x, t = batch\n",
    "            x = x.to(device)\n",
    "            t = t.to(device)\n",
    "            with torch.no_grad(), amp.autocast(use_amp):\n",
    "                y = model(x)\n",
    "            y = y.detach().cpu().to(torch.float32)\n",
    "            loss_func_val(y, t)\n",
    "        val_loss = loss_func_val.compute() \n",
    "        if val_loss < best_val_loss:\n",
    "            best_epoch = epoch\n",
    "            best_val_loss = val_loss\n",
    "            # print(\"save model\")\n",
    "            torch.save(model.state_dict(), str(output_path / f'snapshot_epoch_{epoch}.pth'))\n",
    "        \n",
    "        elapsed_time = time() - epoch_start\n",
    "        print(\n",
    "            f\"[epoch {epoch}] train loss: {train_loss: .6f}, val loss: {val_loss: .6f}, elapsed_time: {elapsed_time: .3f}\")\n",
    "        \n",
    "        if epoch - best_epoch > CFG.es_patience:\n",
    "            print(\"Early Stopping!\")\n",
    "            break\n",
    "            \n",
    "        train_loss = 0\n",
    "            \n",
    "    return fold, best_epoch, best_val_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "102daeb5",
   "metadata": {
    "papermill": {
     "duration": 1761.049877,
     "end_time": "2024-03-04T17:11:09.061715",
     "exception": false,
     "start_time": "2024-03-04T16:41:48.011838",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#########################\n",
      "###  Fold 0\n",
      "[fold0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/root/miniconda3/lib/python3.8/site-packages/timm/models/_factory.py:117: UserWarning: Mapping deprecated model name tf_efficientnet_b0_ns to current tf_efficientnet_b0.ns_jft_in1k.\n",
      "  model = create_fn(\n"
     ]
    },
    {
     "ename": "ProxyError",
     "evalue": "(MaxRetryError(\"HTTPSConnectionPool(host='huggingface.co', port=443): Max retries exceeded with url: /timm/tf_efficientnet_b0.ns_jft_in1k/resolve/main/model.safetensors (Caused by ProxyError('Cannot connect to proxy.', timeout('_ssl.c:1114: The handshake operation timed out')))\"), '(Request ID: 3ea57093-3865-467e-b330-6ccf8397bb65)')",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mtimeout\u001b[0m                                   Traceback (most recent call last)",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/urllib3/connectionpool.py:696\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m    695\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_new_proxy_conn \u001b[38;5;129;01mand\u001b[39;00m http_tunnel_required:\n\u001b[0;32m--> 696\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_prepare_proxy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconn\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    698\u001b[0m \u001b[38;5;66;03m# Make the request on the httplib connection object.\u001b[39;00m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/urllib3/connectionpool.py:964\u001b[0m, in \u001b[0;36mHTTPSConnectionPool._prepare_proxy\u001b[0;34m(self, conn)\u001b[0m\n\u001b[1;32m    962\u001b[0m     conn\u001b[38;5;241m.\u001b[39mtls_in_tls_required \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[0;32m--> 964\u001b[0m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconnect\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/urllib3/connection.py:411\u001b[0m, in \u001b[0;36mHTTPSConnection.connect\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    409\u001b[0m     context\u001b[38;5;241m.\u001b[39mload_default_certs()\n\u001b[0;32m--> 411\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msock \u001b[38;5;241m=\u001b[39m \u001b[43mssl_wrap_socket\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    412\u001b[0m \u001b[43m    \u001b[49m\u001b[43msock\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    413\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkeyfile\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkey_file\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    414\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcertfile\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcert_file\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    415\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkey_password\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkey_password\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    416\u001b[0m \u001b[43m    \u001b[49m\u001b[43mca_certs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mca_certs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    417\u001b[0m \u001b[43m    \u001b[49m\u001b[43mca_cert_dir\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mca_cert_dir\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    418\u001b[0m \u001b[43m    \u001b[49m\u001b[43mca_cert_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mca_cert_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    419\u001b[0m \u001b[43m    \u001b[49m\u001b[43mserver_hostname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mserver_hostname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    420\u001b[0m \u001b[43m    \u001b[49m\u001b[43mssl_context\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcontext\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    421\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtls_in_tls\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtls_in_tls\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    422\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    424\u001b[0m \u001b[38;5;66;03m# If we're using all defaults and the connection\u001b[39;00m\n\u001b[1;32m    425\u001b[0m \u001b[38;5;66;03m# is TLSv1 or TLSv1.1 we throw a DeprecationWarning\u001b[39;00m\n\u001b[1;32m    426\u001b[0m \u001b[38;5;66;03m# for the host.\u001b[39;00m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/urllib3/util/ssl_.py:449\u001b[0m, in \u001b[0;36mssl_wrap_socket\u001b[0;34m(sock, keyfile, certfile, cert_reqs, ca_certs, server_hostname, ssl_version, ciphers, ssl_context, ca_cert_dir, key_password, ca_cert_data, tls_in_tls)\u001b[0m\n\u001b[1;32m    448\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m send_sni:\n\u001b[0;32m--> 449\u001b[0m     ssl_sock \u001b[38;5;241m=\u001b[39m \u001b[43m_ssl_wrap_socket_impl\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    450\u001b[0m \u001b[43m        \u001b[49m\u001b[43msock\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtls_in_tls\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mserver_hostname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mserver_hostname\u001b[49m\n\u001b[1;32m    451\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    452\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/urllib3/util/ssl_.py:493\u001b[0m, in \u001b[0;36m_ssl_wrap_socket_impl\u001b[0;34m(sock, ssl_context, tls_in_tls, server_hostname)\u001b[0m\n\u001b[1;32m    492\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m server_hostname:\n\u001b[0;32m--> 493\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mssl_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwrap_socket\u001b[49m\u001b[43m(\u001b[49m\u001b[43msock\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mserver_hostname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mserver_hostname\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    494\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/ssl.py:500\u001b[0m, in \u001b[0;36mSSLContext.wrap_socket\u001b[0;34m(self, sock, server_side, do_handshake_on_connect, suppress_ragged_eofs, server_hostname, session)\u001b[0m\n\u001b[1;32m    494\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrap_socket\u001b[39m(\u001b[38;5;28mself\u001b[39m, sock, server_side\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    495\u001b[0m                 do_handshake_on_connect\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    496\u001b[0m                 suppress_ragged_eofs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    497\u001b[0m                 server_hostname\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, session\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m    498\u001b[0m     \u001b[38;5;66;03m# SSLSocket class handles server_hostname encoding before it calls\u001b[39;00m\n\u001b[1;32m    499\u001b[0m     \u001b[38;5;66;03m# ctx._wrap_socket()\u001b[39;00m\n\u001b[0;32m--> 500\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msslsocket_class\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_create\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    501\u001b[0m \u001b[43m        \u001b[49m\u001b[43msock\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msock\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    502\u001b[0m \u001b[43m        \u001b[49m\u001b[43mserver_side\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mserver_side\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    503\u001b[0m \u001b[43m        \u001b[49m\u001b[43mdo_handshake_on_connect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdo_handshake_on_connect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    504\u001b[0m \u001b[43m        \u001b[49m\u001b[43msuppress_ragged_eofs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msuppress_ragged_eofs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    505\u001b[0m \u001b[43m        \u001b[49m\u001b[43mserver_hostname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mserver_hostname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    506\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcontext\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    507\u001b[0m \u001b[43m        \u001b[49m\u001b[43msession\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msession\u001b[49m\n\u001b[1;32m    508\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/ssl.py:1040\u001b[0m, in \u001b[0;36mSSLSocket._create\u001b[0;34m(cls, sock, server_side, do_handshake_on_connect, suppress_ragged_eofs, server_hostname, context, session)\u001b[0m\n\u001b[1;32m   1039\u001b[0m             \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdo_handshake_on_connect should not be specified for non-blocking sockets\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 1040\u001b[0m         \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdo_handshake\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1041\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mOSError\u001b[39;00m, \u001b[38;5;167;01mValueError\u001b[39;00m):\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/ssl.py:1309\u001b[0m, in \u001b[0;36mSSLSocket.do_handshake\u001b[0;34m(self, block)\u001b[0m\n\u001b[1;32m   1308\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msettimeout(\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m-> 1309\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sslobj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdo_handshake\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1310\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n",
      "\u001b[0;31mtimeout\u001b[0m: _ssl.c:1114: The handshake operation timed out",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mMaxRetryError\u001b[0m                             Traceback (most recent call last)",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/requests/adapters.py:489\u001b[0m, in \u001b[0;36mHTTPAdapter.send\u001b[0;34m(self, request, stream, timeout, verify, cert, proxies)\u001b[0m\n\u001b[1;32m    488\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m chunked:\n\u001b[0;32m--> 489\u001b[0m     resp \u001b[38;5;241m=\u001b[39m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    490\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    491\u001b[0m \u001b[43m        \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    492\u001b[0m \u001b[43m        \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    493\u001b[0m \u001b[43m        \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    494\u001b[0m \u001b[43m        \u001b[49m\u001b[43mredirect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    495\u001b[0m \u001b[43m        \u001b[49m\u001b[43massert_same_host\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    496\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpreload_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    497\u001b[0m \u001b[43m        \u001b[49m\u001b[43mdecode_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    498\u001b[0m \u001b[43m        \u001b[49m\u001b[43mretries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax_retries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    499\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    500\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    502\u001b[0m \u001b[38;5;66;03m# Send the request.\u001b[39;00m\n\u001b[1;32m    503\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/urllib3/connectionpool.py:755\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m    753\u001b[0m     e \u001b[38;5;241m=\u001b[39m ProtocolError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mConnection aborted.\u001b[39m\u001b[38;5;124m\"\u001b[39m, e)\n\u001b[0;32m--> 755\u001b[0m retries \u001b[38;5;241m=\u001b[39m \u001b[43mretries\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mincrement\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    756\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43merror\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43me\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_pool\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_stacktrace\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msys\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexc_info\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[1;32m    757\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    758\u001b[0m retries\u001b[38;5;241m.\u001b[39msleep()\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/urllib3/util/retry.py:574\u001b[0m, in \u001b[0;36mRetry.increment\u001b[0;34m(self, method, url, response, error, _pool, _stacktrace)\u001b[0m\n\u001b[1;32m    573\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m new_retry\u001b[38;5;241m.\u001b[39mis_exhausted():\n\u001b[0;32m--> 574\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m MaxRetryError(_pool, url, error \u001b[38;5;129;01mor\u001b[39;00m ResponseError(cause))\n\u001b[1;32m    576\u001b[0m log\u001b[38;5;241m.\u001b[39mdebug(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIncremented Retry for (url=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m): \u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, url, new_retry)\n",
      "\u001b[0;31mMaxRetryError\u001b[0m: HTTPSConnectionPool(host='huggingface.co', port=443): Max retries exceeded with url: /timm/tf_efficientnet_b0.ns_jft_in1k/resolve/main/model.safetensors (Caused by ProxyError('Cannot connect to proxy.', timeout('_ssl.c:1114: The handshake operation timed out')))",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mProxyError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[24], line 11\u001b[0m\n\u001b[1;32m      9\u001b[0m output_path\u001b[38;5;241m.\u001b[39mmkdir(exist_ok\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m     10\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m[fold\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m\"\u001b[39m)     \n\u001b[0;32m---> 11\u001b[0m score_list\u001b[38;5;241m.\u001b[39mappend(\u001b[43mtrain_one_fold\u001b[49m\u001b[43m(\u001b[49m\u001b[43mCFG\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43mtrain_index\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalid_index\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutput_path\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m     12\u001b[0m \u001b[38;5;66;03m# score_list.append(train_one_fold(CFG, i,train_index, valid_index, output_path, stage='sec'))\u001b[39;00m\n",
      "Cell \u001b[0;32mIn[20], line 5\u001b[0m, in \u001b[0;36mtrain_one_fold\u001b[0;34m(CFG, fold, train_index, valid_index, output_path, stage)\u001b[0m\n\u001b[1;32m      3\u001b[0m set_random_seed(CFG\u001b[38;5;241m.\u001b[39mseed)\n\u001b[1;32m      4\u001b[0m device \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mdevice(CFG\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[0;32m----> 5\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43mHMSHBACSpecModel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m      6\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmodel_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mCFG\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpretrained\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_classes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m6\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43min_channels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m      7\u001b[0m model\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[1;32m      9\u001b[0m train_data, valid_data \u001b[38;5;241m=\u001b[39m train\u001b[38;5;241m.\u001b[39miloc[train_index], train\u001b[38;5;241m.\u001b[39miloc[valid_index]\n",
      "Cell \u001b[0;32mIn[17], line 11\u001b[0m, in \u001b[0;36mHMSHBACSpecModel.__init__\u001b[0;34m(self, model_name, pretrained, in_channels, num_classes)\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\n\u001b[1;32m      4\u001b[0m         \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m      5\u001b[0m         model_name: \u001b[38;5;28mstr\u001b[39m,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m      8\u001b[0m         num_classes: \u001b[38;5;28mint\u001b[39m,\n\u001b[1;32m      9\u001b[0m     ):\n\u001b[1;32m     10\u001b[0m     \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m()\n\u001b[0;32m---> 11\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel \u001b[38;5;241m=\u001b[39m \u001b[43mtimm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     12\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmodel_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpretrained\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpretrained\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43min_chans\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43min_channels\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     13\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel)\n\u001b[1;32m     14\u001b[0m     in_features \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel\u001b[38;5;241m.\u001b[39mclassifier\u001b[38;5;241m.\u001b[39min_features\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/timm/models/_factory.py:117\u001b[0m, in \u001b[0;36mcreate_model\u001b[0;34m(model_name, pretrained, pretrained_cfg, pretrained_cfg_overlay, checkpoint_path, scriptable, exportable, no_jit, **kwargs)\u001b[0m\n\u001b[1;32m    115\u001b[0m create_fn \u001b[38;5;241m=\u001b[39m model_entrypoint(model_name)\n\u001b[1;32m    116\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m set_layer_config(scriptable\u001b[38;5;241m=\u001b[39mscriptable, exportable\u001b[38;5;241m=\u001b[39mexportable, no_jit\u001b[38;5;241m=\u001b[39mno_jit):\n\u001b[0;32m--> 117\u001b[0m     model \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_fn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    118\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpretrained\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpretrained\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    119\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpretrained_cfg\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpretrained_cfg\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    120\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpretrained_cfg_overlay\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpretrained_cfg_overlay\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    121\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    122\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    124\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m checkpoint_path:\n\u001b[1;32m    125\u001b[0m     load_checkpoint(model, checkpoint_path)\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/timm/models/_registry.py:145\u001b[0m, in \u001b[0;36m_deprecated_model_shim.<locals>._fn\u001b[0;34m(pretrained, **kwargs)\u001b[0m\n\u001b[1;32m    143\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mMapping deprecated model name \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdeprecated_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m to current \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcurrent_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m'\u001b[39m, stacklevel\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m    144\u001b[0m pretrained_cfg \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mpretrained_cfg\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m--> 145\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcurrent_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpretrained\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpretrained\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpretrained_cfg\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpretrained_cfg\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mcurrent_tag\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/timm/models/efficientnet.py:1905\u001b[0m, in \u001b[0;36mtf_efficientnet_b0\u001b[0;34m(pretrained, **kwargs)\u001b[0m\n\u001b[1;32m   1903\u001b[0m kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbn_eps\u001b[39m\u001b[38;5;124m'\u001b[39m, BN_EPS_TF_DEFAULT)\n\u001b[1;32m   1904\u001b[0m kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mpad_type\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124msame\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m-> 1905\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43m_gen_efficientnet\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   1906\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtf_efficientnet_b0\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchannel_multiplier\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdepth_multiplier\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpretrained\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpretrained\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1907\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m model\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/timm/models/efficientnet.py:537\u001b[0m, in \u001b[0;36m_gen_efficientnet\u001b[0;34m(variant, channel_multiplier, depth_multiplier, channel_divisor, group_size, pretrained, **kwargs)\u001b[0m\n\u001b[1;32m    527\u001b[0m round_chs_fn \u001b[38;5;241m=\u001b[39m partial(round_channels, multiplier\u001b[38;5;241m=\u001b[39mchannel_multiplier, divisor\u001b[38;5;241m=\u001b[39mchannel_divisor)\n\u001b[1;32m    528\u001b[0m model_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mdict\u001b[39m(\n\u001b[1;32m    529\u001b[0m     block_args\u001b[38;5;241m=\u001b[39mdecode_arch_def(arch_def, depth_multiplier, group_size\u001b[38;5;241m=\u001b[39mgroup_size),\n\u001b[1;32m    530\u001b[0m     num_features\u001b[38;5;241m=\u001b[39mround_chs_fn(\u001b[38;5;241m1280\u001b[39m),\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    535\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m    536\u001b[0m )\n\u001b[0;32m--> 537\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43m_create_effnet\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvariant\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpretrained\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    538\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m model\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/timm/models/efficientnet.py:282\u001b[0m, in \u001b[0;36m_create_effnet\u001b[0;34m(variant, pretrained, **kwargs)\u001b[0m\n\u001b[1;32m    279\u001b[0m         model_cls \u001b[38;5;241m=\u001b[39m EfficientNetFeatures\n\u001b[1;32m    280\u001b[0m         features_mode \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcls\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m--> 282\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43mbuild_model_with_cfg\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    283\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmodel_cls\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    284\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvariant\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    285\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpretrained\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    286\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfeatures_only\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfeatures_mode\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mcfg\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    287\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpretrained_strict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfeatures_mode\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m!=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mcls\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    288\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkwargs_filter\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkwargs_filter\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    289\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    290\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    291\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m features_mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcls\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m    292\u001b[0m     model\u001b[38;5;241m.\u001b[39mpretrained_cfg \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mdefault_cfg \u001b[38;5;241m=\u001b[39m pretrained_cfg_for_features(model\u001b[38;5;241m.\u001b[39mpretrained_cfg)\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/timm/models/_builder.py:410\u001b[0m, in \u001b[0;36mbuild_model_with_cfg\u001b[0;34m(model_cls, variant, pretrained, pretrained_cfg, pretrained_cfg_overlay, model_cfg, feature_cfg, pretrained_strict, pretrained_filter_fn, kwargs_filter, **kwargs)\u001b[0m\n\u001b[1;32m    408\u001b[0m num_classes_pretrained \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m features \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(model, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnum_classes\u001b[39m\u001b[38;5;124m'\u001b[39m, kwargs\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnum_classes\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;241m1000\u001b[39m))\n\u001b[1;32m    409\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pretrained:\n\u001b[0;32m--> 410\u001b[0m     \u001b[43mload_pretrained\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    411\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    412\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpretrained_cfg\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpretrained_cfg\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    413\u001b[0m \u001b[43m        \u001b[49m\u001b[43mnum_classes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_classes_pretrained\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    414\u001b[0m \u001b[43m        \u001b[49m\u001b[43min_chans\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43min_chans\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    415\u001b[0m \u001b[43m        \u001b[49m\u001b[43mfilter_fn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpretrained_filter_fn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    416\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstrict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpretrained_strict\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    417\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    419\u001b[0m \u001b[38;5;66;03m# Wrap the model in a feature extraction module if enabled\u001b[39;00m\n\u001b[1;32m    420\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m features:\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/timm/models/_builder.py:190\u001b[0m, in \u001b[0;36mload_pretrained\u001b[0;34m(model, pretrained_cfg, num_classes, in_chans, filter_fn, strict)\u001b[0m\n\u001b[1;32m    188\u001b[0m         state_dict \u001b[38;5;241m=\u001b[39m load_state_dict_from_hf(\u001b[38;5;241m*\u001b[39mpretrained_loc)\n\u001b[1;32m    189\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 190\u001b[0m         state_dict \u001b[38;5;241m=\u001b[39m \u001b[43mload_state_dict_from_hf\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpretrained_loc\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    191\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    192\u001b[0m     model_name \u001b[38;5;241m=\u001b[39m pretrained_cfg\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124marchitecture\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mthis model\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/timm/models/_hub.py:179\u001b[0m, in \u001b[0;36mload_state_dict_from_hf\u001b[0;34m(model_id, filename)\u001b[0m\n\u001b[1;32m    177\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m safe_filename \u001b[38;5;129;01min\u001b[39;00m _get_safe_alternatives(filename):\n\u001b[1;32m    178\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 179\u001b[0m         cached_safe_file \u001b[38;5;241m=\u001b[39m \u001b[43mhf_hub_download\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrepo_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhf_model_id\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msafe_filename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrevision\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhf_revision\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    180\u001b[0m         _logger\u001b[38;5;241m.\u001b[39minfo(\n\u001b[1;32m    181\u001b[0m             \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m[\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel_id\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m] Safe alternative available for \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfilename\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    182\u001b[0m             \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m(as \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00msafe_filename\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m). Loading weights using safetensors.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    183\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m safetensors\u001b[38;5;241m.\u001b[39mtorch\u001b[38;5;241m.\u001b[39mload_file(cached_safe_file, device\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcpu\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/huggingface_hub/utils/_validators.py:118\u001b[0m, in \u001b[0;36mvalidate_hf_hub_args.<locals>._inner_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    115\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m check_use_auth_token:\n\u001b[1;32m    116\u001b[0m     kwargs \u001b[38;5;241m=\u001b[39m smoothly_deprecate_use_auth_token(fn_name\u001b[38;5;241m=\u001b[39mfn\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m, has_token\u001b[38;5;241m=\u001b[39mhas_token, kwargs\u001b[38;5;241m=\u001b[39mkwargs)\n\u001b[0;32m--> 118\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/huggingface_hub/file_download.py:1261\u001b[0m, in \u001b[0;36mhf_hub_download\u001b[0;34m(repo_id, filename, subfolder, repo_type, revision, library_name, library_version, cache_dir, local_dir, local_dir_use_symlinks, user_agent, force_download, force_filename, proxies, etag_timeout, resume_download, token, local_files_only, legacy_cache_layout, endpoint)\u001b[0m\n\u001b[1;32m   1259\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1260\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1261\u001b[0m         metadata \u001b[38;5;241m=\u001b[39m \u001b[43mget_hf_file_metadata\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   1262\u001b[0m \u001b[43m            \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1263\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtoken\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtoken\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1264\u001b[0m \u001b[43m            \u001b[49m\u001b[43mproxies\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mproxies\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1265\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43metag_timeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1266\u001b[0m \u001b[43m            \u001b[49m\u001b[43mlibrary_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlibrary_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1267\u001b[0m \u001b[43m            \u001b[49m\u001b[43mlibrary_version\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlibrary_version\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1268\u001b[0m \u001b[43m            \u001b[49m\u001b[43muser_agent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muser_agent\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1269\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1270\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m EntryNotFoundError \u001b[38;5;28;01mas\u001b[39;00m http_error:\n\u001b[1;32m   1271\u001b[0m         \u001b[38;5;66;03m# Cache the non-existence of the file and raise\u001b[39;00m\n\u001b[1;32m   1272\u001b[0m         commit_hash \u001b[38;5;241m=\u001b[39m http_error\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mheaders\u001b[38;5;241m.\u001b[39mget(HUGGINGFACE_HEADER_X_REPO_COMMIT)\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/huggingface_hub/utils/_validators.py:118\u001b[0m, in \u001b[0;36mvalidate_hf_hub_args.<locals>._inner_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    115\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m check_use_auth_token:\n\u001b[1;32m    116\u001b[0m     kwargs \u001b[38;5;241m=\u001b[39m smoothly_deprecate_use_auth_token(fn_name\u001b[38;5;241m=\u001b[39mfn\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m, has_token\u001b[38;5;241m=\u001b[39mhas_token, kwargs\u001b[38;5;241m=\u001b[39mkwargs)\n\u001b[0;32m--> 118\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/huggingface_hub/file_download.py:1667\u001b[0m, in \u001b[0;36mget_hf_file_metadata\u001b[0;34m(url, token, proxies, timeout, library_name, library_version, user_agent)\u001b[0m\n\u001b[1;32m   1664\u001b[0m headers[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAccept-Encoding\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124midentity\u001b[39m\u001b[38;5;124m\"\u001b[39m  \u001b[38;5;66;03m# prevent any compression => we want to know the real size of the file\u001b[39;00m\n\u001b[1;32m   1666\u001b[0m \u001b[38;5;66;03m# Retrieve metadata\u001b[39;00m\n\u001b[0;32m-> 1667\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43m_request_wrapper\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   1668\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mHEAD\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1669\u001b[0m \u001b[43m    \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1670\u001b[0m \u001b[43m    \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1671\u001b[0m \u001b[43m    \u001b[49m\u001b[43mallow_redirects\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m   1672\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfollow_relative_redirects\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m   1673\u001b[0m \u001b[43m    \u001b[49m\u001b[43mproxies\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mproxies\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1674\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1675\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1676\u001b[0m hf_raise_for_status(r)\n\u001b[1;32m   1678\u001b[0m \u001b[38;5;66;03m# Return\u001b[39;00m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/huggingface_hub/file_download.py:385\u001b[0m, in \u001b[0;36m_request_wrapper\u001b[0;34m(method, url, follow_relative_redirects, **params)\u001b[0m\n\u001b[1;32m    383\u001b[0m \u001b[38;5;66;03m# Recursively follow relative redirects\u001b[39;00m\n\u001b[1;32m    384\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m follow_relative_redirects:\n\u001b[0;32m--> 385\u001b[0m     response \u001b[38;5;241m=\u001b[39m \u001b[43m_request_wrapper\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    386\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    387\u001b[0m \u001b[43m        \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    388\u001b[0m \u001b[43m        \u001b[49m\u001b[43mfollow_relative_redirects\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    389\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    390\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    392\u001b[0m     \u001b[38;5;66;03m# If redirection, we redirect only relative paths.\u001b[39;00m\n\u001b[1;32m    393\u001b[0m     \u001b[38;5;66;03m# This is useful in case of a renamed repository.\u001b[39;00m\n\u001b[1;32m    394\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;241m300\u001b[39m \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m response\u001b[38;5;241m.\u001b[39mstatus_code \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m399\u001b[39m:\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/huggingface_hub/file_download.py:408\u001b[0m, in \u001b[0;36m_request_wrapper\u001b[0;34m(method, url, follow_relative_redirects, **params)\u001b[0m\n\u001b[1;32m    405\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m response\n\u001b[1;32m    407\u001b[0m \u001b[38;5;66;03m# Perform request and return if status_code is not in the retry list.\u001b[39;00m\n\u001b[0;32m--> 408\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mget_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    409\u001b[0m hf_raise_for_status(response)\n\u001b[1;32m    410\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m response\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/requests/sessions.py:587\u001b[0m, in \u001b[0;36mSession.request\u001b[0;34m(self, method, url, params, data, headers, cookies, files, auth, timeout, allow_redirects, proxies, hooks, stream, verify, cert, json)\u001b[0m\n\u001b[1;32m    582\u001b[0m send_kwargs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m    583\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtimeout\u001b[39m\u001b[38;5;124m\"\u001b[39m: timeout,\n\u001b[1;32m    584\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mallow_redirects\u001b[39m\u001b[38;5;124m\"\u001b[39m: allow_redirects,\n\u001b[1;32m    585\u001b[0m }\n\u001b[1;32m    586\u001b[0m send_kwargs\u001b[38;5;241m.\u001b[39mupdate(settings)\n\u001b[0;32m--> 587\u001b[0m resp \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprep\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msend_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    589\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m resp\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/requests/sessions.py:701\u001b[0m, in \u001b[0;36mSession.send\u001b[0;34m(self, request, **kwargs)\u001b[0m\n\u001b[1;32m    698\u001b[0m start \u001b[38;5;241m=\u001b[39m preferred_clock()\n\u001b[1;32m    700\u001b[0m \u001b[38;5;66;03m# Send the request\u001b[39;00m\n\u001b[0;32m--> 701\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43madapter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrequest\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    703\u001b[0m \u001b[38;5;66;03m# Total elapsed time of the request (approximately)\u001b[39;00m\n\u001b[1;32m    704\u001b[0m elapsed \u001b[38;5;241m=\u001b[39m preferred_clock() \u001b[38;5;241m-\u001b[39m start\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/huggingface_hub/utils/_http.py:67\u001b[0m, in \u001b[0;36mUniqueRequestIdAdapter.send\u001b[0;34m(self, request, *args, **kwargs)\u001b[0m\n\u001b[1;32m     65\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Catch any RequestException to append request id to the error message for debugging.\"\"\"\u001b[39;00m\n\u001b[1;32m     66\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 67\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrequest\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     68\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m requests\u001b[38;5;241m.\u001b[39mRequestException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m     69\u001b[0m     request_id \u001b[38;5;241m=\u001b[39m request\u001b[38;5;241m.\u001b[39mheaders\u001b[38;5;241m.\u001b[39mget(X_AMZN_TRACE_ID)\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.8/site-packages/requests/adapters.py:559\u001b[0m, in \u001b[0;36mHTTPAdapter.send\u001b[0;34m(self, request, stream, timeout, verify, cert, proxies)\u001b[0m\n\u001b[1;32m    556\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m RetryError(e, request\u001b[38;5;241m=\u001b[39mrequest)\n\u001b[1;32m    558\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(e\u001b[38;5;241m.\u001b[39mreason, _ProxyError):\n\u001b[0;32m--> 559\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m ProxyError(e, request\u001b[38;5;241m=\u001b[39mrequest)\n\u001b[1;32m    561\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(e\u001b[38;5;241m.\u001b[39mreason, _SSLError):\n\u001b[1;32m    562\u001b[0m     \u001b[38;5;66;03m# This branch is for urllib3 v1.22 and later.\u001b[39;00m\n\u001b[1;32m    563\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m SSLError(e, request\u001b[38;5;241m=\u001b[39mrequest)\n",
      "\u001b[0;31mProxyError\u001b[0m: (MaxRetryError(\"HTTPSConnectionPool(host='huggingface.co', port=443): Max retries exceeded with url: /timm/tf_efficientnet_b0.ns_jft_in1k/resolve/main/model.safetensors (Caused by ProxyError('Cannot connect to proxy.', timeout('_ssl.c:1114: The handshake operation timed out')))\"), '(Request ID: 3ea57093-3865-467e-b330-6ccf8397bb65)')"
     ]
    }
   ],
   "source": [
    "score_list = []\n",
    "\n",
    "gkf = GroupKFold(n_splits=5)\n",
    "for i, (train_index, valid_index) in enumerate(gkf.split(train, train.target, train.patient_id)):  \n",
    "    print('#'*25)\n",
    "    print(f'###  Fold {i}')\n",
    "    \n",
    "    output_path = Path(f\"fold{i}\")\n",
    "    output_path.mkdir(exist_ok=True)\n",
    "    print(f\"[fold{i}]\")     \n",
    "    score_list.append(train_one_fold(CFG, i,train_index, valid_index, output_path))\n",
    "    # score_list.append(train_one_fold(CFG, i,train_index, valid_index, output_path, stage='sec'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70752ec3",
   "metadata": {
    "papermill": {
     "duration": 0.030567,
     "end_time": "2024-03-04T17:11:09.122822",
     "exception": false,
     "start_time": "2024-03-04T17:11:09.092255",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Inference Out Of Fold\n",
    "Copy best models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9873007e",
   "metadata": {
    "papermill": {
     "duration": 0.039805,
     "end_time": "2024-03-04T17:11:09.193161",
     "exception": false,
     "start_time": "2024-03-04T17:11:09.153356",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(score_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4e6a7d8",
   "metadata": {
    "papermill": {
     "duration": 0.187809,
     "end_time": "2024-03-04T17:11:09.411753",
     "exception": false,
     "start_time": "2024-03-04T17:11:09.223944",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "best_log_list = []\n",
    "for (fold_id, best_epoch, _) in score_list:\n",
    "    \n",
    "    exp_dir_path = Path(f\"fold{fold_id}\")\n",
    "    best_model_path = exp_dir_path / f\"snapshot_epoch_{best_epoch}.pth\"\n",
    "    copy_to = f\"./best_model_fold{fold_id}.pth\"\n",
    "    shutil.copy(best_model_path, copy_to)\n",
    "    \n",
    "    for p in exp_dir_path.glob(\"*.pth\"):\n",
    "        p.unlink()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d6fe6ce",
   "metadata": {
    "papermill": {
     "duration": 0.030335,
     "end_time": "2024-03-04T17:11:09.473151",
     "exception": false,
     "start_time": "2024-03-04T17:11:09.442816",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Inference OOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60c87fe3",
   "metadata": {
    "papermill": {
     "duration": 0.040733,
     "end_time": "2024-03-04T17:11:09.544495",
     "exception": false,
     "start_time": "2024-03-04T17:11:09.503762",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def run_inference_loop(model, loader, device):\n",
    "    model.to(device)\n",
    "    model.eval()\n",
    "    pred_list = []\n",
    "    with torch.no_grad():\n",
    "        for batch in tqdm(loader):\n",
    "            x, t = batch\n",
    "            x = x.to(device)\n",
    "            t = t.to(device)\n",
    "            y = model(x)\n",
    "            pred_list.append(y.softmax(dim=1).detach().cpu().numpy())\n",
    "        \n",
    "    pred_arr = np.concatenate(pred_list)\n",
    "    del pred_list\n",
    "    return pred_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64e62166",
   "metadata": {
    "papermill": {
     "duration": 0.037817,
     "end_time": "2024-03-04T17:11:09.613108",
     "exception": false,
     "start_time": "2024-03-04T17:11:09.575291",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "device = torch.device(CFG.device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b7616c3",
   "metadata": {
    "papermill": {
     "duration": 137.788265,
     "end_time": "2024-03-04T17:13:27.432406",
     "exception": false,
     "start_time": "2024-03-04T17:11:09.644141",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "all_oof = []\n",
    "all_true = []\n",
    "valid_loaders = []\n",
    "for i, (train_index, valid_index) in enumerate(gkf.split(train, train.target, train.patient_id)):  \n",
    "    print('#'*25)\n",
    "    print(f'### Fold {i+1}')\n",
    "    valid_data = train.iloc[valid_index]\n",
    "\n",
    "    valid_ds = EEGDataset(valid_data, mode='valid', specs=spectrograms, eeg_specs=all_eegs, raw_eegs=all_raw_eegs, data_type='both')\n",
    "    valid_loader = DataLoader(valid_ds, shuffle=False, batch_size=CFG.batch_size*2, num_workers=3)\n",
    "    print(f'###  Valid size: {len(valid_index)}')\n",
    "    print('#'*25)\n",
    "    \n",
    "    # # get model\n",
    "    model_path = f\"./best_model_fold{i}.pth\"\n",
    "    model = HMSHBACSpecModel(\n",
    "        model_name=CFG.model_name, pretrained=False, num_classes=6, in_channels=3)\n",
    "    model.to(device)\n",
    "    \n",
    "    model.load_state_dict(torch.load(model_path, map_location=device))\n",
    "    \n",
    "    # # inference\n",
    "    val_pred = run_inference_loop(model, valid_loader, device)\n",
    "    valid_loaders.append(valid_loader)\n",
    "    all_true.append(train.iloc[valid_index][TARGETS].values)\n",
    "    all_oof.append(val_pred)\n",
    "    del model\n",
    "    gc.collect()\n",
    "\n",
    "all_oof = np.concatenate(all_oof)\n",
    "all_true = np.concatenate(all_true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "811e7e14",
   "metadata": {
    "papermill": {
     "duration": 0.096128,
     "end_time": "2024-03-04T17:13:27.561141",
     "exception": false,
     "start_time": "2024-03-04T17:13:27.465013",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "oof = pd.DataFrame(all_oof.copy())\n",
    "oof['id'] = np.arange(len(oof))\n",
    "\n",
    "true = pd.DataFrame(all_true.copy())\n",
    "true['id'] = np.arange(len(true))\n",
    "\n",
    "cv = score(solution=true, submission=oof, row_id_column_name='id')\n",
    "print(f'CV Score KL-Div for {CFG.model_name} =',cv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e063aa0",
   "metadata": {
    "papermill": {
     "duration": 0.042658,
     "end_time": "2024-03-04T17:13:27.636297",
     "exception": false,
     "start_time": "2024-03-04T17:13:27.593639",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# # WEIGHTS_FILE = '/kaggle/input/hms-efficientnetb0-pt-ckpts/efficientnet_b0_rwightman-7f5810bc.pth'\n",
    "\n",
    "\n",
    "# class HMSModel(pl.LightningModule):\n",
    "    \n",
    "#     def __init__(\n",
    "#         self,\n",
    "#         model_name: str,\n",
    "#         pretrained: bool,\n",
    "#         in_channels: int,\n",
    "#         num_classes: int,\n",
    "    \n",
    "#     ):\n",
    "#         super().__init__()\n",
    "#         self.base_model = timm.create_model(\n",
    "#             model_name=model_name, pretrained=pretrained,\n",
    "#             num_classes=num_classes, in_chans=in_channels)\n",
    "#         self.prob_out = nn.Softmax()\n",
    "        \n",
    "#     def forward(self, x):\n",
    "#         x1 = [x[:, :, :, i:i+1] for i in range(4)]\n",
    "#         x1 = torch.concat(x1, dim=1)\n",
    "#         x2 = [x[:, :, :, i+4:i+5] for i in range(4)]\n",
    "#         x2 = torch.concat(x2, dim=1)\n",
    "        \n",
    "#         if CFG.USE_KAGGLE_SPECTROGRAMS & CFG.USE_EEG_SPECTROGRAMS:\n",
    "#             x = torch.concat([x1, x2], dim=2)\n",
    "#         elif CFG.USE_EEG_SPECTROGRAMS:\n",
    "#             x = x2\n",
    "#         else:\n",
    "#             x = x1\n",
    "#         x = torch.concat([x, x, x], dim=3)\n",
    "#         x = x.permute(0, 3, 1, 2)\n",
    "        \n",
    "#         out = self.base_model(x)\n",
    "#         return out\n",
    "    \n",
    "#     def training_step(self, batch, batch_idx):\n",
    "#         x, y = batch\n",
    "    \n",
    "#         out = self.forward(x)\n",
    "#         out = F.log_softmax(out, dim=1)\n",
    "#         kl_loss = nn.KLDivLoss(reduction='batchmean')\n",
    "#         loss = kl_loss(out, y)\n",
    "#         return loss\n",
    "    \n",
    "#     def predict_step(self, batch, batch_idx, dataloader_idx=0):\n",
    "#         return F.softmax(self(batch), dim=1)\n",
    "    \n",
    "#     def configure_optimizers(self):\n",
    "#         optimizer = torch.optim.Adam(self.parameters(), lr=CFG.lr)\n",
    "#         return optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "628cd6dd",
   "metadata": {
    "papermill": {
     "duration": 0.040715,
     "end_time": "2024-03-04T17:13:27.710447",
     "exception": false,
     "start_time": "2024-03-04T17:13:27.669732",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# all_oof = []\n",
    "# all_true = []\n",
    "# valid_loaders = []\n",
    "\n",
    "# gkf = GroupKFold(n_splits=5)\n",
    "# for i, (train_index, valid_index) in enumerate(gkf.split(train, train.target, train.patient_id)):  \n",
    "#     print('#'*25)\n",
    "#     print(f'### Fold {i+1}')\n",
    "    \n",
    "#     train_ds = EEGDataset(train.iloc[train_index])\n",
    "#     train_loader = DataLoader(train_ds, shuffle=True, batch_size=CFG.batch_size, num_workers=3)\n",
    "#     valid_ds = EEGDataset(train.iloc[valid_index], mode='valid')\n",
    "#     valid_loader = DataLoader(valid_ds, shuffle=False, batch_size=CFG.batch_size*2, num_workers=3)\n",
    "    \n",
    "#     print(f'### Train size: {len(train_index)}, Valid size: {len(valid_index)}')\n",
    "#     print('#'*25)\n",
    "    \n",
    "#     trainer = pl.Trainer(max_epochs=CFG.max_epoch)\n",
    "#     model = HMSModel(model_name=CFG.model_name, pretrained=True, num_classes=6, in_channels=3)\n",
    "#     if LOAD_MODELS_FROM is None:\n",
    "#         trainer.fit(model=model, train_dataloaders=train_loader)\n",
    "#         # 手动保存模型权重\n",
    "#         trainer.save_checkpoint(f'{CFG.model_name}_v{CFG.VER}_f{i}.ckpt')\n",
    "\n",
    "#     valid_loaders.append(valid_loader)\n",
    "#     all_true.append(train.iloc[valid_index][TARGETS].values)\n",
    "#     del trainer\n",
    "#     gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5429184b",
   "metadata": {
    "papermill": {
     "duration": 0.040187,
     "end_time": "2024-03-04T17:13:27.783334",
     "exception": false,
     "start_time": "2024-03-04T17:13:27.743147",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef75bdc3",
   "metadata": {
    "papermill": {
     "duration": 0.042227,
     "end_time": "2024-03-04T17:13:27.858815",
     "exception": false,
     "start_time": "2024-03-04T17:13:27.816588",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# for i in range(5):\n",
    "#     print('#'*25)\n",
    "#     print(f'### Validating Fold {i+1}')\n",
    "\n",
    "#     ckpt_file = f'{CFG.model_name}_v{CFG.VER}_f{i}.ckpt' if LOAD_MODELS_FROM is None else f'{LOAD_MODELS_FROM}/{CFG.model_name}_v{CFG.VER}_f{i}.ckpt'\n",
    "#     model = model.load_from_cxheckpoint(ckpt_file)\n",
    "#     model.to(device).eval()\n",
    "#     with torch.inference_mode():\n",
    "#         for val_batch in valid_loaders[i]:\n",
    "#             val_batch = val_batch.to(device)\n",
    "#             oof = torch.softmax(model(val_batch), dim=1).cpu().numpy()\n",
    "#             all_oof.append(oof)\n",
    "#     del model\n",
    "#     gc.collect()\n",
    "\n",
    "# all_oof = np.concatenate(all_oof)\n",
    "# all_true = np.concatenate(all_true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4c0720b",
   "metadata": {
    "papermill": {
     "duration": 0.040004,
     "end_time": "2024-03-04T17:13:27.932508",
     "exception": false,
     "start_time": "2024-03-04T17:13:27.892504",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# oof = pd.DataFrame(all_oof.copy())\n",
    "# oof['id'] = np.arange(len(oof))\n",
    "\n",
    "# true = pd.DataFrame(all_true.copy())\n",
    "# true['id'] = np.arange(len(true))\n",
    "\n",
    "# cv = score(solution=true, submission=oof, row_id_column_name='id')\n",
    "# print('CV Score KL-Div for EfficientNetB2 =',cv)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49c95065",
   "metadata": {
    "papermill": {
     "duration": 0.033841,
     "end_time": "2024-03-04T17:13:28.000319",
     "exception": false,
     "start_time": "2024-03-04T17:13:27.966478",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b45418f7",
   "metadata": {
    "papermill": {
     "duration": 0.041779,
     "end_time": "2024-03-04T17:13:28.076017",
     "exception": false,
     "start_time": "2024-03-04T17:13:28.034238",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# del all_eegs, spectrograms\n",
    "# gc.collect()\n",
    "\n",
    "# test = pd.read_csv('/kaggle/input/hms-harmful-brain-activity-classification/test.csv')\n",
    "# print('Test shape',test.shape)\n",
    "# test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ffceaac",
   "metadata": {
    "papermill": {
     "duration": 0.042438,
     "end_time": "2024-03-04T17:13:28.151935",
     "exception": false,
     "start_time": "2024-03-04T17:13:28.109497",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# # READ ALL SPECTROGRAMS\n",
    "# PATH2 = '/kaggle/input/hms-harmful-brain-activity-classification/test_spectrograms/'\n",
    "# files2 = os.listdir(PATH2)\n",
    "# print(f'There are {len(files2)} test spectrogram parquets')\n",
    "    \n",
    "# spectrograms2 = {}\n",
    "# for i, f in enumerate(files2):\n",
    "#     if i % 100 == 0:\n",
    "#         print(i, ', ',end='')\n",
    "#     tmp = pd.read_parquet(f'{PATH2}{f}')\n",
    "#     name = int(f.split('.')[0])\n",
    "#     spectrograms2[name] = tmp.iloc[:, 1:].values\n",
    "    \n",
    "# # RENAME FOR DATALOADER\n",
    "# test = test.rename({'spectrogram_id': 'spec_id'}, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7bd166d4",
   "metadata": {
    "papermill": {
     "duration": 0.043474,
     "end_time": "2024-03-04T17:13:28.228365",
     "exception": false,
     "start_time": "2024-03-04T17:13:28.184891",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# import pywt, librosa\n",
    "\n",
    "# USE_WAVELET = None \n",
    "\n",
    "# NAMES = ['LL','LP','RP','RR']\n",
    "\n",
    "# FEATS = [['Fp1','F7','T3','T5','O1'],\n",
    "#          ['Fp1','F3','C3','P3','O1'],\n",
    "#          ['Fp2','F8','T4','T6','O2'],\n",
    "#          ['Fp2','F4','C4','P4','O2']]\n",
    "\n",
    "\n",
    "# # DENOISE FUNCTION\n",
    "# def maddest(d, axis=None):\n",
    "#     return np.mean(np.absolute(d - np.mean(d, axis)), axis)\n",
    "\n",
    "\n",
    "# def denoise(x, wavelet='haar', level=1):    \n",
    "#     coeff = pywt.wavedec(x, wavelet, mode=\"per\")\n",
    "#     sigma = (1/0.6745) * maddest(coeff[-level])\n",
    "\n",
    "#     uthresh = sigma * np.sqrt(2*np.log(len(x)))\n",
    "#     coeff[1:] = (pywt.threshold(i, value=uthresh, mode='hard') for i in coeff[1:])\n",
    "\n",
    "#     ret=pywt.waverec(coeff, wavelet, mode='per')\n",
    "    \n",
    "#     return ret\n",
    "\n",
    "\n",
    "# def spectrogram_from_eeg(parquet_path, display=False):\n",
    "    \n",
    "#     # LOAD MIDDLE 50 SECONDS OF EEG SERIES\n",
    "#     eeg = pd.read_parquet(parquet_path)\n",
    "#     middle = (len(eeg)-10_000)//2\n",
    "#     eeg = eeg.iloc[middle:middle+10_000]\n",
    "    \n",
    "#     # VARIABLE TO HOLD SPECTROGRAM\n",
    "#     img = np.zeros((128,256,4),dtype='float32')\n",
    "    \n",
    "#     if display: plt.figure(figsize=(10,7))\n",
    "#     signals = []\n",
    "#     for k in range(4):\n",
    "#         COLS = FEATS[k]\n",
    "        \n",
    "#         for kk in range(4):\n",
    "        \n",
    "#             # COMPUTE PAIR DIFFERENCES\n",
    "#             x = eeg[COLS[kk]].values - eeg[COLS[kk+1]].values\n",
    "\n",
    "#             # FILL NANS\n",
    "#             m = np.nanmean(x)\n",
    "#             if np.isnan(x).mean()<1: x = np.nan_to_num(x,nan=m)\n",
    "#             else: x[:] = 0\n",
    "\n",
    "#             # DENOISE\n",
    "#             if USE_WAVELET:\n",
    "#                 x = denoise(x, wavelet=USE_WAVELET)\n",
    "#             signals.append(x)\n",
    "\n",
    "#             # RAW SPECTROGRAM\n",
    "#             mel_spec = librosa.feature.melspectrogram(y=x, sr=200, hop_length=len(x)//256, \n",
    "#                   n_fft=1024, n_mels=128, fmin=0, fmax=20, win_length=128)\n",
    "\n",
    "#             # LOG TRANSFORM\n",
    "#             width = (mel_spec.shape[1]//32)*32\n",
    "#             mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max).astype(np.float32)[:,:width]\n",
    "\n",
    "#             # STANDARDIZE TO -1 TO 1\n",
    "#             mel_spec_db = (mel_spec_db+40)/40 \n",
    "#             img[:,:,k] += mel_spec_db\n",
    "                \n",
    "#         # AVERAGE THE 4 MONTAGE DIFFERENCES\n",
    "#         img[:,:,k] /= 4.0\n",
    "        \n",
    "#         if display:\n",
    "#             plt.subplot(2,2,k+1)\n",
    "#             plt.imshow(img[:,:,k],aspect='auto',origin='lower')\n",
    "#             plt.title(f'EEG {eeg_id} - Spectrogram {NAMES[k]}')\n",
    "            \n",
    "#     if display: \n",
    "#         plt.show()\n",
    "#         plt.figure(figsize=(10,5))\n",
    "#         offset = 0\n",
    "#         for k in range(4):\n",
    "#             if k>0: offset -= signals[3-k].min()\n",
    "#             plt.plot(range(10_000),signals[k]+offset,label=NAMES[3-k])\n",
    "#             offset += signals[3-k].max()\n",
    "#         plt.legend()\n",
    "#         plt.title(f'EEG {eeg_id} Signals')\n",
    "#         plt.show()\n",
    "#         print(); print('#'*25); print()\n",
    "        \n",
    "#     return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d09720e4",
   "metadata": {
    "papermill": {
     "duration": 0.040139,
     "end_time": "2024-03-04T17:13:28.301301",
     "exception": false,
     "start_time": "2024-03-04T17:13:28.261162",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# # READ ALL EEG SPECTROGRAMS\n",
    "# PATH2 = '/kaggle/input/hms-harmful-brain-activity-classification/test_eegs/'\n",
    "# DISPLAY = 1\n",
    "# EEG_IDS2 = test.eeg_id.unique()\n",
    "# all_eegs2 = {}\n",
    "\n",
    "# print('Converting Test EEG to Spectrograms...'); print()\n",
    "# for i, eeg_id in enumerate(EEG_IDS2):\n",
    "        \n",
    "#     # CREATE SPECTROGRAM FROM EEG PARQUET\n",
    "#     img = spectrogram_from_eeg(f'{PATH2}{eeg_id}.parquet', i < DISPLAY)\n",
    "#     all_eegs2[eeg_id] = img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48a13ed6",
   "metadata": {
    "papermill": {
     "duration": 0.042224,
     "end_time": "2024-03-04T17:13:28.376392",
     "exception": false,
     "start_time": "2024-03-04T17:13:28.334168",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# # INFER EFFICIENTNET ON TEST\n",
    "# preds = []\n",
    "# test_ds = EEGDataset(test, mode='test', specs=spectrograms2, eeg_specs=all_eegs2)\n",
    "# test_loader = DataLoader(test_ds, shuffle=False, batch_size=64, num_workers=3)\n",
    "\n",
    "# for i in range(5):\n",
    "#     print('#'*25)\n",
    "#     print(f'### Testing Fold {i+1}')\n",
    "\n",
    "#     ckpt_file = f'{CFG.model_name}_v{CFG.VER}_f{i}.ckpt' if LOAD_MODELS_FROM is None else f'{LOAD_MODELS_FROM}/{CFG.model_name}_v{CFG.VER}_f{i}.ckpt'\n",
    "#     model = EEGEffnetB0.load_from_checkpoint(ckpt_file)\n",
    "#     model.to(device).eval()\n",
    "#     fold_preds = []\n",
    "\n",
    "#     with torch.inference_mode():\n",
    "#         for test_batch in test_loader:\n",
    "#             test_batch = test_batch.to(device)\n",
    "#             pred = torch.softmax(model(test_batch), dim=1).cpu().numpy()\n",
    "#             fold_preds.append(pred)\n",
    "#         fold_preds = np.concatenate(fold_preds)\n",
    "\n",
    "#     preds.append(fold_preds)\n",
    "\n",
    "# pred = np.mean(preds,axis=0)\n",
    "# print()\n",
    "# print('Test preds shape',pred.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c999a47a",
   "metadata": {
    "papermill": {
     "duration": 0.039963,
     "end_time": "2024-03-04T17:13:28.450107",
     "exception": false,
     "start_time": "2024-03-04T17:13:28.410144",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# sub = pd.DataFrame({'eeg_id': test.eeg_id.values})\n",
    "# sub[TARGETS] = pred\n",
    "# sub.to_csv('submission.csv',index=False)\n",
    "# print('Submissionn shape',sub.shape)\n",
    "# sub.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b09f5fb",
   "metadata": {
    "papermill": {
     "duration": 0.040814,
     "end_time": "2024-03-04T17:13:28.524107",
     "exception": false,
     "start_time": "2024-03-04T17:13:28.483293",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# # SANITY CHECK TO CONFIRM PREDICTIONS SUM TO ONE\n",
    "# sub.iloc[:,-6:].sum(axis=1)"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [
    {
     "databundleVersionId": 7469972,
     "sourceId": 59093,
     "sourceType": "competition"
    },
    {
     "datasetId": 4297749,
     "sourceId": 7392733,
     "sourceType": "datasetVersion"
    },
    {
     "datasetId": 4297782,
     "sourceId": 7392775,
     "sourceType": "datasetVersion"
    },
    {
     "datasetId": 4334995,
     "sourceId": 7447509,
     "sourceType": "datasetVersion"
    },
    {
     "datasetId": 4317718,
     "sourceId": 7465251,
     "sourceType": "datasetVersion"
    },
    {
     "datasetId": 4407194,
     "sourceId": 7570342,
     "sourceType": "datasetVersion"
    },
    {
     "datasetId": 4529157,
     "sourceId": 7760353,
     "sourceType": "datasetVersion"
    }
   ],
   "dockerImageVersionId": 30665,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "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.8.10"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 2049.261071,
   "end_time": "2024-03-04T17:13:32.851041",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2024-03-04T16:39:23.589970",
   "version": "2.5.0"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "03012e9d592c44e4b9223cbb593847c6": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_d1281f09074948b5addf8e30e70da9ad",
       "placeholder": "​",
       "style": "IPY_MODEL_488a48fec92143f1b56f4c9262737983",
       "value": "100%"
      }
     },
     "0495c9e461254d208a3cc65b7d857d71": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "0f905055e79e400d86608a6db93953c9": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "12a96a8d7427446b871a27e224f7e28a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_e06b996b4d9c485f9329293fa7d24e39",
       "placeholder": "​",
       "style": "IPY_MODEL_7eeaa9ee0098472a9ccf799251ad21df",
       "value": " 54/54 [00:21&lt;00:00,  3.63it/s]"
      }
     },
     "1b26dd2ff9b1478b9ea11c41e635788d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "1d9a2d8a7baf4792ac692a978361b5f2": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "28681796dba24f3d8bbb13f4e75629b0": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_5551ba9b39e3429996adb7dede766397",
       "max": 54,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_778d8d88e2604f4c9b7c006bff5f1a7e",
       "value": 54
      }
     },
     "2a0d388281454327b3feb762507e2c87": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "2baebf94bef54ca99ea4b20f7a977b4c": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "2ce02e90ccad4bc4a7902cff61d95fc2": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "2d3dbb594d88405cbecf00f9167b7c8f": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "2f0ff25e515d4bc49be18ca802b1efd5": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "3f67f37edbfa4f34a9d76dab11943331": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_ea447827127b4b0190feeb16c2a4130f",
       "placeholder": "​",
       "style": "IPY_MODEL_aa2d29923dcb4b9cb1e593e7902114b3",
       "value": " 54/54 [00:20&lt;00:00,  3.64it/s]"
      }
     },
     "4660daaec7694cb5a9006788602ea8d4": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_c26b2d6d4fb04927a67292e06ede52c6",
       "placeholder": "​",
       "style": "IPY_MODEL_b311ef0d5fea4fec9d496f04dd2a294a",
       "value": "100%"
      }
     },
     "488a48fec92143f1b56f4c9262737983": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "5551ba9b39e3429996adb7dede766397": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "565db9ebd770498582c91e71c03d9ecb": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_4660daaec7694cb5a9006788602ea8d4",
        "IPY_MODEL_f67014fd721a4fa49f8b82c68dfbbb42",
        "IPY_MODEL_fb7da03ea42a4c23bdf1b2dd11644058"
       ],
       "layout": "IPY_MODEL_2a0d388281454327b3feb762507e2c87"
      }
     },
     "56fa873d4ff342fdad23f6ecd7f89075": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_1b26dd2ff9b1478b9ea11c41e635788d",
       "placeholder": "​",
       "style": "IPY_MODEL_7dbd89e791444383b92c25cd1f908982",
       "value": "100%"
      }
     },
     "5df4fda4606548768ea9374b8b2cafc9": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "5fc8587c57de4415b6b1253a4c178bd3": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_8c6d060c7ccd430285abd83e4c6f56d4",
        "IPY_MODEL_8e07af3bede44409b40323749825d3ec",
        "IPY_MODEL_d31d597b5e2a44f5a1416074c704e7e0"
       ],
       "layout": "IPY_MODEL_940b39cd44e34ec0ac2c7ca79d6f83ab"
      }
     },
     "60bf69b6cf3e4029b7ecafdd618ab0a0": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "6611e67eea94489697c13aa3f224a2d4": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "66181bb676b6463998d00f096676b0ae": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "742c4563ef3842d4969a4fe87c6c3fdc": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "767e7dddabcf42008eced77ea3550c83": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "76eeb193a4094d918136d2cd043cf6ca": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "772fadb46d254ac5849972e5d663b1c1": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "778d8d88e2604f4c9b7c006bff5f1a7e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "7a08523bafc943faa5d94ae74b44a665": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "7a0a85b458ee4e159aeedc0107e17ec3": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_b144ad2d34364b5e9866f587373354fd",
       "max": 54,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_b3246e709a624978ace3974a47932708",
       "value": 54
      }
     },
     "7ab13965c520412bbe14a7376d2e981f": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "7c0c43a1aaa74e81817528e2c88e273a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "7dbd89e791444383b92c25cd1f908982": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "7e37f98e785b4f78867bac48fed5ffd1": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_1d9a2d8a7baf4792ac692a978361b5f2",
       "max": 54,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_dca8265f44b243cb9bb44452592e724b",
       "value": 54
      }
     },
     "7eeaa9ee0098472a9ccf799251ad21df": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "8373d87f380f4d6ba495c8c60b702175": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "8c6d060c7ccd430285abd83e4c6f56d4": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_0f905055e79e400d86608a6db93953c9",
       "placeholder": "​",
       "style": "IPY_MODEL_2d3dbb594d88405cbecf00f9167b7c8f",
       "value": "model.safetensors: 100%"
      }
     },
     "8e07af3bede44409b40323749825d3ec": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_772fadb46d254ac5849972e5d663b1c1",
       "max": 21355344,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_b409dec6c42d4f45a06bd8c35620779a",
       "value": 21355344
      }
     },
     "8f12351099044038b5566055e9bc704e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "940b39cd44e34ec0ac2c7ca79d6f83ab": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "9fa04c598bbf46818d4e06c7a04c8a87": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "9fd0b3f86da34dddb4338467135d96cb": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_03012e9d592c44e4b9223cbb593847c6",
        "IPY_MODEL_7a0a85b458ee4e159aeedc0107e17ec3",
        "IPY_MODEL_3f67f37edbfa4f34a9d76dab11943331"
       ],
       "layout": "IPY_MODEL_2baebf94bef54ca99ea4b20f7a977b4c"
      }
     },
     "a43595397f034f8aad45582e05dc372d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "a92e4d3ad71840aba5cef09695f9d1b2": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_ea37ce82c5ad4e329251241b95648845",
       "placeholder": "​",
       "style": "IPY_MODEL_2ce02e90ccad4bc4a7902cff61d95fc2",
       "value": "100%"
      }
     },
     "aa2d29923dcb4b9cb1e593e7902114b3": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "abf5cae6aa2142469aaa39ff37dcc74b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_66181bb676b6463998d00f096676b0ae",
       "placeholder": "​",
       "style": "IPY_MODEL_8373d87f380f4d6ba495c8c60b702175",
       "value": "100%"
      }
     },
     "ac402482e90d48e7b948d62fa2845d4d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "b144ad2d34364b5e9866f587373354fd": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "b311ef0d5fea4fec9d496f04dd2a294a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "b3246e709a624978ace3974a47932708": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "b409dec6c42d4f45a06bd8c35620779a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "c26b2d6d4fb04927a67292e06ede52c6": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "d1281f09074948b5addf8e30e70da9ad": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "d31d597b5e2a44f5a1416074c704e7e0": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_742c4563ef3842d4969a4fe87c6c3fdc",
       "placeholder": "​",
       "style": "IPY_MODEL_6611e67eea94489697c13aa3f224a2d4",
       "value": " 21.4M/21.4M [00:00&lt;00:00, 98.5MB/s]"
      }
     },
     "dca8265f44b243cb9bb44452592e724b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "e06b996b4d9c485f9329293fa7d24e39": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "e81ef2075b1a4ffd92fa2a98c8d4add7": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_2f0ff25e515d4bc49be18ca802b1efd5",
       "placeholder": "​",
       "style": "IPY_MODEL_5df4fda4606548768ea9374b8b2cafc9",
       "value": " 54/54 [00:28&lt;00:00,  2.33s/it]"
      }
     },
     "ea37ce82c5ad4e329251241b95648845": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "ea447827127b4b0190feeb16c2a4130f": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "ee8b70bf1a4a45458fc0d52cd355e3b5": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_9fa04c598bbf46818d4e06c7a04c8a87",
       "max": 54,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_60bf69b6cf3e4029b7ecafdd618ab0a0",
       "value": 54
      }
     },
     "f5d3f7eed9db411fa8ff5fa5273220e8": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_76eeb193a4094d918136d2cd043cf6ca",
       "placeholder": "​",
       "style": "IPY_MODEL_7c0c43a1aaa74e81817528e2c88e273a",
       "value": " 54/54 [00:20&lt;00:00,  3.67it/s]"
      }
     },
     "f67014fd721a4fa49f8b82c68dfbbb42": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_a43595397f034f8aad45582e05dc372d",
       "max": 54,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_7ab13965c520412bbe14a7376d2e981f",
       "value": 54
      }
     },
     "f8f113d0c8f143d280d99cb1eb46b51a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_56fa873d4ff342fdad23f6ecd7f89075",
        "IPY_MODEL_28681796dba24f3d8bbb13f4e75629b0",
        "IPY_MODEL_12a96a8d7427446b871a27e224f7e28a"
       ],
       "layout": "IPY_MODEL_767e7dddabcf42008eced77ea3550c83"
      }
     },
     "fabdb8bed7db4d11bba02ee4c711c459": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_abf5cae6aa2142469aaa39ff37dcc74b",
        "IPY_MODEL_ee8b70bf1a4a45458fc0d52cd355e3b5",
        "IPY_MODEL_e81ef2075b1a4ffd92fa2a98c8d4add7"
       ],
       "layout": "IPY_MODEL_0495c9e461254d208a3cc65b7d857d71"
      }
     },
     "fb7da03ea42a4c23bdf1b2dd11644058": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_7a08523bafc943faa5d94ae74b44a665",
       "placeholder": "​",
       "style": "IPY_MODEL_8f12351099044038b5566055e9bc704e",
       "value": " 54/54 [00:43&lt;00:00,  2.38s/it]"
      }
     },
     "fd1d883d3d084637a58db7876ec268be": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_a92e4d3ad71840aba5cef09695f9d1b2",
        "IPY_MODEL_7e37f98e785b4f78867bac48fed5ffd1",
        "IPY_MODEL_f5d3f7eed9db411fa8ff5fa5273220e8"
       ],
       "layout": "IPY_MODEL_ac402482e90d48e7b948d62fa2845d4d"
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}