Part3-3-1 - Interpolation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "27d7b0da",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-02-08 18:48:44.165457: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  SSE4.1 SSE4.2\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "/var/folders/jg/lkqyq8zj1cxg49bgvkxt3l2w0000gn/T/ipykernel_29217/1559922479.py:10: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-<style>'. Alternatively, directly use the seaborn API instead.\n",
      "  plt.style.use('seaborn-whitegrid')\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import torch\n",
    "import torchvision as tv\n",
    "from torchvision import transforms, datasets\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('seaborn-whitegrid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e264a77c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grab MNIST dataset\n",
    "trainingSet = datasets.MNIST('', train=True, download=False, transform=transforms.Compose([transforms.ToTensor()]))\n",
    "testingSet = datasets.MNIST('', train=False, download=False, transform=transforms.Compose([transforms.ToTensor()]))\n",
    "train = torch.utils.data.DataLoader(trainingSet, batch_size=25, shuffle=True)\n",
    "test = torch.utils.data.DataLoader(testingSet, batch_size=25, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8b93b8e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the number of parameters in a neural network\n",
    "def calcParams(inputModel):\n",
    "    val = sum(params.numel() for params in inputModel.parameters() if params.requires_grad)\n",
    "    return val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b0f0dff6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set different batch sizes for each of the 5 different models\n",
    "# batchSizes = [ 25, 125]\n",
    "# train1 = torch.utils.data.DataLoader(trainingSet, batch_size=batchSizes[0], shuffle=True)\n",
    "# test1 = torch.utils.data.DataLoader(testingSet, batch_size=batchSizes[0], shuffle=True)\n",
    "# train2 = torch.utils.data.DataLoader(trainingSet, batch_size=batchSizes[1], shuffle=True)\n",
    "# test2 = torch.utils.data.DataLoader(testingSet, batch_size=batchSizes[1], shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "456bac7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model Declarations\n",
    "# Model 1 - 2 Hidden layer / 1645 Parameters\n",
    "# 0\n",
    "#         self.fc3 = nn.Linear(5, 5)\n",
    "#         self.fc4 = nn.Linear(5,10)\n",
    "\n",
    "#     def forward(self, val):\n",
    "#         val = F.relu(self.fc1(val))\n",
    "#         #val = self.fc2(val)\n",
    "#         val = F.relu(self.fc2(val))\n",
    "#         #val = self.fc3(val)\n",
    "#         val = F.relu(self.fc3(val))\n",
    "#         val = self.fc4(val)\n",
    "#         return val\n",
    "    \n",
    "# # Model 1 - 2 Hidden layer / 1645 Parameters    \n",
    "# class Model3 (nn.Module):\n",
    "#     def __init__(self):\n",
    "#         super().__init__()\n",
    "#         self.fc1 = nn.Linear(784, 2)\n",
    "#         #self.fc2 = nn.Linear(2, 10)\n",
    "#         self.fc2 = nn.Linear(2, 5)\n",
    "#         self.fc3 = nn.Linear(5, 5)\n",
    "#         self.fc4 = nn.Linear(5,10)\n",
    "\n",
    "#     def forward(self, val):\n",
    "#         val = F.relu(self.fc1(val))\n",
    "#         #val = self.fc2(val)\n",
    "#         val = F.relu(self.fc2(val))\n",
    "#         #val = self.fc3(val)\n",
    "#         val = F.relu(self.fc3(val))\n",
    "#         val = self.fc4(val)\n",
    "#         return val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0a99a014",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model1 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 30)\n",
    "        self.fc2 = nn.Linear(30, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = self.fc2(val)\n",
    "        return val\n",
    "\n",
    "class Model2 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 30)\n",
    "        self.fc2 = nn.Linear(30, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = self.fc2(val)\n",
    "        return val\n",
    "\n",
    "class Model3 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 30)\n",
    "        self.fc2 = nn.Linear(30, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = self.fc2(val)\n",
    "        return val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "28bd180b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up necessary auxilaries for neural net training\n",
    "model1 = Model1()\n",
    "model2 = Model2()\n",
    "model3 = Model3()\n",
    "costFunc = nn.CrossEntropyLoss()\n",
    "model1Opt = optim.Adam(model1.parameters(), lr=0.001)\n",
    "model2Opt = optim.Adam(model2.parameters(), lr=0.01)\n",
    "model3Opt = optim.Adam(model3.parameters(), lr=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "14cd7ed7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Train all 3 models using different batch sizes\n",
    "EPOCHS = 10\n",
    "for index in range(EPOCHS):\n",
    "    # Print index to show progress of training during computation\n",
    "    print(index)\n",
    "    \n",
    "    # Model 1\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        model1.zero_grad()\n",
    "        output = model1(inputImages.view(-1,784))\n",
    "        cost = costFunc(output, groundTruth)\n",
    "        cost.backward()\n",
    "        model1Opt.step()\n",
    "\n",
    "    # Model 2\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        model2.zero_grad()\n",
    "        output = model2(inputImages.view(-1,784))\n",
    "        cost = costFunc(output, groundTruth)\n",
    "        cost.backward()\n",
    "        model2Opt.step()\n",
    "        \n",
    "#     for batch in train:\n",
    "#         inputImages, groundTruth = batch\n",
    "#         model3.zero_grad()\n",
    "#         output = model3(inputImages.view(-1,784))\n",
    "#         cost = costFunc(output, groundTruth)\n",
    "#         cost.backward()\n",
    "#         model3Opt.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3e69ac75",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating loss for each value of alpha....\n",
    "from torch.nn.utils import (\n",
    "  parameters_to_vector as Params2Vec,\n",
    "  vector_to_parameters as Vec2Params\n",
    ")\n",
    "mod1 = Params2Vec(model1.parameters())\n",
    "mod2 = Params2Vec(model2.parameters())\n",
    "\n",
    "#alpha = [-1,-0.5,0,0.5,1.0,1.5,2.0]\n",
    "alpha = np.arange(-1.0, 2.0 , 0.15)\n",
    "cost3_train = []\n",
    "cost3_alpha_train = []\n",
    "cost3_test = []\n",
    "accuracy3_alpha_train = []\n",
    "\n",
    "for a in alpha:\n",
    "    mod3 = (1 - a)*mod1 + a * mod2\n",
    "    Vec2Params(mod3,model3.parameters())\n",
    "    total = 0\n",
    "    correct = 0\n",
    "    costTotal = 0\n",
    "    costCounter = 0\n",
    "    with torch.no_grad():\n",
    "        for batch in train:\n",
    "            inputImages, groundTruth = batch\n",
    "            #model3.zero_grad()\n",
    "            output = model3(inputImages.view(-1,784))\n",
    "            cost = costFunc(output, groundTruth)\n",
    "            costTotal += cost\n",
    "            costCounter += 1\n",
    "            for i, outputTensor in enumerate(output):\n",
    "                if torch.argmax(outputTensor) == groundTruth[i]:\n",
    "                    correct += 1\n",
    "                total += 1\n",
    "        cost3_alpha_train.append(costTotal / costCounter)\n",
    "        accuracy3_alpha_train.append(round(correct/total, 3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5866ac13",
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy3_alpha_test = []\n",
    "cost3_alpha_test = []\n",
    "for a in alpha :\n",
    "    mod3 = (1 - a)*mod1 + a * mod2\n",
    "    Vec2Params(mod3,model3.parameters())\n",
    "    total = 0\n",
    "    correct = 0\n",
    "    costTotal = 0\n",
    "    costCounter = 0\n",
    "    with torch.no_grad():\n",
    "        for batch in test:\n",
    "            inputImages, groundTruth = batch\n",
    "            output = model3(inputImages.view(-1,784))\n",
    "            cost = costFunc(output, groundTruth)\n",
    "            costTotal += cost\n",
    "            costCounter += 1\n",
    "            for i, outputTensor in enumerate(output):\n",
    "                if torch.argmax(outputTensor) == groundTruth[i]:\n",
    "                    correct += 1\n",
    "                total += 1\n",
    "        cost3_alpha_test.append(costTotal / costCounter)\n",
    "        accuracy3_alpha_test.append(round(correct/total, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "82f6d97b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor(108.9575),\n",
       " tensor(77.3764),\n",
       " tensor(50.9629),\n",
       " tensor(29.8017),\n",
       " tensor(14.0496),\n",
       " tensor(4.1002),\n",
       " tensor(0.3451),\n",
       " tensor(0.1046),\n",
       " tensor(1.0055),\n",
       " tensor(1.6823),\n",
       " tensor(1.7970),\n",
       " tensor(1.3401),\n",
       " tensor(0.5404),\n",
       " tensor(0.1657),\n",
       " tensor(0.2171),\n",
       " tensor(0.6659),\n",
       " tensor(1.8332),\n",
       " tensor(3.9874),\n",
       " tensor(7.2239),\n",
       " tensor(11.4475)]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cost3_alpha_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9c52241c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.315,\n",
       " 0.335,\n",
       " 0.366,\n",
       " 0.416,\n",
       " 0.504,\n",
       " 0.67,\n",
       " 0.911,\n",
       " 0.967,\n",
       " 0.736,\n",
       " 0.657,\n",
       " 0.653,\n",
       " 0.689,\n",
       " 0.826,\n",
       " 0.951,\n",
       " 0.943,\n",
       " 0.883,\n",
       " 0.795,\n",
       " 0.681,\n",
       " 0.599,\n",
       " 0.552]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy3_alpha_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "37b52a19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import math\n",
    "from math import log\n",
    "cost3_alpha_train = [math.log10(i) for i in cost3_alpha_train]\n",
    "cost3_alpha_test = [math.log10(i) for i in cost3_alpha_test]\n",
    "#plt.plot(alpha, cost3_alpha_train, 'r', label='Model')\n",
    "fig,ax = plt.subplots()\n",
    "ax.plot(alpha,\n",
    "        cost3_alpha_train,\n",
    "        color=\"red\")\n",
    "ax.plot(alpha, cost3_alpha_test, color = \"r\", linestyle='dashed')\n",
    "# set x-axis label\n",
    "ax.set_xlabel(\"alpha\", fontsize = 14)\n",
    "# set y-axis label\n",
    "ax.set_ylabel(\"Cros Entropy Cost\",\n",
    "              color=\"red\",\n",
    "              fontsize=14)\n",
    "# twin object for two different y-axis on the sample plot\n",
    "ax2=ax.twinx()\n",
    "# make a plot with different y-axis using second axis object\n",
    "ax2.plot(alpha, accuracy3_alpha_train ,color=\"blue\")\n",
    "ax2.plot(alpha, accuracy3_alpha_test, color = \"blue\", linestyle='dashed')\n",
    "ax2.set_ylabel(\"accuracy\",color=\"blue\",fontsize=14)\n",
    "plt.show()\n",
    "# save the plot as a file\n",
    "# #fig.savefig('two_different_y_axis_for_single_python_plot_with_twinx.jpg',\n",
    "#             format='jpeg',\n",
    "#             dpi=100,\n",
    "#             bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ce2c1616",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch.utils.data.dataloader.DataLoader at 0x7fec2a3fe890>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99cd42f8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b11b31a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}