Pytorch/SelfNormalizingNetworks_MLP_MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Tutorial on self-normalizing networks on the MNIST data set: multi-layer perceptrons\n",
    "\n",
    "*Author:* Kajetan Schweighofer, 2021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "import os\n",
    "import copy\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader, Subset\n",
    "import torchvision\n",
    "from torchvision import transforms\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "# load data and preprocess\n",
    "\n",
    "path = os.path.join(\".\", \"dataset\", \"mnist\")\n",
    "os.makedirs(path, exist_ok=True)\n",
    "\n",
    "# convert PIL image to tensor and normalize\n",
    "transform = transform=transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.1307,), (0.3081,))\n",
    "])\n",
    "\n",
    "train = torchvision.datasets.MNIST(path, download=True, train=True, transform=transform)\n",
    "test = torchvision.datasets.MNIST(path, download=True, train=False, transform=transform)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Functions"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Model"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "class MLP(nn.Module):\n",
    "\n",
    "    def __init__(self, in_features: int, out_features: int, p_drop=0.2, use_selu: bool=False):\n",
    "        super(MLP, self).__init__()\n",
    "\n",
    "        activation = nn.SELU() if use_selu else nn.ReLU()\n",
    "        dropout = nn.AlphaDropout(p=p_drop) if use_selu else nn.Dropout(p=p_drop)\n",
    "\n",
    "        self.net = nn.Sequential(\n",
    "            nn.Flatten(),   # flatten input image from batchx1x28x28 to batchx784\n",
    "            nn.Linear(in_features=in_features, out_features=512),\n",
    "            activation,\n",
    "            dropout,\n",
    "            nn.Linear(in_features=512, out_features=256),\n",
    "            activation,\n",
    "            dropout,\n",
    "            nn.Linear(in_features=256, out_features=out_features)\n",
    "        )\n",
    "\n",
    "        if use_selu:\n",
    "            for param in self.net.parameters():\n",
    "                # biases zero\n",
    "                if len(param.shape) == 1:\n",
    "                    nn.init.constant_(param, 0)\n",
    "                # others using lecun-normal initialization\n",
    "                else:\n",
    "                    nn.init.kaiming_normal_(param, mode='fan_in', nonlinearity='linear')\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.net(x)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Accuracy metric"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "class Accuracy(nn.Module):\n",
    "\n",
    "    def forward(self, x, y):\n",
    "\n",
    "        y_pred = F.softmax(x, dim=1).argmax(dim=1).cpu().numpy()\n",
    "        y = y.cpu().numpy()\n",
    "\n",
    "        return accuracy_score(y_true=y, y_pred=y_pred)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Training / Evaluation methods"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "def _forward(network: nn.Module, data: DataLoader, metric: callable):\n",
    "\n",
    "    for x, y in data:\n",
    "        x = x.to(next(network.parameters()).device)\n",
    "\n",
    "        y_hat = network.forward(x).cpu()\n",
    "        loss = metric(y_hat, y)\n",
    "        yield loss\n",
    "\n",
    "@torch.enable_grad()\n",
    "def update(network: nn.Module, data: DataLoader, loss: nn.Module,\n",
    "           opt: torch.optim.Optimizer) -> list:\n",
    "\n",
    "    network.train()\n",
    "\n",
    "    errs = []\n",
    "    for err in _forward(network, data, loss):\n",
    "        errs.append(err.item())\n",
    "        opt.zero_grad()\n",
    "        try:\n",
    "            err.backward()\n",
    "            opt.step()\n",
    "        except:\n",
    "            print('error in update step')\n",
    "    return errs\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluate(network: nn.Module, data: DataLoader, metric: callable) -> float:\n",
    "\n",
    "    network.eval()\n",
    "\n",
    "    performance = []\n",
    "    for p in _forward(network, data, metric):\n",
    "        performance.append(p.item())\n",
    "    return np.mean(performance).item()\n",
    "\n",
    "\n",
    "def fit(network: nn.Module, trainloader: DataLoader, valloader: DataLoader,\n",
    "          testloader: DataLoader, epochs: int, lr: float):\n",
    "    optimizer = torch.optim.SGD(params=network.parameters(), lr=lr)\n",
    "    ce = nn.CrossEntropyLoss()\n",
    "    accuracy = Accuracy()\n",
    "\n",
    "    train_losses, val_losses, accuracies = [], [], []\n",
    "\n",
    "    # performance before training\n",
    "    val_losses.append(evaluate(network=network, data=valloader, metric=ce))\n",
    "\n",
    "    pbar = tqdm(range(epochs))\n",
    "    for ep in pbar:\n",
    "        # update network\n",
    "        tl = update(network=network, data=trainloader, loss=ce, opt=optimizer)\n",
    "        train_losses.extend(tl)\n",
    "        vl = evaluate(network=network, data=valloader, metric=ce)\n",
    "        val_losses.append(vl)\n",
    "        ac = evaluate(network=network, data=valloader, metric=accuracy)\n",
    "\n",
    "        if len(accuracies) == 0 or ac > max(accuracies):\n",
    "            # here we would store the model on disc for early stopping\n",
    "            best_model = copy.deepcopy(network)\n",
    "\n",
    "        accuracies.append(ac)\n",
    "\n",
    "        print(f\"train loss: {round(np.mean(tl), 4):.4f}, \"\n",
    "              f\"val loss: {round(vl, 4):.4f}, \"\n",
    "              f\"accuracy: {round(ac * 100, 2):.2f}%\")\n",
    "\n",
    "        pbar.set_description_str(desc=f\"Epoch {ep+1}\")\n",
    "\n",
    "    # evaluate on best model obtained throughout training\n",
    "    acc = evaluate(network=best_model, data=testloader, metric=accuracy)\n",
    "\n",
    "    print(f\"Final accuracy on testset: {round(acc*100, 2):.2f}%\")\n",
    "\n",
    "    return train_losses, val_losses, accuracies, acc"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Training\n",
    "\n",
    "### Hyperparameters"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "epochs = 20\n",
    "lr = 1e-3\n",
    "batch_size = 128\n",
    "num_workers = 4\n",
    "p_drop = 0.05"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Create Dataloaders"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "# obtain validation set (1/6 of train data to be equal to size of test data)\n",
    "rng = np.random.default_rng(seed=42)\n",
    "val_inds = rng.choice(np.arange(len(train)), size=len(train)//6, replace=False)\n",
    "train_inds = np.delete(np.arange(len(train)), val_inds)\n",
    "\n",
    "trainloader = DataLoader(Subset(train, indices=train_inds),\n",
    "                         batch_size=batch_size, drop_last=True, shuffle=True, num_workers=num_workers)\n",
    "valloader = DataLoader(Subset(train, indices=val_inds),\n",
    "                       batch_size=batch_size, drop_last=True, shuffle=True, num_workers=num_workers)\n",
    "testloader = DataLoader(test, batch_size=batch_size, drop_last=False, shuffle=False, num_workers=num_workers)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Train Networks"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 20/20 [04:17<00:00, 12.88s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: 2.2289, val loss: 2.1446, accuracy: 54.21%\n",
      "train loss: 2.0434, val loss: 1.9147, accuracy: 67.01%\n",
      "train loss: 1.7677, val loss: 1.5914, accuracy: 71.63%\n",
      "train loss: 1.4285, val loss: 1.2525, accuracy: 75.86%\n",
      "train loss: 1.1241, val loss: 0.9904, accuracy: 79.36%\n",
      "train loss: 0.9095, val loss: 0.8160, accuracy: 82.39%\n",
      "train loss: 0.7681, val loss: 0.7009, accuracy: 84.16%\n",
      "train loss: 0.6725, val loss: 0.6219, accuracy: 85.42%\n",
      "train loss: 0.6051, val loss: 0.5652, accuracy: 86.22%\n",
      "train loss: 0.5560, val loss: 0.5216, accuracy: 87.00%\n",
      "train loss: 0.5176, val loss: 0.4883, accuracy: 87.64%\n",
      "train loss: 0.4883, val loss: 0.4622, accuracy: 88.20%\n",
      "train loss: 0.4633, val loss: 0.4400, accuracy: 88.41%\n",
      "train loss: 0.4424, val loss: 0.4229, accuracy: 88.78%\n",
      "train loss: 0.4272, val loss: 0.4079, accuracy: 88.98%\n",
      "train loss: 0.4127, val loss: 0.3949, accuracy: 89.13%\n",
      "train loss: 0.4001, val loss: 0.3840, accuracy: 89.35%\n",
      "train loss: 0.3901, val loss: 0.3744, accuracy: 89.57%\n",
      "train loss: 0.3799, val loss: 0.3667, accuracy: 89.84%\n",
      "train loss: 0.3722, val loss: 0.3584, accuracy: 89.98%\n",
      "Final accuracy on testset: 90.76%\n"
     ]
    }
   ],
   "source": [
    "# ReLU training\n",
    "\n",
    "# 28x28 = 784 input images for 10 classes\n",
    "network = MLP(in_features=784, out_features=10, p_drop=p_drop, use_selu=False).to(device)\n",
    "rtl, rvl, raccs, racc = fit(network, trainloader, valloader, testloader, epochs, lr)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 20/20 [04:09<00:00, 12.48s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: 1.3306, val loss: 0.6669, accuracy: 80.90%\n",
      "train loss: 0.7245, val loss: 0.5074, accuracy: 85.03%\n",
      "train loss: 0.5906, val loss: 0.4466, accuracy: 86.72%\n",
      "train loss: 0.5260, val loss: 0.4126, accuracy: 87.70%\n",
      "train loss: 0.4874, val loss: 0.3906, accuracy: 88.40%\n",
      "train loss: 0.4577, val loss: 0.3744, accuracy: 88.74%\n",
      "train loss: 0.4374, val loss: 0.3625, accuracy: 89.11%\n",
      "train loss: 0.4202, val loss: 0.3527, accuracy: 89.34%\n",
      "train loss: 0.4073, val loss: 0.3451, accuracy: 89.52%\n",
      "train loss: 0.3966, val loss: 0.3377, accuracy: 89.89%\n",
      "train loss: 0.3869, val loss: 0.3317, accuracy: 90.16%\n",
      "train loss: 0.3763, val loss: 0.3260, accuracy: 90.22%\n",
      "train loss: 0.3694, val loss: 0.3220, accuracy: 90.33%\n",
      "train loss: 0.3649, val loss: 0.3173, accuracy: 90.56%\n",
      "train loss: 0.3575, val loss: 0.3130, accuracy: 90.66%\n",
      "train loss: 0.3485, val loss: 0.3080, accuracy: 90.85%\n",
      "train loss: 0.3480, val loss: 0.3054, accuracy: 90.95%\n",
      "train loss: 0.3404, val loss: 0.3021, accuracy: 91.06%\n",
      "train loss: 0.3368, val loss: 0.2993, accuracy: 91.14%\n",
      "train loss: 0.3339, val loss: 0.2957, accuracy: 91.24%\n",
      "Final accuracy on testset: 92.04%\n"
     ]
    }
   ],
   "source": [
    "# SELU training\n",
    "network = MLP(in_features=784, out_features=10, p_drop=p_drop, use_selu=True).to(device)\n",
    "stl, svl, saccs, sacc = fit(network, trainloader, valloader, testloader, epochs, lr)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Plot results"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(np.asarray(range(len(rtl))) / len(trainloader), rtl, alpha=0.4, label=\"ReLU train loss\")\n",
    "plt.plot(np.asarray(range(len(stl))) / len(trainloader), stl, alpha=0.4, label=\"SELU train loss\")\n",
    "plt.plot(range(len(rvl)), rvl, color=\"C0\", label=\"ReLU val loss\")\n",
    "plt.plot(range(len(svl)), svl, color=\"C1\", label=\"SELU val loss\")\n",
    "plt.title(\"Train and Validation loss over Epochs\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"CELoss\")\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(range(1, len(raccs)+1), [a*100 for a in raccs], label=\"ReLU val accuracy\")\n",
    "plt.hlines(y=racc*100, xmin=0, xmax=len(raccs), colors=\"C0\", linestyles=\"dashed\", label=\"ReLU test accuracy\")\n",
    "plt.plot(range(1, len(saccs)+1), [a*100 for a in saccs], label=\"SELU val accuracy\")\n",
    "plt.hlines(y=sacc*100, xmin=0, xmax=len(saccs), colors=\"C1\", linestyles=\"dashed\", label=\"SELU test accuracy\")\n",
    "plt.title(\"Validation Accuracy\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "pycharm-91bfdd0f",
   "language": "python",
   "display_name": "PyCharm (SNNs)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}