Transformer_PyTorch_Lightning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fcada710",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cuda device\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "from torch.utils.data import random_split, DataLoader\n",
    "import torch.nn as nn\n",
    "from torchmetrics import Accuracy\n",
    "\n",
    "import pytorch_lightning as pl\n",
    "from vit_pytorch.vit_1d import ViT\n",
    "\n",
    "NUM_WORKERS = int(os.cpu_count() // 4)\n",
    "\n",
    "device = (\n",
    "    \"cuda\"\n",
    "    if torch.cuda.is_available()\n",
    "    else \"mps\"\n",
    "    if torch.backends.mps.is_available()\n",
    "    else \"cpu\"\n",
    ")\n",
    "print(f\"Using {device} device\")\n",
    "torch.set_float32_matmul_precision('medium')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdba1e26",
   "metadata": {},
   "source": [
    "#### Import training/testing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3662c263",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = pd.read_pickle('train.pkl.gz').sample(frac=1, random_state=1)\n",
    "test_df = pd.read_pickle('test.pkl.gz').sample(frac=1, random_state=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a139a61b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Data</th>\n",
       "      <th>Label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>674</th>\n",
       "      <td>[[1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,...</td>\n",
       "      <td>674</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1699</th>\n",
       "      <td>[[1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,...</td>\n",
       "      <td>1699</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1282</th>\n",
       "      <td>[[2, 1, 1, 0, 2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1,...</td>\n",
       "      <td>1282</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1315</th>\n",
       "      <td>[[0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,...</td>\n",
       "      <td>1315</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                   Data  Label\n",
       "674   [[1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,...    674\n",
       "1699  [[1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,...   1699\n",
       "1282  [[2, 1, 1, 0, 2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1,...   1282\n",
       "1315  [[0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,...   1315"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.head(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2fb9143",
   "metadata": {},
   "source": [
    "#### Each data is a (250, 128) numpy array per label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bfa0380a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2000, 250, 128), (2000,), (2000, 250, 128), (2000,))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert pandas to numpy array\n",
    "\n",
    "data_array_train = np.stack(train_df['Data'])\n",
    "label_array_train = np.stack(train_df['Label'])\n",
    "\n",
    "\n",
    "data_array_test = np.stack(test_df['Data'])\n",
    "label_array_test = np.stack(test_df['Label'])\n",
    "\n",
    "\n",
    "data_array_test.shape, label_array_test.shape, \\\n",
    "data_array_train.shape, label_array_train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c538e027",
   "metadata": {},
   "source": [
    "#### Put data and labels as a torch dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6e7b1fdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, data_array, label_array):\n",
    "        self.data = torch.from_numpy(data_array).float()\n",
    "        self.labels = label_array\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        return self.data[index], self.labels[index]\n",
    "\n",
    "training_data = Dataset(data_array_train, label_array_train)\n",
    "testing_data = Dataset(data_array_test, label_array_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27ad5d74",
   "metadata": {},
   "source": [
    "#### Using LightningDataModule to train/test etc later on. We will also split training into 80/20 for validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1ac654d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class DataModule(pl.LightningDataModule):\n",
    "    def __init__(self, batch_size=256):\n",
    "        super().__init__()\n",
    "        self.batch_size = batch_size\n",
    "\n",
    "    def setup(self, stage: str):\n",
    "        self.test = testing_data\n",
    "        full = training_data\n",
    "        self.train, self.val = random_split(\n",
    "            full, [0.8, 0.2], generator=torch.Generator().manual_seed(12345)\n",
    "        )\n",
    "\n",
    "    def train_dataloader(self):\n",
    "        return DataLoader(self.train, batch_size=self.batch_size, shuffle=True, num_workers=NUM_WORKERS)\n",
    "\n",
    "    def val_dataloader(self):\n",
    "        return DataLoader(self.val, batch_size=self.batch_size, shuffle=False, num_workers=NUM_WORKERS)\n",
    "\n",
    "    def test_dataloader(self):\n",
    "        return DataLoader(self.test, batch_size=self.batch_size, shuffle=False, num_workers=NUM_WORKERS)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e10622d9",
   "metadata": {},
   "source": [
    "#### The trainer module for transformer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "608d6dc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_CLASSES = len(set(label_array_train))\n",
    "\n",
    "class MyLitModel(pl.LightningModule):\n",
    "    def __init__(self, lr=0.05):\n",
    "        super().__init__()\n",
    "        self.save_hyperparameters()\n",
    "        self.model = ViT(\n",
    "                        seq_len = 128, # this comes from shape of input data\n",
    "                        patch_size = 4,\n",
    "                        num_classes = NUM_CLASSES,\n",
    "                        dim = 1024,\n",
    "                        depth = 6,\n",
    "                        heads = 16,\n",
    "                        mlp_dim = 2048, \n",
    "                        channels=250, # this comes from shape of input data\n",
    "                    )\n",
    "        self.train_accuracy = Accuracy(task=\"multiclass\", num_classes=NUM_CLASSES)\n",
    "        self.val_accuracy = Accuracy(task=\"multiclass\", num_classes=NUM_CLASSES)\n",
    "        self.test_accuracy = Accuracy(task=\"multiclass\", num_classes=NUM_CLASSES)\n",
    "        self.loss_fn = nn.CrossEntropyLoss()\n",
    "    \n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        logits = self(x)\n",
    "        loss = self.loss_fn(logits, y)\n",
    "        self.log(\"train_loss\", loss, prog_bar=True,)\n",
    "        acc = self.train_accuracy(logits, y)\n",
    "        self.log(\"train_accuracy\", acc, prog_bar=True,)\n",
    "        return loss\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        logits = self(x)\n",
    "        loss = self.loss_fn(logits, y)\n",
    "        self.log(\"val_loss\", loss, prog_bar=True, )\n",
    "        acc = self.val_accuracy(logits, y)\n",
    "        self.log(\"val_accuracy\", acc, prog_bar=True,)\n",
    "        \n",
    "    def test_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        logits = self(x)\n",
    "        loss = self.loss_fn(logits, y)\n",
    "        self.log(\"test_loss\", loss, prog_bar=True,)\n",
    "        acc = self.test_accuracy(logits, y)\n",
    "        self.log(\"test_accuracy\", acc, prog_bar=True,)\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.SGD(self.parameters(), lr=self.hparams.lr, momentum=0.9)\n",
    "        return optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c33ce30",
   "metadata": {},
   "source": [
    "#### Train the model and log intermediate results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8f68d906",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "Missing logger folder: logs/ViT\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name           | Type               | Params\n",
      "------------------------------------------------------\n",
      "0 | model          | ViT                | 53.5 M\n",
      "1 | train_accuracy | MulticlassAccuracy | 0     \n",
      "2 | val_accuracy   | MulticlassAccuracy | 0     \n",
      "3 | test_accuracy  | MulticlassAccuracy | 0     \n",
      "4 | loss_fn        | CrossEntropyLoss   | 0     \n",
      "------------------------------------------------------\n",
      "53.5 M    Trainable params\n",
      "0         Non-trainable params\n",
      "53.5 M    Total params\n",
      "213.987   Total estimated model params size (MB)\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Sanity Checking: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "07d596a226a34b3bb61128fe61797780",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pytorch_lightning.loggers import CSVLogger\n",
    "from pytorch_lightning.callbacks import EarlyStopping\n",
    "\n",
    "logger = CSVLogger(\"logs\", name=\"ViT\")\n",
    "\n",
    "model = MyLitModel(lr=0.05)\n",
    "\n",
    "data = DataModule()\n",
    "trainer = pl.Trainer(\n",
    "    max_epochs=100,\n",
    "    accelerator=\"auto\",\n",
    "    devices=\"auto\",\n",
    "    logger=logger,\n",
    "    callbacks=EarlyStopping('val_loss', patience=5),\n",
    "    log_every_n_steps=4\n",
    ")\n",
    "\n",
    "trainer.fit(model, datamodule=data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e13de70",
   "metadata": {},
   "source": [
    "#### Test accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "43040659",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "38e9d45f88f64357919445716fca49ea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "       Test metric             DataLoader 0\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "      test_accuracy         0.6230000257492065\n",
      "        test_loss            3.817396640777588\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'test_loss': 3.817396640777588, 'test_accuracy': 0.6230000257492065}]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainer.test(model, datamodule=data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cdd442a",
   "metadata": {},
   "source": [
    "#### Some plottings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c3197296",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>epoch</th>\n",
       "      <th>step</th>\n",
       "      <th>test_accuracy</th>\n",
       "      <th>test_loss</th>\n",
       "      <th>train_accuracy</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>val_accuracy</th>\n",
       "      <th>val_loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.932872</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>8.36457</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   epoch  step  test_accuracy  test_loss  train_accuracy  train_loss  \\\n",
       "0      0     3            NaN        NaN             0.0    7.932872   \n",
       "1      0     6            NaN        NaN             NaN         NaN   \n",
       "\n",
       "   val_accuracy  val_loss  \n",
       "0           NaN       NaN  \n",
       "1           0.0   8.36457  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logs = pd.read_csv('logs/ViT/version_0/metrics.csv')\n",
    "logs.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6fc21368",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "sns.set_theme(style='whitegrid', palette='deep', font_scale=1.,)\n",
    "\n",
    "sns.lineplot(data=logs[['train_loss', 'val_loss']], lw=2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "20ce3f7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(data=logs[['train_accuracy', 'val_accuracy']], lw=2);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a73aec9",
   "metadata": {},
   "source": [
    "#### The trained model and hyperparameters are inside logs/ViT/ ... directory. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23af8f6a",
   "metadata": {},
   "source": [
    "#### This is how to load the model to do predictions on some other data later on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "d8b7c365",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "MyLitModel(\n",
       "  (model): ViT(\n",
       "    (to_patch_embedding): Sequential(\n",
       "      (0): Rearrange('b c (n p) -> b n (p c)', p=4)\n",
       "      (1): LayerNorm((1000,), eps=1e-05, elementwise_affine=True)\n",
       "      (2): Linear(in_features=1000, out_features=1024, bias=True)\n",
       "      (3): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
       "    )\n",
       "    (dropout): Dropout(p=0.0, inplace=False)\n",
       "    (transformer): Transformer(\n",
       "      (layers): ModuleList(\n",
       "        (0-5): 6 x ModuleList(\n",
       "          (0): Attention(\n",
       "            (norm): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
       "            (attend): Softmax(dim=-1)\n",
       "            (dropout): Dropout(p=0.0, inplace=False)\n",
       "            (to_qkv): Linear(in_features=1024, out_features=3072, bias=False)\n",
       "            (to_out): Sequential(\n",
       "              (0): Linear(in_features=1024, out_features=1024, bias=True)\n",
       "              (1): Dropout(p=0.0, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (1): FeedForward(\n",
       "            (net): Sequential(\n",
       "              (0): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
       "              (1): Linear(in_features=1024, out_features=2048, bias=True)\n",
       "              (2): GELU(approximate='none')\n",
       "              (3): Dropout(p=0.0, inplace=False)\n",
       "              (4): Linear(in_features=2048, out_features=1024, bias=True)\n",
       "              (5): Dropout(p=0.0, inplace=False)\n",
       "            )\n",
       "          )\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (mlp_head): Sequential(\n",
       "      (0): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
       "      (1): Linear(in_features=1024, out_features=2000, bias=True)\n",
       "    )\n",
       "  )\n",
       "  (train_accuracy): MulticlassAccuracy()\n",
       "  (val_accuracy): MulticlassAccuracy()\n",
       "  (test_accuracy): MulticlassAccuracy()\n",
       "  (loss_fn): CrossEntropyLoss()\n",
       ")"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the trainer and model\n",
    "loaded_trainer = pl.Trainer(default_root_dir=\"logs/ViT/version_0/\")\n",
    "loaded_model = MyLitModel.load_from_checkpoint(\"logs/ViT/version_0/checkpoints/epoch=11-step=84.ckpt\")\n",
    "\n",
    "# disable randomness, dropout, etc...\n",
    "loaded_model.eval()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e08c1bb1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Data</th>\n",
       "      <th>Label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[[0, 0, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[[1, 0, 1, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0,...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                Data  Label\n",
       "0  [[0, 0, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,...      0\n",
       "1  [[1, 0, 1, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0,...      1"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load the data to to predictions on\n",
    "\n",
    "pred_df = pd.read_pickle('pred.pkl.gz')\n",
    "pred_df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "59281635",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2000, 250, 128)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a numpy array of Data\n",
    "data_array_pred = np.stack(pred_df['Data'])\n",
    "data_array_pred.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "03cab5dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a datamodule for prediction\n",
    "\n",
    "class DataModulePredict(pl.LightningDataModule):\n",
    "    def __init__(self, batch_size=256):\n",
    "        super().__init__()\n",
    "        self.batch_size = batch_size\n",
    "\n",
    "    def setup(self, stage: str):\n",
    "        self.predict = torch.from_numpy(data_array_pred).float() \n",
    "\n",
    "    def predict_dataloader(self):\n",
    "        return DataLoader(self.predict, batch_size=self.batch_size, shuffle=False, num_workers=NUM_WORKERS)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "f9cfb81d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d70eeaafc12f40e5a19285d0d75dfe58",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Predicting: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run the predictions on the data using the loaded model and loaded trainer\n",
    "preds = loaded_trainer.predict(loaded_model, datamodule=DataModulePredict())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "59948557",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1745,    1,  676,  344,    4, 1248, 1593,    7,  819,  757,   10,   11,\n",
       "        1394,   13,   14,   15, 1548,   17,   18,   19,   20,   21,   22,   23,\n",
       "          24,   25,   26,   27,  918,   29,  740, 1428,  220,   33, 1450,   57,\n",
       "          36,   37,   38,   39,   40,   41,   42,   43,  815,   45,   46, 1668,\n",
       "          48,   49,  122,   51,   52,   53,   54, 1654, 1062,   57,   58,   59,\n",
       "         198,   61, 1273,   63, 1985,   65,   66,   67,   68, 1232,   70, 1285,\n",
       "          72,  171,   74,   75,   76,   77,   65, 1118,   80,   81,   82,   83,\n",
       "          84,  837,   86,   87,   88, 1091,  280, 1111, 1315,   93,  965,  628,\n",
       "          96,   97,   98,   99,  100,  101,  102, 1917,  104,  105,  106,  107,\n",
       "         108,  109,  110,   93, 1385,  113,  903,  115,   65,  117,  118,  119,\n",
       "         120, 1154,  122,  724,  124, 1024, 1535,  127,  128,  129,  130, 1536,\n",
       "         132,  216,  134,  135,  963,  324, 1560,  139,  140, 1069, 1783,  289,\n",
       "         144,  324,  146, 1971,  951,  149,  999,  151,  274,  153,  954,   65,\n",
       "         156,  157,  650,  159,  315, 1664,  162,  163, 1232,  808,  166,  167,\n",
       "        1431,  433,  170,  171,   39, 1292,  174,  175,  176, 1428, 1711,  628,\n",
       "         180, 1826,  182,  183,  866,  461,  186,  187,  753,  189,  190,  191,\n",
       "         192,  107,  194,  176, 1393,  197,  198,  199,  283,  201,  202, 1664,\n",
       "        1409,  205,  206,  207, 1154,  209,  210, 1460, 1095,  213,  214,  215,\n",
       "         216,  216,  961,  676,  220,  221,  803,  223,  224,  225,  226,  227,\n",
       "         228,  229,  230,  331,  232,  233,  234, 1890, 1381, 1248,  238, 1666,\n",
       "         240,  241,  242,  387, 1851,  728,  246,  247,  248, 1778,  250,  251,\n",
       "        1986, 1004,  254,  628])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predictions are logits. Use argmax to find the actual label\n",
    "# For eg for the first batch of predictions:\n",
    "\n",
    "preds[0].argmax(dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "cf309a85",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.6094)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can also find the accuracy in this new data\n",
    "# For the first batch it is like \n",
    "preds_, targets = preds[0].argmax(dim=1), np.stack(pred_df['Label'])[:256]\n",
    "\n",
    "\n",
    "accuracy = Accuracy(task=\"multiclass\", num_classes=NUM_CLASSES)\n",
    "accuracy(preds_, torch.from_numpy(targets))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2dfe70a7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7238129c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}