Part3-2-Number of Params.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9c976bdd",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-02-11 13:41:53.590902: 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_62489/2651104673.py:12: 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": [
    "# 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": 2,
   "id": "e4388f13",
   "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": 3,
   "id": "92d910ac",
   "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": "540f9c95",
   "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",
    "# 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",
    "# 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",
    "# 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": 5,
   "id": "b93c9b5d",
   "metadata": {},
   "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": 6,
   "id": "059a6f48",
   "metadata": {},
   "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": 7,
   "id": "11d16071",
   "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",
    "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": 8,
   "id": "4d2d3c97",
   "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": 9,
   "id": "17ec1fb5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 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": 10,
   "id": "9ccc25b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 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(\"Accuracy\")\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()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c38c1692",
   "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
}