Part3_ParamGener.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "aerial-trance",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This program creates 10 DNNs to evaluate the effect of a model's parameter number on accuacy and training\n",
    "\n",
    "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": 99,
   "id": "hungry-messaging",
   "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=50, shuffle=True)\n",
    "test = torch.utils.data.DataLoader(testingSet, batch_size=50, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "straight-institution",
   "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": 101,
   "id": "personal-western",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model Declarations\n",
    "# Model 1 - 2 Hidden layer / 1645 Parameters\n",
    "class Model1 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 2)\n",
    "        self.fc2 = nn.Linear(2, 5)\n",
    "        self.fc3 = nn.Linear(5, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = F.relu(self.fc2(val))\n",
    "        val = self.fc3(val)\n",
    "        return val\n",
    "    \n",
    "# Model 2 - 2 Hidden layer / 3270 Parameters\n",
    "class Model2 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 4)\n",
    "        self.fc2 = nn.Linear(4, 8)\n",
    "        self.fc3 = nn.Linear(8, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = F.relu(self.fc2(val))\n",
    "        val = self.fc3(val)\n",
    "        return val\n",
    "    \n",
    "# Model 3 - 2 Hidden layer / 8280 Parameters\n",
    "class Model3 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 10)\n",
    "        self.fc2 = nn.Linear(10, 20)\n",
    "        self.fc3 = nn.Linear(20, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = F.relu(self.fc2(val))\n",
    "        val = self.fc3(val)\n",
    "        return val\n",
    "\n",
    "# Model 4 - 2 Hidden layer / 16640 Parameters\n",
    "class Model4 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 20)\n",
    "        self.fc2 = nn.Linear(20, 30)\n",
    "        self.fc3 = nn.Linear(30, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = F.relu(self.fc2(val))\n",
    "        val = self.fc3(val)\n",
    "        return val\n",
    "    \n",
    "# Model 5 - 2 Hidden layer / 40785 Parameters\n",
    "class Model5 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 50)\n",
    "        self.fc2 = nn.Linear(50, 25)\n",
    "        self.fc3 = nn.Linear(25, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = F.relu(self.fc2(val))\n",
    "        val = self.fc3(val)\n",
    "        return val\n",
    "    \n",
    "# Model 6 - 2 Hidden layer / 84060 Parameters\n",
    "class Model6 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 100)\n",
    "        self.fc2 = nn.Linear(100, 50)\n",
    "        self.fc3 = nn.Linear(50, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = F.relu(self.fc2(val))\n",
    "        val = self.fc3(val)\n",
    "        return val\n",
    "    \n",
    "# Model 7 - 2 Hidden layer / 178110 Parameters\n",
    "class Model7 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 200)\n",
    "        self.fc2 = nn.Linear(200, 100)\n",
    "        self.fc3 = nn.Linear(100, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = F.relu(self.fc2(val))\n",
    "        val = self.fc3(val)\n",
    "        return val\n",
    "    \n",
    "# Model 8 - 2 Hidden layer / 396210 Parameters\n",
    "class Model8 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 400)\n",
    "        self.fc2 = nn.Linear(400, 200)\n",
    "        self.fc3 = nn.Linear(200, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = F.relu(self.fc2(val))\n",
    "        val = self.fc3(val)\n",
    "        return val\n",
    "\n",
    "# Model 9 - 2 Hidden layer / 654310 Parameters\n",
    "class Model9 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 600)\n",
    "        self.fc2 = nn.Linear(600, 300)\n",
    "        self.fc3 = nn.Linear(300, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = F.relu(self.fc2(val))\n",
    "        val = self.fc3(val)\n",
    "        return val\n",
    "    \n",
    "# Model 10 - 2 Hidden layer / 952410 Parameters\n",
    "class Model10 (nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 800)\n",
    "        self.fc2 = nn.Linear(800, 400)\n",
    "        self.fc3 = nn.Linear(400, 10)\n",
    "\n",
    "    def forward(self, val):\n",
    "        val = F.relu(self.fc1(val))\n",
    "        val = F.relu(self.fc2(val))\n",
    "        val = self.fc3(val)\n",
    "        return val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "toxic-pizza",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Set up necessary auxilaries for neural net training\n",
    "model1 = Model1()\n",
    "model2 = Model2()\n",
    "model3 = Model3()\n",
    "model4 = Model4()\n",
    "model5 = Model5()\n",
    "model6 = Model6()\n",
    "model7 = Model7()\n",
    "model8 = Model8()\n",
    "model9 = Model9()\n",
    "model10 = Model10()\n",
    "costFunc = nn.CrossEntropyLoss()\n",
    "model1Opt = optim.Adam(model1.parameters(), lr=0.001)\n",
    "model2Opt = optim.Adam(model2.parameters(), lr=0.001)\n",
    "model3Opt = optim.Adam(model3.parameters(), lr=0.001)\n",
    "model4Opt = optim.Adam(model4.parameters(), lr=0.001)\n",
    "model5Opt = optim.Adam(model5.parameters(), lr=0.001)\n",
    "model6Opt = optim.Adam(model6.parameters(), lr=0.001)\n",
    "model7Opt = optim.Adam(model7.parameters(), lr=0.001)\n",
    "model8Opt = optim.Adam(model8.parameters(), lr=0.001)\n",
    "model9Opt = optim.Adam(model9.parameters(), lr=0.001)\n",
    "model10Opt = optim.Adam(model10.parameters(), lr=0.001)\n",
    "model1Params = calcParams(model1)\n",
    "model2Params = calcParams(model2)\n",
    "model3Params = calcParams(model3)\n",
    "model4Params = calcParams(model4)\n",
    "model5Params = calcParams(model5)\n",
    "model6Params = calcParams(model6)\n",
    "model7Params = calcParams(model7)\n",
    "model8Params = calcParams(model8)\n",
    "model9Params = calcParams(model9)\n",
    "model10Params = calcParams(model10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "affected-liechtenstein",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n",
      "25\n",
      "26\n",
      "27\n",
      "28\n",
      "29\n",
      "30\n",
      "31\n",
      "32\n",
      "33\n",
      "34\n",
      "35\n",
      "36\n",
      "37\n",
      "38\n",
      "39\n",
      "40\n",
      "41\n",
      "42\n",
      "43\n",
      "44\n",
      "45\n",
      "46\n",
      "47\n",
      "48\n",
      "49\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "# Train all models prior to testing and calc loss\n",
    "EPOCHS = 50\n",
    "counter = 0\n",
    "counterList = []\n",
    "for index in range(EPOCHS):\n",
    "    counterList.append(counter)\n",
    "    counter += 1\n",
    "    # Print counter to show progress of training during computation\n",
    "    print(counter)\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",
    "    # Model 3\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()\n",
    "        \n",
    "    # Model 4\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        model4.zero_grad()\n",
    "        output = model4(inputImages.view(-1,784))\n",
    "        cost = costFunc(output, groundTruth)\n",
    "        cost.backward()\n",
    "        model4Opt.step()\n",
    "        \n",
    "    # Model 5\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        model5.zero_grad()\n",
    "        output = model5(inputImages.view(-1,784))\n",
    "        cost = costFunc(output, groundTruth)\n",
    "        cost.backward()\n",
    "        model5Opt.step()\n",
    "        \n",
    "    # Model 6\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        model6.zero_grad()\n",
    "        output = model6(inputImages.view(-1,784))\n",
    "        cost = costFunc(output, groundTruth)\n",
    "        cost.backward()\n",
    "        model6Opt.step()\n",
    "        \n",
    "    # Model 7\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        model7.zero_grad()\n",
    "        output = model7(inputImages.view(-1,784))\n",
    "        cost = costFunc(output, groundTruth)\n",
    "        cost.backward()\n",
    "        model7Opt.step()\n",
    "        \n",
    "    # Model 8\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        model8.zero_grad()\n",
    "        output = model8(inputImages.view(-1,784))\n",
    "        cost = costFunc(output, groundTruth)\n",
    "        cost.backward()\n",
    "        model8Opt.step()\n",
    "        \n",
    "    # Model 9\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        model9.zero_grad()\n",
    "        output = model9(inputImages.view(-1,784))\n",
    "        cost = costFunc(output, groundTruth)\n",
    "        cost.backward()\n",
    "        model9Opt.step()\n",
    "        \n",
    "    # Model 10\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        model10.zero_grad()\n",
    "        output = model10(inputImages.view(-1,784))\n",
    "        cost = costFunc(output, groundTruth)\n",
    "        cost.backward()\n",
    "        model10Opt.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "solid-criterion",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate loss and accuracy for every model for training set\n",
    "# Model 1\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model1(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",
    "model1TrainCost = costTotal / costCounter\n",
    "model1TrainAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 2\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model2(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",
    "model2TrainCost = costTotal / costCounter\n",
    "model2TrainAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 3\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train:\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",
    "model3TrainCost = costTotal / costCounter\n",
    "model3TrainAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 4\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model4(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",
    "model4TrainCost = costTotal / costCounter\n",
    "model4TrainAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 5\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model5(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",
    "model5TrainCost = costTotal / costCounter\n",
    "model5TrainAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 6\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model6(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",
    "model6TrainCost = costTotal / costCounter\n",
    "model6TrainAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 7\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model7(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",
    "model7TrainCost = costTotal / costCounter\n",
    "model7TrainAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 8\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model8(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",
    "model8TrainCost = costTotal / costCounter\n",
    "model8TrainAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 9\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model9(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",
    "model9TrainCost = costTotal / costCounter\n",
    "model9TrainAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 10\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model10(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",
    "model10TrainCost = costTotal / costCounter\n",
    "model10TrainAcc = round(correct/total, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "exterior-compact",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate loss and accuracy for every model for testing set\n",
    "# Model 1\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model1(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",
    "model1TestCost = costTotal / costCounter\n",
    "model1TestAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 2\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model2(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",
    "model2TestCost = costTotal / costCounter\n",
    "model2TestAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 3\n",
    "correct = 0\n",
    "total = 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",
    "model3TestCost = costTotal / costCounter\n",
    "model3TestAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 4\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model4(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",
    "model4TestCost = costTotal / costCounter\n",
    "model4TestAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 5\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model5(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",
    "model5TestCost = costTotal / costCounter\n",
    "model5TestAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 6\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model6(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",
    "model6TestCost = costTotal / costCounter\n",
    "model6TestAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 7\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model7(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",
    "model7TestCost = costTotal / costCounter\n",
    "model7TestAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 8\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model8(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",
    "model8TestCost = costTotal / costCounter\n",
    "model8TestAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 9\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model9(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",
    "model9TestCost = costTotal / costCounter\n",
    "model9TestAcc = round(correct/total, 3)\n",
    "\n",
    "# Model 10\n",
    "correct = 0\n",
    "total = 0\n",
    "costTotal = 0\n",
    "costCounter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test:\n",
    "        inputImages, groundTruth = batch\n",
    "        output = model10(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",
    "model10TestCost = costTotal / costCounter\n",
    "model10TestAcc = round(correct/total, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "demanding-eight",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize loss of models by their parameter count\n",
    "# Training Set\n",
    "plt.plot(model1Params, model1TrainCost, 'r*')\n",
    "plt.plot(model2Params, model2TrainCost, 'r*')\n",
    "plt.plot(model3Params, model3TrainCost, 'r*')\n",
    "plt.plot(model4Params, model4TrainCost, 'r*')\n",
    "plt.plot(model5Params, model5TrainCost, 'r*')\n",
    "plt.plot(model6Params, model6TrainCost, 'r*')\n",
    "plt.plot(model7Params, model7TrainCost, 'r*')\n",
    "plt.plot(model8Params, model8TrainCost, 'r*')\n",
    "plt.plot(model9Params, model9TrainCost, 'r*')\n",
    "plt.plot(model10Params, model10TrainCost, 'r*')\n",
    "# Testing Set\n",
    "plt.plot(model1Params, model1TestCost, 'b^')\n",
    "plt.plot(model2Params, model2TestCost, 'b^')\n",
    "plt.plot(model3Params, model3TestCost, 'b^')\n",
    "plt.plot(model4Params, model4TestCost, 'b^')\n",
    "plt.plot(model5Params, model5TestCost, 'b^')\n",
    "plt.plot(model6Params, model6TestCost, 'b^')\n",
    "plt.plot(model7Params, model7TestCost, 'b^')\n",
    "plt.plot(model8Params, model8TestCost, 'b^')\n",
    "plt.plot(model9Params, model9TestCost, 'b^')\n",
    "plt.plot(model10Params, model10TestCost, 'b^')\n",
    "plt.title(\"Loss of Models\")\n",
    "plt.xlabel(\"Number of Parameters\")\n",
    "plt.ylabel(\"Cross Entropy Loss\")\n",
    "plt.annotate(\"Train\", (model9Params, 0.8), color=\"red\", fontsize=16)\n",
    "plt.annotate(\"Test\", (model9Params, 0.6), color=\"Blue\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "pacific-breach",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize Accuracy of models by their parameter count\n",
    "# Training Set\n",
    "plt.plot(model1Params, model1TrainAcc, 'r*')\n",
    "plt.plot(model2Params, model2TrainAcc, 'r*')\n",
    "plt.plot(model3Params, model3TrainAcc, 'r*')\n",
    "plt.plot(model4Params, model4TrainAcc, 'r*')\n",
    "plt.plot(model5Params, model5TrainAcc, 'r*')\n",
    "plt.plot(model6Params, model6TrainAcc, 'r*')\n",
    "plt.plot(model7Params, model7TrainAcc, 'r*')\n",
    "plt.plot(model8Params, model8TrainAcc, 'r*')\n",
    "plt.plot(model9Params, model9TrainAcc, 'r*')\n",
    "plt.plot(model10Params, model10TrainAcc, 'r*')\n",
    "# Testing Set\n",
    "plt.plot(model1Params, model1TestAcc, 'b^')\n",
    "plt.plot(model2Params, model2TestAcc, 'b^')\n",
    "plt.plot(model3Params, model3TestAcc, 'b^')\n",
    "plt.plot(model4Params, model4TestAcc, 'b^')\n",
    "plt.plot(model5Params, model5TestAcc, 'b^')\n",
    "plt.plot(model6Params, model6TestAcc, 'b^')\n",
    "plt.plot(model7Params, model7TestAcc, 'b^')\n",
    "plt.plot(model8Params, model8TestAcc, 'b^')\n",
    "plt.plot(model9Params, model9TestAcc, 'b^')\n",
    "plt.plot(model10Params, model10TestAcc, 'b^')\n",
    "plt.title(\"Accuracy of Models\")\n",
    "plt.xlabel(\"Number of Parameters\")\n",
    "plt.ylabel(\"Cross Entropy Loss\")\n",
    "plt.annotate(\"Train\", (model9Params, 0.9), color=\"red\", fontsize=16)\n",
    "plt.annotate(\"Test\", (model9Params, 0.85), color=\"Blue\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ongoing-foundation",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fallen-stations",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}