pytorch_ipynb/cnn/cnn-basic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Accompanying code examples of the book \"Introduction to Artificial Neural Networks and Deep Learning: A Practical Guide with Applications in Python\" by [Sebastian Raschka](https://sebastianraschka.com). All code examples are released under the [MIT license](https://github.com/rasbt/deep-learning-book/blob/master/LICENSE). If you find this content useful, please consider supporting the work by buying a [copy of the book](https://leanpub.com/ann-and-deeplearning).*\n",
    "  \n",
    "Other code examples and content are available on [GitHub](https://github.com/rasbt/deep-learning-book). The PDF and ebook versions of the book are available through [Leanpub](https://leanpub.com/ann-and-deeplearning)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sebastian Raschka \n",
      "\n",
      "CPython 3.6.8\n",
      "IPython 7.2.0\n",
      "\n",
      "torch 1.0.0\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -a 'Sebastian Raschka' -v -p torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Runs on CPU or GPU (if available)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Zoo -- Convolutional Neural Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    torch.backends.cudnn.deterministic = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Settings and Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image batch dimensions: torch.Size([128, 1, 28, 28])\n",
      "Image label dimensions: torch.Size([128])\n"
     ]
    }
   ],
   "source": [
    "##########################\n",
    "### SETTINGS\n",
    "##########################\n",
    "\n",
    "# Device\n",
    "device = torch.device(\"cuda:3\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Hyperparameters\n",
    "random_seed = 1\n",
    "learning_rate = 0.05\n",
    "num_epochs = 10\n",
    "batch_size = 128\n",
    "\n",
    "# Architecture\n",
    "num_classes = 10\n",
    "\n",
    "\n",
    "##########################\n",
    "### MNIST DATASET\n",
    "##########################\n",
    "\n",
    "# Note transforms.ToTensor() scales input images\n",
    "# to 0-1 range\n",
    "train_dataset = datasets.MNIST(root='data', \n",
    "                               train=True, \n",
    "                               transform=transforms.ToTensor(),\n",
    "                               download=True)\n",
    "\n",
    "test_dataset = datasets.MNIST(root='data', \n",
    "                              train=False, \n",
    "                              transform=transforms.ToTensor())\n",
    "\n",
    "\n",
    "train_loader = DataLoader(dataset=train_dataset, \n",
    "                          batch_size=batch_size, \n",
    "                          shuffle=True)\n",
    "\n",
    "test_loader = DataLoader(dataset=test_dataset, \n",
    "                         batch_size=batch_size, \n",
    "                         shuffle=False)\n",
    "\n",
    "# Checking the dataset\n",
    "for images, labels in train_loader:  \n",
    "    print('Image batch dimensions:', images.shape)\n",
    "    print('Image label dimensions:', labels.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "##########################\n",
    "### MODEL\n",
    "##########################\n",
    "\n",
    "\n",
    "class ConvNet(torch.nn.Module):\n",
    "\n",
    "    def __init__(self, num_classes):\n",
    "        super(ConvNet, self).__init__()\n",
    "        \n",
    "        # calculate same padding:\n",
    "        # (w - k + 2*p)/s + 1 = o\n",
    "        # => p = (s(o-1) - w + k)/2\n",
    "        \n",
    "        # 28x28x1 => 28x28x4\n",
    "        self.conv_1 = torch.nn.Conv2d(in_channels=1,\n",
    "                                      out_channels=4,\n",
    "                                      kernel_size=(3, 3),\n",
    "                                      stride=(1, 1),\n",
    "                                      padding=1) # (1(28-1) - 28 + 3) / 2 = 1\n",
    "        # 28x28x4 => 14x14x4\n",
    "        self.pool_1 = torch.nn.MaxPool2d(kernel_size=(2, 2),\n",
    "                                         stride=(2, 2),\n",
    "                                         padding=0) # (2(14-1) - 28 + 2) = 0                                       \n",
    "        # 14x14x4 => 14x14x8\n",
    "        self.conv_2 = torch.nn.Conv2d(in_channels=4,\n",
    "                                      out_channels=8,\n",
    "                                      kernel_size=(3, 3),\n",
    "                                      stride=(1, 1),\n",
    "                                      padding=1) # (1(14-1) - 14 + 3) / 2 = 1                 \n",
    "        # 14x14x8 => 7x7x8                             \n",
    "        self.pool_2 = torch.nn.MaxPool2d(kernel_size=(2, 2),\n",
    "                                         stride=(2, 2),\n",
    "                                         padding=0) # (2(7-1) - 14 + 2) = 0\n",
    "        \n",
    "        self.linear_1 = torch.nn.Linear(7*7*8, num_classes)\n",
    "\n",
    "        \n",
    "    def forward(self, x):\n",
    "        out = self.conv_1(x)\n",
    "        out = F.relu(out)\n",
    "        out = self.pool_1(out)\n",
    "\n",
    "        out = self.conv_2(out)\n",
    "        out = F.relu(out)\n",
    "        out = self.pool_2(out)\n",
    "        \n",
    "        logits = self.linear_1(out.view(-1, 7*7*8))\n",
    "        probas = F.softmax(logits, dim=1)\n",
    "        return logits, probas\n",
    "\n",
    "    \n",
    "torch.manual_seed(random_seed)\n",
    "model = ConvNet(num_classes=num_classes)\n",
    "\n",
    "model = model.to(device)\n",
    "\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 001/010 | Batch 000/469 | Cost: 2.3016\n",
      "Epoch: 001/010 | Batch 050/469 | Cost: 2.2714\n",
      "Epoch: 001/010 | Batch 100/469 | Cost: 1.6118\n",
      "Epoch: 001/010 | Batch 150/469 | Cost: 0.7966\n",
      "Epoch: 001/010 | Batch 200/469 | Cost: 0.5077\n",
      "Epoch: 001/010 | Batch 250/469 | Cost: 0.3221\n",
      "Epoch: 001/010 | Batch 300/469 | Cost: 0.2850\n",
      "Epoch: 001/010 | Batch 350/469 | Cost: 0.3116\n",
      "Epoch: 001/010 | Batch 400/469 | Cost: 0.2836\n",
      "Epoch: 001/010 | Batch 450/469 | Cost: 0.3169\n",
      "Epoch: 001/010 training accuracy: 92.72%\n",
      "Time elapsed: 0.21 min\n",
      "Epoch: 002/010 | Batch 000/469 | Cost: 0.2469\n",
      "Epoch: 002/010 | Batch 050/469 | Cost: 0.2342\n",
      "Epoch: 002/010 | Batch 100/469 | Cost: 0.2883\n",
      "Epoch: 002/010 | Batch 150/469 | Cost: 0.2920\n",
      "Epoch: 002/010 | Batch 200/469 | Cost: 0.1798\n",
      "Epoch: 002/010 | Batch 250/469 | Cost: 0.2277\n",
      "Epoch: 002/010 | Batch 300/469 | Cost: 0.1747\n",
      "Epoch: 002/010 | Batch 350/469 | Cost: 0.2430\n",
      "Epoch: 002/010 | Batch 400/469 | Cost: 0.1578\n",
      "Epoch: 002/010 | Batch 450/469 | Cost: 0.1279\n",
      "Epoch: 002/010 training accuracy: 95.07%\n",
      "Time elapsed: 0.41 min\n",
      "Epoch: 003/010 | Batch 000/469 | Cost: 0.1223\n",
      "Epoch: 003/010 | Batch 050/469 | Cost: 0.1999\n",
      "Epoch: 003/010 | Batch 100/469 | Cost: 0.2212\n",
      "Epoch: 003/010 | Batch 150/469 | Cost: 0.0905\n",
      "Epoch: 003/010 | Batch 200/469 | Cost: 0.1502\n",
      "Epoch: 003/010 | Batch 250/469 | Cost: 0.2391\n",
      "Epoch: 003/010 | Batch 300/469 | Cost: 0.1108\n",
      "Epoch: 003/010 | Batch 350/469 | Cost: 0.1734\n",
      "Epoch: 003/010 | Batch 400/469 | Cost: 0.1426\n",
      "Epoch: 003/010 | Batch 450/469 | Cost: 0.1253\n",
      "Epoch: 003/010 training accuracy: 96.21%\n",
      "Time elapsed: 0.62 min\n",
      "Epoch: 004/010 | Batch 000/469 | Cost: 0.1368\n",
      "Epoch: 004/010 | Batch 050/469 | Cost: 0.1984\n",
      "Epoch: 004/010 | Batch 100/469 | Cost: 0.1296\n",
      "Epoch: 004/010 | Batch 150/469 | Cost: 0.1439\n",
      "Epoch: 004/010 | Batch 200/469 | Cost: 0.1141\n",
      "Epoch: 004/010 | Batch 250/469 | Cost: 0.0566\n",
      "Epoch: 004/010 | Batch 300/469 | Cost: 0.1119\n",
      "Epoch: 004/010 | Batch 350/469 | Cost: 0.1777\n",
      "Epoch: 004/010 | Batch 400/469 | Cost: 0.2209\n",
      "Epoch: 004/010 | Batch 450/469 | Cost: 0.1390\n",
      "Epoch: 004/010 training accuracy: 96.77%\n",
      "Time elapsed: 0.82 min\n",
      "Epoch: 005/010 | Batch 000/469 | Cost: 0.1305\n",
      "Epoch: 005/010 | Batch 050/469 | Cost: 0.0445\n",
      "Epoch: 005/010 | Batch 100/469 | Cost: 0.1327\n",
      "Epoch: 005/010 | Batch 150/469 | Cost: 0.0846\n",
      "Epoch: 005/010 | Batch 200/469 | Cost: 0.0760\n",
      "Epoch: 005/010 | Batch 250/469 | Cost: 0.0795\n",
      "Epoch: 005/010 | Batch 300/469 | Cost: 0.1364\n",
      "Epoch: 005/010 | Batch 350/469 | Cost: 0.1419\n",
      "Epoch: 005/010 | Batch 400/469 | Cost: 0.0903\n",
      "Epoch: 005/010 | Batch 450/469 | Cost: 0.0599\n",
      "Epoch: 005/010 training accuracy: 97.15%\n",
      "Time elapsed: 1.03 min\n",
      "Epoch: 006/010 | Batch 000/469 | Cost: 0.0721\n",
      "Epoch: 006/010 | Batch 050/469 | Cost: 0.0481\n",
      "Epoch: 006/010 | Batch 100/469 | Cost: 0.0386\n",
      "Epoch: 006/010 | Batch 150/469 | Cost: 0.0421\n",
      "Epoch: 006/010 | Batch 200/469 | Cost: 0.1176\n",
      "Epoch: 006/010 | Batch 250/469 | Cost: 0.0719\n",
      "Epoch: 006/010 | Batch 300/469 | Cost: 0.0534\n",
      "Epoch: 006/010 | Batch 350/469 | Cost: 0.0230\n",
      "Epoch: 006/010 | Batch 400/469 | Cost: 0.0941\n",
      "Epoch: 006/010 | Batch 450/469 | Cost: 0.0848\n",
      "Epoch: 006/010 training accuracy: 97.43%\n",
      "Time elapsed: 1.23 min\n",
      "Epoch: 007/010 | Batch 000/469 | Cost: 0.1986\n",
      "Epoch: 007/010 | Batch 050/469 | Cost: 0.0445\n",
      "Epoch: 007/010 | Batch 100/469 | Cost: 0.0524\n",
      "Epoch: 007/010 | Batch 150/469 | Cost: 0.0639\n",
      "Epoch: 007/010 | Batch 200/469 | Cost: 0.0667\n",
      "Epoch: 007/010 | Batch 250/469 | Cost: 0.0952\n",
      "Epoch: 007/010 | Batch 300/469 | Cost: 0.0294\n",
      "Epoch: 007/010 | Batch 350/469 | Cost: 0.0974\n",
      "Epoch: 007/010 | Batch 400/469 | Cost: 0.1130\n",
      "Epoch: 007/010 | Batch 450/469 | Cost: 0.0552\n",
      "Epoch: 007/010 training accuracy: 97.77%\n",
      "Time elapsed: 1.43 min\n",
      "Epoch: 008/010 | Batch 000/469 | Cost: 0.1190\n",
      "Epoch: 008/010 | Batch 050/469 | Cost: 0.1556\n",
      "Epoch: 008/010 | Batch 100/469 | Cost: 0.0912\n",
      "Epoch: 008/010 | Batch 150/469 | Cost: 0.0401\n",
      "Epoch: 008/010 | Batch 200/469 | Cost: 0.0832\n",
      "Epoch: 008/010 | Batch 250/469 | Cost: 0.0418\n",
      "Epoch: 008/010 | Batch 300/469 | Cost: 0.0886\n",
      "Epoch: 008/010 | Batch 350/469 | Cost: 0.0844\n",
      "Epoch: 008/010 | Batch 400/469 | Cost: 0.0673\n",
      "Epoch: 008/010 | Batch 450/469 | Cost: 0.1391\n",
      "Epoch: 008/010 training accuracy: 97.55%\n",
      "Time elapsed: 1.64 min\n",
      "Epoch: 009/010 | Batch 000/469 | Cost: 0.0826\n",
      "Epoch: 009/010 | Batch 050/469 | Cost: 0.1026\n",
      "Epoch: 009/010 | Batch 100/469 | Cost: 0.1812\n",
      "Epoch: 009/010 | Batch 150/469 | Cost: 0.0658\n",
      "Epoch: 009/010 | Batch 200/469 | Cost: 0.0883\n",
      "Epoch: 009/010 | Batch 250/469 | Cost: 0.1577\n",
      "Epoch: 009/010 | Batch 300/469 | Cost: 0.0479\n",
      "Epoch: 009/010 | Batch 350/469 | Cost: 0.0779\n",
      "Epoch: 009/010 | Batch 400/469 | Cost: 0.0407\n",
      "Epoch: 009/010 | Batch 450/469 | Cost: 0.0236\n",
      "Epoch: 009/010 training accuracy: 97.82%\n",
      "Time elapsed: 1.84 min\n",
      "Epoch: 010/010 | Batch 000/469 | Cost: 0.0183\n",
      "Epoch: 010/010 | Batch 050/469 | Cost: 0.0740\n",
      "Epoch: 010/010 | Batch 100/469 | Cost: 0.0425\n",
      "Epoch: 010/010 | Batch 150/469 | Cost: 0.0332\n",
      "Epoch: 010/010 | Batch 200/469 | Cost: 0.0795\n",
      "Epoch: 010/010 | Batch 250/469 | Cost: 0.0568\n",
      "Epoch: 010/010 | Batch 300/469 | Cost: 0.1070\n",
      "Epoch: 010/010 | Batch 350/469 | Cost: 0.1660\n",
      "Epoch: 010/010 | Batch 400/469 | Cost: 0.0204\n",
      "Epoch: 010/010 | Batch 450/469 | Cost: 0.0613\n",
      "Epoch: 010/010 training accuracy: 97.77%\n",
      "Time elapsed: 2.04 min\n",
      "Total Training Time: 2.04 min\n"
     ]
    }
   ],
   "source": [
    "def compute_accuracy(model, data_loader):\n",
    "    correct_pred, num_examples = 0, 0\n",
    "    for features, targets in data_loader:\n",
    "        features = features.to(device)\n",
    "        targets = targets.to(device)\n",
    "        logits, probas = model(features)\n",
    "        _, predicted_labels = torch.max(probas, 1)\n",
    "        num_examples += targets.size(0)\n",
    "        correct_pred += (predicted_labels == targets).sum()\n",
    "    return correct_pred.float()/num_examples * 100\n",
    "    \n",
    "\n",
    "start_time = time.time()    \n",
    "for epoch in range(num_epochs):\n",
    "    model = model.train()\n",
    "    for batch_idx, (features, targets) in enumerate(train_loader):\n",
    "        \n",
    "        features = features.to(device)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        ### FORWARD AND BACK PROP\n",
    "        logits, probas = model(features)\n",
    "        cost = F.cross_entropy(logits, targets)\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        cost.backward()\n",
    "        \n",
    "        ### UPDATE MODEL PARAMETERS\n",
    "        optimizer.step()\n",
    "        \n",
    "        ### LOGGING\n",
    "        if not batch_idx % 50:\n",
    "            print ('Epoch: %03d/%03d | Batch %03d/%03d | Cost: %.4f' \n",
    "                   %(epoch+1, num_epochs, batch_idx, \n",
    "                     len(train_loader), cost))\n",
    "    \n",
    "    model = model.eval()\n",
    "    print('Epoch: %03d/%03d training accuracy: %.2f%%' % (\n",
    "          epoch+1, num_epochs, \n",
    "          compute_accuracy(model, train_loader)))\n",
    "\n",
    "    print('Time elapsed: %.2f min' % ((time.time() - start_time)/60))\n",
    "    \n",
    "print('Total Training Time: %.2f min' % ((time.time() - start_time)/60))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 97.77%\n"
     ]
    }
   ],
   "source": [
    "with torch.set_grad_enabled(False): # save memory during inference\n",
    "    print('Test accuracy: %.2f%%' % (compute_accuracy(model, test_loader)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numpy       1.15.4\n",
      "torch       1.0.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%watermark -iv"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}