Basic-Neural-Network.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Dependencies\n",
    "import torch\n",
    "import numpy as np\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x10c7a0ed0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set Seed in Torch\n",
    "torch.manual_seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define NN Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Neural Network Class\n",
    "class BasicNN(nn.Module):\n",
    "    \n",
    "    # Initializer Function\n",
    "    def __init__(self, num_features, num_hidden, num_output):\n",
    "        super(BasicNN, self).__init__()\n",
    "        # Initialize input to hidden layer\n",
    "        self.hidden = torch.nn.Linear(num_features, num_hidden)\n",
    "        # Initilize hidden layer to output\n",
    "        self.output = torch.nn.Linear(num_hidden, num_output)\n",
    "        \n",
    "    # Forward Pass\n",
    "    def forward(self,x):\n",
    "        # Apply activation function to hidden layer\n",
    "        x = nn.functional.relu(self.hidden(x))\n",
    "        # Linear Output\n",
    "        x = self.output(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BasicNN(\n",
      "  (hidden): Linear(in_features=1, out_features=10, bias=True)\n",
      "  (output): Linear(in_features=10, out_features=1, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Initialize the model\n",
    "model1 = BasicNN(num_features=1, num_hidden=10, num_output=1)\n",
    "print(model1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential(\n",
      "  (0): Linear(in_features=1, out_features=10, bias=True)\n",
      "  (1): ReLU()\n",
      "  (2): Linear(in_features=10, out_features=1, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Other way of defining a model\n",
    "model2 = nn.Sequential(\n",
    "         nn.Linear(1,10),\n",
    "         nn.ReLU(),\n",
    "         nn.Linear(10,1))\n",
    "print(model2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Tensor, torch.Tensor)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generate some data\n",
    "\n",
    "# x.shape = (100, 1)\n",
    "X = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)\n",
    "\n",
    "# Noisy y data, shape=(100, 1)\n",
    "y = X.pow(2) + 0.2*torch.rand(X.size())\n",
    "\n",
    "# Convert \"x\" and \"y\" to torch tensor\n",
    "X, y = Variable(X, requires_grad=False), Variable(y, requires_grad=False)\n",
    "\n",
    "type(X), type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save NN Function\n",
    "def saveNN():\n",
    "    \n",
    "    # Define Model-1\n",
    "    model1 = nn.Sequential(\n",
    "             nn.Linear(1,10),\n",
    "             nn.ReLU(),\n",
    "             nn.Linear(10,1))\n",
    "    \n",
    "    # Define Optimizer\n",
    "    optimizer = torch.optim.SGD(model1.parameters(), lr=0.05)\n",
    "    \n",
    "    # Define Loss Function\n",
    "    loss_func = nn.MSELoss()\n",
    "    \n",
    "    # Train the Model\n",
    "    epochs = 100\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        # Predicted Output\n",
    "        y_hat = model1(X)\n",
    "        \n",
    "        # Loss\n",
    "        loss = loss_func(y_hat, y)\n",
    "        \n",
    "        # Clear the Gradients\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        # Back Propagation\n",
    "        loss.backward()\n",
    "        \n",
    "        # Optimize\n",
    "        optimizer.step()\n",
    "        \n",
    "        if epoch%10 == 0:\n",
    "            print(\"Epoch: {0}\\t Loss: {1}\".format(epoch,loss.data[0]))\n",
    "        \n",
    "    # Plot the Results\n",
    "    plt.figure(1, figsize=(20, 5))\n",
    "    plt.subplot(131)\n",
    "    plt.title('Model-1')\n",
    "    plt.scatter(X.data.numpy(), y.data.numpy(), color = \"red\")\n",
    "    plt.plot(X.data.numpy(), y_hat.data.numpy(), 'y-', lw=5)\n",
    "    \n",
    "    # Save the Trained Model\n",
    "    # 1. Save entire Neural Network\n",
    "    torch.save(model1, './saved_model/model_1.pkl')\n",
    "    print(\"\\nModel Saved at ./saved_model/model_1.pkl...\\n\")\n",
    "    \n",
    "    # 2. Save only the Parameters i.e Weights & Biases\n",
    "    torch.save(model1.state_dict(), './saved_model/model_1_params.pkl')\n",
    "    print(\"Model Parameters Saved at ./saved_model/model_1_params.pkl...\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Saved Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to restore the Saved Model into a New Model\n",
    "def restoreModel():\n",
    "    # Restore entire model-1 to a new model, model-2\n",
    "    model2 = torch.load('./saved_model/model_1.pkl')\n",
    "    y_pred = model2(X)\n",
    "\n",
    "    # Plot Saved Model Results\n",
    "    plt.figure(1, figsize=(20, 5))\n",
    "    plt.subplot(132)\n",
    "    plt.title('Model-2')\n",
    "    plt.scatter(X.data.numpy(), y.data.numpy(), color = \"red\")\n",
    "    plt.plot(X.data.numpy(), y_pred.data.numpy(), 'y-', lw=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Restore Model Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to Restore Model Parameters\n",
    "def restoreModelParams():\n",
    "    # Restore only the Parameters in saved model-1 to a new model, model-3\n",
    "    # Create the Model Architecture\n",
    "    model3 = torch.nn.Sequential(\n",
    "        torch.nn.Linear(1, 10),\n",
    "        torch.nn.ReLU(),\n",
    "        torch.nn.Linear(10, 1)\n",
    "    )\n",
    "    \n",
    "    # Copy model-1's Parameters into model-3\n",
    "    model3.load_state_dict(torch.load('./saved_model/model_1_params.pkl'))\n",
    "    y_pred = model3(X)\n",
    "    \n",
    "    # Plot Results from Loaded Model\n",
    "    plt.figure(1, figsize=(20, 5))\n",
    "    plt.subplot(133)\n",
    "    plt.title('Model-3')\n",
    "    plt.scatter(X.data.numpy(), y.data.numpy(), color = \"red\")\n",
    "    plt.plot(X.data.numpy(), y_pred.data.numpy(), 'y-', lw=5)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot the Models, model-1, model-2 and model-3 for Verification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0\t Loss: 0.9994783997535706\n",
      "Epoch: 10\t Loss: 0.10376431792974472\n",
      "Epoch: 20\t Loss: 0.10072514414787292\n",
      "Epoch: 30\t Loss: 0.09799028933048248\n",
      "Epoch: 40\t Loss: 0.09557335078716278\n",
      "Epoch: 50\t Loss: 0.09344539791345596\n",
      "Epoch: 60\t Loss: 0.09148307144641876\n",
      "Epoch: 70\t Loss: 0.08959227055311203\n",
      "Epoch: 80\t Loss: 0.08768895268440247\n",
      "Epoch: 90\t Loss: 0.08571644127368927\n",
      "\n",
      "Model Saved at ./saved_model/model_1.pkl...\n",
      "\n",
      "Model Parameters Saved at ./saved_model/model_1_params.pkl...\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/anujdutt/miniconda3/envs/deeplearning/lib/python3.6/site-packages/ipykernel_launcher.py:36: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Save the Model, saved model-1\n",
    "saveNN()\n",
    "\n",
    "# Restore the model from Saved Model\n",
    "restoreModel()\n",
    "\n",
    "# Model with Restored Parameters\n",
    "restoreModelParams()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***The above plots prove that we saved the \"model-1\", restored the model as \"model-2\" and also restored model-1 as \"model-3\" with model-1's saved parameters.***"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}