coursera_deep_neural_network/7.4one_layer_neural_network_MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork/Template/module%201/images/IDSNlogo.png\" width=\"300\" alt=\"cognitiveclass.ai logo\"  />\n",
    "</center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Neural Networks with One Hidden Layer</h1>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Objective</h2><ul><li> How to classify handwritten digits using Neural Network.</li></ul> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Table of Contents</h2>\n",
    "<p>In this lab, you will use a single layer neural network to classify handwritten digits from the MNIST database.</p>\n",
    "\n",
    "<ul>\n",
    "    <li><a href=\"#Model\">Neural Network Module and Training Function</a></li>\n",
    "    <li><a href=\"#Makeup_Data\">Make Some Data</a></li>\n",
    "    <li><a href=\"#Train\">Define the Neural Network, Optimizer, and Train the  Model</a></li>\n",
    "    <li><a href=\"#Result\">Analyze Results</a></li>\n",
    "</ul>\n",
    "<p>Estimated Time Needed: <strong>25 min</strong></p>\n",
    "\n",
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Preparation</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll need the following libraries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:07:43.235577Z",
     "start_time": "2021-07-15T10:07:43.229664Z"
    }
   },
   "outputs": [],
   "source": [
    "# Import the libraries we need for this lab\n",
    "\n",
    "# Using the following line code to install the torchvision library\n",
    "# !conda install -y torchvision\n",
    "\n",
    "import torch \n",
    "import torch.nn as nn\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.datasets as dsets\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pylab as plt\n",
    "import numpy as np\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the following helper functions for plotting the loss: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:07:45.486946Z",
     "start_time": "2021-07-15T10:07:45.476377Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define a function to plot accuracy and loss\n",
    "\n",
    "def plot_accuracy_loss(training_results): \n",
    "    plt.subplot(2, 1, 1)\n",
    "    plt.plot(training_results['training_loss'], 'r')\n",
    "    plt.ylabel('loss')\n",
    "    plt.title('training loss iterations')\n",
    "    plt.subplot(2, 1, 2)\n",
    "    plt.plot(training_results['validation_accuracy'])\n",
    "    plt.ylabel('accuracy')\n",
    "    plt.xlabel('epochs')   \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the following function for printing the model parameters: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:07:46.382792Z",
     "start_time": "2021-07-15T10:07:46.379156Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define a function to plot model parameters\n",
    "\n",
    "def print_model_parameters(model):\n",
    "    count = 0\n",
    "    for ele in model.state_dict():\n",
    "        count += 1\n",
    "        if count % 2 != 0:\n",
    "            print (\"The following are the parameters for the layer \", count // 2 + 1)\n",
    "        if ele.find(\"bias\") != -1:\n",
    "            print(\"The size of bias: \", model.state_dict()[ele].size())\n",
    "        else:\n",
    "            print(\"The size of weights: \", model.state_dict()[ele].size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the neural network module or class: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:08:06.136921Z",
     "start_time": "2021-07-15T10:08:06.131340Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define a function to display data\n",
    "\n",
    "def show_data(data_sample):\n",
    "    plt.imshow(data_sample.numpy().reshape(28, 28), cmap='gray')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Model\">Neural Network Module and Training Function</h2> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the neural network module or class: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:08:10.772373Z",
     "start_time": "2021-07-15T10:08:10.769244Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define a Neural Network class\n",
    "\n",
    "class Net(nn.Module):\n",
    "    \n",
    "    # Constructor\n",
    "    def __init__(self, D_in, H, D_out):\n",
    "        super(Net, self).__init__()\n",
    "        self.linear1 = nn.Linear(D_in, H)\n",
    "        self.linear2 = nn.Linear(H, D_out)\n",
    "\n",
    "    # Prediction    \n",
    "    def forward(self, x):\n",
    "        x = torch.sigmoid(self.linear1(x))  \n",
    "        x = self.linear2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function to train the model. In this case, the function returns a Python dictionary to store the training loss and accuracy on the validation data. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:08:20.203193Z",
     "start_time": "2021-07-15T10:08:20.189909Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define a training function to train the model\n",
    "\n",
    "def train(model, criterion, train_loader, validation_loader, optimizer, epochs=100):\n",
    "    i = 0\n",
    "    useful_stuff = {'training_loss': [],'validation_accuracy': []}  \n",
    "    for epoch in tqdm(range(epochs)):\n",
    "        for i, (x, y) in enumerate(train_loader): \n",
    "            optimizer.zero_grad()\n",
    "            z = model(x.view(-1, 28 * 28))\n",
    "            loss = criterion(z, y)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "             #loss for every iteration\n",
    "            useful_stuff['training_loss'].append(loss.data.item())\n",
    "        correct = 0\n",
    "        for x, y in validation_loader:\n",
    "            #validation \n",
    "            z = model(x.view(-1, 28 * 28))\n",
    "            _, label = torch.max(z, 1)\n",
    "            correct += (label == y).sum().item()\n",
    "        accuracy = 100 * (correct / len(validation_dataset))\n",
    "        useful_stuff['validation_accuracy'].append(accuracy)\n",
    "    return useful_stuff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Makeup_Data\">Make Some Data</h2> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the training dataset by setting the parameters <code>train</code> to <code>True</code> and convert it to a tensor by placing a transform object in the argument <code>transform</code>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:08:22.766989Z",
     "start_time": "2021-07-15T10:08:22.747149Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create training dataset\n",
    "\n",
    "train_dataset = dsets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the testing dataset and convert it to a tensor by placing a transform object in the argument <code>transform</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:08:23.682712Z",
     "start_time": "2021-07-15T10:08:23.658751Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create validating dataset\n",
    "\n",
    "validation_dataset = dsets.MNIST(root='./data', download=True, transform=transforms.ToTensor())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the criterion function:  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:08:24.553101Z",
     "start_time": "2021-07-15T10:08:24.547407Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create criterion function\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the training-data loader and the validation-data loader objects: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:08:27.449843Z",
     "start_time": "2021-07-15T10:08:27.444350Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create data loader for both train dataset and valdiate dataset\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=2000, shuffle=True)\n",
    "validation_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=5000, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Train\">Define the Neural Network, Optimizer, and Train the Model</h2> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the model with 100 neurons: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:08:28.799945Z",
     "start_time": "2021-07-15T10:08:28.794162Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create the model with 100 neurons\n",
    "\n",
    "input_dim = 28 * 28\n",
    "hidden_dim = 100\n",
    "output_dim = 10\n",
    "\n",
    "model = Net(input_dim, hidden_dim, output_dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print the model parameters: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:08:32.980396Z",
     "start_time": "2021-07-15T10:08:32.977186Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The following are the parameters for the layer  1\n",
      "The size of weights:  torch.Size([100, 784])\n",
      "The size of bias:  torch.Size([100])\n",
      "The following are the parameters for the layer  2\n",
      "The size of weights:  torch.Size([10, 100])\n",
      "The size of bias:  torch.Size([10])\n"
     ]
    }
   ],
   "source": [
    "# Print the parameters for model\n",
    "\n",
    "print_model_parameters(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the optimizer object with a learning rate of 0.01: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:08:36.096101Z",
     "start_time": "2021-07-15T10:08:36.090662Z"
    }
   },
   "outputs": [],
   "source": [
    "# Set the learning rate and the optimizer\n",
    "\n",
    "learning_rate = 0.01\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the model by using 100 epochs **(this process takes time)**: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:12:37.878471Z",
     "start_time": "2021-07-15T10:08:37.103914Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 30/30 [04:00<00:00,  8.03s/it]\n"
     ]
    }
   ],
   "source": [
    "# Train the model\n",
    "\n",
    "training_results = train(model, criterion, train_loader, validation_loader, optimizer, epochs=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Result\">Analyze Results</h2> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the training total loss or cost for every iteration and plot the training accuracy for every epoch:  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:12:54.469035Z",
     "start_time": "2021-07-15T10:12:54.305240Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the accuracy and loss\n",
    "\n",
    "plot_accuracy_loss(training_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the first five misclassified samples:   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T10:14:06.101968Z",
     "start_time": "2021-07-15T10:14:05.620608Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the first five misclassified samples\n",
    "\n",
    "count = 0\n",
    "for x, y in validation_dataset:\n",
    "    z = model(x.reshape(-1, 28 * 28))\n",
    "    _,yhat = torch.max(z, 1)\n",
    "    if yhat != y:\n",
    "        show_data(x)\n",
    "        count += 1\n",
    "    if count >= 5:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Practice</h3> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use <code>nn.Sequential</code> to build exactly the same model as you just built. Use the function <train>train</train> to train the model and use the function <code>plot_accuracy_loss</code> to see the metrics. Also, try different epoch numbers. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-15T11:17:07.450314Z",
     "start_time": "2021-07-15T11:15:50.642517Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10/10 [01:16<00:00,  7.66s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Practice: Use nn.Sequential to build the same model. Use plot_accuracy_loss to print out the accuarcy and loss\n",
    "\n",
    "# Type your code here\n",
    "\n",
    "input_dim = 28 * 28\n",
    "hidden_dim = 100\n",
    "output_dim = 10\n",
    "model2 = nn.Sequential(\n",
    "    nn.Linear(input_dim, hidden_dim),\n",
    "    nn.Sigmoid(),\n",
    "    nn.Linear(hidden_dim, output_dim)\n",
    ")\n",
    "learning_rate = 0.1\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr = learning_rate)\n",
    "training_results = train(model2, criterion, train_loader, validation_loader, optimizer, epochs=10)\n",
    "\n",
    "plot_accuracy_loss(training_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- \n",
    "input_dim = 28 * 28\n",
    "hidden_dim = 100\n",
    "output_dim = 10\n",
    "\n",
    "model = torch.nn.Sequential(\n",
    "    torch.nn.Linear(input_dim, hidden_dim),\n",
    "    torch.nn.Sigmoid(),\n",
    "    torch.nn.Linear(hidden_dim, output_dim),\n",
    ")\n",
    "learning_rate = 0.01\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr = learning_rate)\n",
    "training_results = train(model, criterion, train_loader, validation_loader, optimizer, epochs = 10)\n",
    "plot_accuracy_loss(training_results)\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://dataplatform.cloud.ibm.com/registration/stepone?context=cpdaas&apps=data_science_experience,watson_machine_learning\"><img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork/Template/module%201/images/Watson_Studio.png\"/></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>About the Authors:</h2> \n",
    "\n",
    "<a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\">Joseph Santarcangelo</a> has a PhD in Electrical Engineering, his research focused on using machine learning, signal processing, and computer vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other contributors: <a href=\"https://www.linkedin.com/in/michelleccarey/\">Michelle Carey</a>, <a href=\"www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change Log\n",
    "\n",
    "| Date (YYYY-MM-DD) | Version | Changed By | Change Description                                          |\n",
    "| ----------------- | ------- | ---------- | ----------------------------------------------------------- |\n",
    "| 2020-09-23        | 2.0     | Shubham    | Migrated Lab to Markdown and added to course repo in GitLab |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"
   ]
  }
 ],
 "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "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": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}