appr_retr/appr_retr_transformer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Moving Circles Transformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pickle\n",
    "import time\n",
    "from matplotlib import pyplot as plt\n",
    "import gc\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "#device = \"cpu\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Transformer(nn.Module):\n",
    "    def __init__(self, n_input, n_output, seq_len, n_head, dim_ff, num_layers, position_encoding):\n",
    "        super().__init__()\n",
    "\n",
    "        self.n_input = n_input\n",
    "        self.n_output = n_output\n",
    "        self.n_head = n_head\n",
    "        self.dim_ff = dim_ff\n",
    "        self.num_layers = num_layers\n",
    "        self.position_encoding = position_encoding\n",
    "        self.seq_len = seq_len\n",
    "\n",
    "        self.transformerlayer = nn.TransformerEncoderLayer(n_input, n_head, dim_feedforward=dim_ff, batch_first=True)\n",
    "        self.transformer_encoder = nn.TransformerEncoder(self.transformerlayer, num_layers)\n",
    "        self.fc = nn.Linear(n_input, n_output)\n",
    "\n",
    "    def position_encode(self):\n",
    "        pe = torch.zeros(self.seq_len, self.n_input).to(device)\n",
    "        pos = torch.arange(0, self.seq_len, dtype=torch.float).unsqueeze(1)\n",
    "        div_term = torch.exp(torch.arange(0, self.n_input, 2).float() * (-np.log(10000.0) / self.n_input))\n",
    "\n",
    "        pe[:, 0::2] = torch.sin(pos * div_term)\n",
    "        pe[:, 1::2] = torch.cos(pos * div_term)\n",
    "        pe = pe.unsqueeze(0)\n",
    "        return pe\n",
    "    \n",
    "    def forward(self, X):\n",
    "        x = X.to(device)\n",
    "        if self.position_encoding:\n",
    "            pe = self.position_encode()\n",
    "            pe = pe.expand(X.size(0), -1, -1)\n",
    "            x = X + pe\n",
    "        y = self.transformer_encoder(x)\n",
    "        y = self.fc(y)\n",
    "        return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformerModel:\n",
    "    def __init__(self, lstm, loss_fn, optimizer, seq_len, n_output, model_name=\"transformer\"):\n",
    "        self.model = lstm\n",
    "        self.loss_fn = loss_fn\n",
    "        self.optim = optimizer\n",
    "        self.seq_len = seq_len\n",
    "        self.n_output = n_output\n",
    "        self.model_name = model_name\n",
    "\n",
    "    def train(self, train_loader, n_epochs=10, learning=1e-2):\n",
    "        train_loss = []\n",
    "        best_loss = 1e10\n",
    "\n",
    "        self.model.train()\n",
    "        \n",
    "        for i in range(n_epochs):\n",
    "            start = time.time()\n",
    "            avg_loss = 0.\n",
    "            for X, y in train_loader:\n",
    "                loss = 0.\n",
    "                curr_batch_size = X.shape[0]\n",
    "\n",
    "                X, y = X.to(device), y.to(device)\n",
    "                self.optim.zero_grad()\n",
    "\n",
    "                output = self.model(X)\n",
    "\n",
    "                output = torch.transpose(output, 1, 2)\n",
    "                y = torch.transpose(y, 1, 2)\n",
    "\n",
    "                loss += self.loss_fn(output, y)\n",
    "                \n",
    "                loss.backward()\n",
    "                self.optim.step()\n",
    "                avg_loss += loss.item()\n",
    "\n",
    "            end = time.time()\n",
    "            epoch_mins, epoch_secs = self.epoch_time(start, end)\n",
    "            if best_loss > avg_loss:\n",
    "                best_loss = avg_loss\n",
    "                torch.save({self.model_name: self.model.state_dict(), self.model_name+\"_optimizer\": self.optim.state_dict()}, self.model_name+'-model.pt')\n",
    "\n",
    "            train_loss.append(avg_loss)\n",
    "            \n",
    "            print(\"Epoch \" + str(i + 1) + \"/\" + str(n_epochs))\n",
    "            print(\"Time: \" + str(epoch_mins) + \" minutes \" + str(epoch_secs) + \" seconds\")\n",
    "            print(\"Training loss: \" + str(avg_loss))\n",
    "            print()\n",
    "\n",
    "        return train_loss\n",
    "    \n",
    "    def epoch_time(self, start_time, end_time):\n",
    "        elapsed = end_time - start_time\n",
    "        elapsed_mins = int(elapsed / 60)\n",
    "        elapsed_secs = int(elapsed - (elapsed_mins * 60))\n",
    "        return elapsed_mins, elapsed_secs\n",
    "\n",
    "    def find_lens(self, X):\n",
    "        X_lens = []\n",
    "        for batch in X:\n",
    "            count = 0\n",
    "            for time in batch:\n",
    "                if torch.count_nonzero(time) == 0:\n",
    "                    break\n",
    "                else:\n",
    "                    count += 1\n",
    "            X_lens.append(count)\n",
    "        return X_lens\n",
    "\n",
    "    def eval(self, test_loader):\n",
    "        check = torch.load(self.model_name+\"-model.pt\")\n",
    "        self.model.load_state_dict(check[self.model_name])\n",
    "\n",
    "        confusion = np.zeros((self.n_output, self.n_output))\n",
    "\n",
    "        gc.collect()\n",
    "        torch.cuda.empty_cache()\n",
    "\n",
    "        with torch.no_grad():\n",
    "            correct = np.zeros(self.seq_len)\n",
    "            total = np.zeros(self.seq_len)\n",
    "            test_loss = 0.\n",
    "            self.model.eval()\n",
    "\n",
    "            for x, y in test_loader:\n",
    "                curr_batch_size = x.shape[0]\n",
    "                X, Y = x.to(device), y.to(device)\n",
    "\n",
    "                output = self.model(X)\n",
    "\n",
    "                X_lens = self.find_lens(X)\n",
    "\n",
    "                top_value, top_index = output.topk(1)\n",
    "                out = torch.zeros(curr_batch_size, self.seq_len, self.n_output).to(device)\n",
    "                for clip in range(curr_batch_size):\n",
    "                    for k in range(self.seq_len):\n",
    "                        out[clip][k][top_index[clip][k].item()] = 1\n",
    "\n",
    "                output = torch.transpose(output, 1, 2)\n",
    "                y_hat = torch.transpose(y, 1, 2).to(device)\n",
    "                test_loss += self.loss_fn(output, y_hat).item()\n",
    "                correct, total = accuracy(y.cpu().numpy(), out.cpu().numpy(), correct, total)\n",
    "\n",
    "                true, pred = devector(y.cpu().numpy(), out.cpu().numpy())\n",
    "\n",
    "                confusion += confusion_matrix(true, pred)\n",
    "        \n",
    "        ff_accuracy = correct / total\n",
    "        return ff_accuracy, confusion\n",
    "    \n",
    "    \n",
    "    def random_samples(self, X, pad=0.):\n",
    "        X_random = []\n",
    "        X_lens = self.find_lens(X)\n",
    "        for i in range(X.shape[0]):\n",
    "            X_batch = np.random.normal(size=(X_lens[i], X.shape[-1]))\n",
    "            if X_lens[i] < self.seq_len:\n",
    "                X_pad = np.array([[pad]*X.shape[-1]]*(self.seq_len - X_lens[i]))\n",
    "                X_batch = np.append(X_batch, X_pad, axis=0)\n",
    "            X_random.append(X_batch)\n",
    "        X_random = np.array(X_random)\n",
    "        return X_random\n",
    "    \n",
    "    def rand_test(self, test_loader, n_samples=20, percentile=90):\n",
    "        rand_acc_array = []\n",
    "        for sample in range(n_samples):\n",
    "            correct = np.zeros(self.seq_len)\n",
    "            total = np.zeros(self.seq_len)\n",
    "            \n",
    "            self.model.eval()\n",
    "\n",
    "            with torch.no_grad():\n",
    "\n",
    "                for x, y in test_loader:\n",
    "                    loss = 0.\n",
    "                    curr_batch_size = x.shape[0]\n",
    "                    X_random = torch.from_numpy(self.random_samples(x)).float().to(device)\n",
    "                    y = y.to(device)\n",
    "\n",
    "                    X_lens = self.find_lens(x)\n",
    "                    output = self.model(X_random)\n",
    "                    top_value, top_index = output.topk(1)\n",
    "                    out = torch.zeros(curr_batch_size, self.seq_len, self.n_output)\n",
    "                    for clip in range(curr_batch_size):\n",
    "                        for k in range(self.seq_len):\n",
    "                            out[clip][k][top_index[clip][k].item()] = 1\n",
    "\n",
    "                    output = torch.transpose(output, 1, 2)\n",
    "                    y_hat = torch.transpose(y, 1, 2).to(device)\n",
    "                    loss += self.loss_fn(output, y_hat).item()\n",
    "                    \n",
    "                    correct, total = accuracy(y.cpu().numpy(), out.cpu().numpy(), correct, total)\n",
    "\n",
    "                    \n",
    "            rand_acc = correct / total\n",
    "            rand_acc_array.append(rand_acc)\n",
    "        plot = np.percentile(np.sort(np.array(rand_acc_array), axis=0), percentile, axis=0)\n",
    "        return plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findIndex(val, arr):\n",
    "    index = -1\n",
    "    for x in range(arr.size):\n",
    "        if val == arr[x]:\n",
    "            index = x\n",
    "            break\n",
    "    return index\n",
    "\n",
    "def accuracy(target, prob, correct, tot):\n",
    "    for i in range(prob.shape[1]):\n",
    "        correctCount = correct[i]\n",
    "        totalCount = tot[i]\n",
    "        for j in range(prob.shape[0]):\n",
    "            if np.count_nonzero(target[j][i]) != 0:\n",
    "                if findIndex(1., target[j][i]) == findIndex(1., prob[j][i]):\n",
    "                    correctCount += 1\n",
    "                totalCount += 1\n",
    "        correct[i] = correctCount\n",
    "        tot[i] = totalCount\n",
    "    return correct, tot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vectorize(y, c=2):\n",
    "    new_y = np.zeros((y.shape[0], y.shape[1], c))\n",
    "    for batch in range(y.shape[0]):\n",
    "        for time in range(y.shape[1]):\n",
    "            cl = y[batch][time]\n",
    "            if cl < c:\n",
    "                new_y[batch][time][int(cl)] = 1.\n",
    "    return new_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def devector(true, pred):\n",
    "    new_y_true = []\n",
    "    new_y_pred = []\n",
    "    for batch in range(true.shape[0]):\n",
    "        for time in range(true.shape[1]):\n",
    "            if np.count_nonzero(true[batch][time]) != 0:\n",
    "                i = findIndex(1., true[batch][time])\n",
    "                new_y_true.append(i)\n",
    "                j = findIndex(1., pred[batch][time])\n",
    "                new_y_pred.append(j)\n",
    "    return np.array(new_y_true), np.array(new_y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(f\"appr_retr_timesegments.pkl\", 'rb') as f:\n",
    "    X_train, y_train, len_train, X_test, y_test, len_test = pickle.load(f)\n",
    "\n",
    "for batch, batch_len in enumerate(len_train):\n",
    "    y_train[batch, batch_len:] = np.array([2]*(y_train.shape[-1] - batch_len))\n",
    "\n",
    "for batch, batch_len in enumerate(len_test):\n",
    "    y_test[batch, batch_len:] = np.array([2]*(y_test.shape[-1] - batch_len))\n",
    "\n",
    "y_train = vectorize(y_train)\n",
    "y_test = vectorize(y_test)\n",
    "\n",
    "batch_size = 32\n",
    "\n",
    "train_data = TensorDataset(torch.from_numpy(X_train).float(), torch.from_numpy(y_train).float())\n",
    "train_loader = DataLoader(train_data, shuffle=True, batch_size=batch_size)\n",
    "test_data = TensorDataset(torch.from_numpy(X_test).float(), torch.from_numpy(y_test).float())\n",
    "test_loader = DataLoader(test_data, shuffle=True, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_input = 300\n",
    "n_hidden = 32\n",
    "seq_len = 129\n",
    "learning_rate = 5e-4\n",
    "EPOCHS = 100\n",
    "num_head=4\n",
    "num_layers=1\n",
    "n_class = 2\n",
    "\n",
    "transformer_multipos = Transformer(n_input, n_class, seq_len, num_head, n_hidden, num_layers, True).to(device)\n",
    "loss_fn_multipos = nn.CrossEntropyLoss()\n",
    "optimizer_multipos = optim.Adam(transformer_multipos.parameters(), lr=learning_rate)\n",
    "\n",
    "model_multipos = TransformerModel(transformer_multipos, loss_fn_multipos, optimizer_multipos, seq_len, n_class, \"transformer_multipos\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'train_loss_multipos' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\Anna\\Documents\\GitHub\\srp-lab-notebook\\appr_retr\\appr_retr_transformer.ipynb Cell 10\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Anna/Documents/GitHub/srp-lab-notebook/appr_retr/appr_retr_transformer.ipynb#X12sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m#train_loss_multipos = model_multipos.train(train_loader, n_epochs=EPOCHS, learning=learning_rate)\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Anna/Documents/GitHub/srp-lab-notebook/appr_retr/appr_retr_transformer.ipynb#X12sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m xAx \u001b[39m=\u001b[39m [i \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m1\u001b[39m, EPOCHS\u001b[39m+\u001b[39m\u001b[39m1\u001b[39m)]\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/Anna/Documents/GitHub/srp-lab-notebook/appr_retr/appr_retr_transformer.ipynb#X12sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m plt\u001b[39m.\u001b[39mplot(xAx, train_loss_multipos)\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Anna/Documents/GitHub/srp-lab-notebook/appr_retr/appr_retr_transformer.ipynb#X12sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m plt\u001b[39m.\u001b[39mxlabel(\u001b[39m\"\u001b[39m\u001b[39mEpoch\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Anna/Documents/GitHub/srp-lab-notebook/appr_retr/appr_retr_transformer.ipynb#X12sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m plt\u001b[39m.\u001b[39mylabel(\u001b[39m\"\u001b[39m\u001b[39mCross Entropy Loss\u001b[39m\u001b[39m\"\u001b[39m)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'train_loss_multipos' is not defined"
     ]
    }
   ],
   "source": [
    "#train_loss_multipos = model_multipos.train(train_loader, n_epochs=EPOCHS, learning=learning_rate)\n",
    "\n",
    "xAx = [i for i in range(1, EPOCHS+1)]\n",
    "plt.plot(xAx, train_loss_multipos)\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Cross Entropy Loss\")\n",
    "plt.xlim(0, EPOCHS)\n",
    "plt.xticks([j*20 for j in range(EPOCHS // 20 + 1)])\n",
    "plt.title(\"Training Loss\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformer_multipos_accuracy, confusion = model_multipos.eval(test_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stored 'transformer_multipos_accuracy' (ndarray)\n"
     ]
    }
   ],
   "source": [
    "%store transformer_multipos_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[46592.  5862.]\n",
      " [ 6218. 47295.]]\n"
     ]
    }
   ],
   "source": [
    "print(confusion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformer_multipos_rand_acc = model_multipos.rand_test(test_loader, n_samples=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xAx = [i for i in range(1,130)]\n",
    "plt.plot(xAx, transformer_multipos_accuracy, label=\"transformer-multi-pos\")\n",
    "plt.plot(xAx, transformer_multipos_rand_acc, label=\"random-multi-pos\")\n",
    "plt.xlabel(\"Time (s)\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.ylim(0,1)\n",
    "plt.xlim(0,130)\n",
    "plt.title(\"Time-varying Classification Accuracy\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 64-bit",
   "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.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "4f240839814783c86679b97dc90219b8a3d3e14ea65e88be68ce87d6dbf01a50"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}