Flatness vs Generalization Part2-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5c832ae0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets, transforms\n",
    "from torchvision.utils import make_grid\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a6ad7301",
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.ToTensor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d5944b62",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_set = datasets.MNIST(root='C:\\\\Users\\\\varsh\\\\dataset\\\\mnist_train', train=True, download=True, transform=transform)\n",
    "test_data_set = datasets.MNIST(root='C:\\\\Users\\\\varsh\\\\dataset\\\\mnist_test', train=False, download=True, transform=transform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "de6bcc66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dataset MNIST\n",
       "    Number of datapoints: 60000\n",
       "    Root location: C:\\Users\\varsh\\dataset\\mnist_train\n",
       "    Split: Train\n",
       "    StandardTransform\n",
       "Transform: ToTensor()"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d9abfc1d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dataset MNIST\n",
       "    Number of datapoints: 10000\n",
       "    Root location: C:\\Users\\varsh\\dataset\\mnist_test\n",
       "    Split: Test\n",
       "    StandardTransform\n",
       "Transform: ToTensor()"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_data_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3ff2acb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_sizes = [5, 25, 125, 500, 1000]\n",
    "train_loader1 = DataLoader(train_data_set, batch_size=batch_sizes[0], shuffle=True)\n",
    "test_loader1 = DataLoader(test_data_set, batch_size=batch_sizes[0], shuffle=True)\n",
    "\n",
    "train_loader2 = DataLoader(train_data_set, batch_size=batch_sizes[1], shuffle=True)\n",
    "test_loader2 = DataLoader(test_data_set, batch_size=batch_sizes[1], shuffle=True)\n",
    "\n",
    "train_loader3 = DataLoader(train_data_set, batch_size=batch_sizes[2], shuffle=True)\n",
    "test_loader3 = DataLoader(test_data_set, batch_size=batch_sizes[2], shuffle=True)\n",
    "\n",
    "train_loader4 = DataLoader(train_data_set, batch_size=batch_sizes[3], shuffle=True)\n",
    "test_loader4 = DataLoader(test_data_set, batch_size=batch_sizes[3], shuffle=True)\n",
    "\n",
    "train_loader5 = DataLoader(train_data_set, batch_size=batch_sizes[4], shuffle=True)\n",
    "test_loader5 = DataLoader(test_data_set, batch_size=batch_sizes[4], shuffle=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "930f6914",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating number of parameters in the class\n",
    "def CalcParams(model):\n",
    "    val = sum(params.numel() for params in model.parameters() if params.requires_grad)\n",
    "    return val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24c5da4f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6d23a96a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#########################################   #Model1 with 16330 parameters   ###################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ec2786e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8fe34cee",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model1(nn.Module):\n",
    "    def __init__(self, i=784, z1=20, z2=20, o=10):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(i,z1)    \n",
    "        self.fc2 = nn.Linear(z1, z2)\n",
    "        self.out = nn.Linear(z2, o)\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.out(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "143f1096",
   "metadata": {},
   "outputs": [],
   "source": [
    "model1=Model1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "58f6031f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Model1(\n",
       "  (fc1): Linear(in_features=784, out_features=20, bias=True)\n",
       "  (fc2): Linear(in_features=20, out_features=20, bias=True)\n",
       "  (out): Linear(in_features=20, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bb4e6540",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16330\n"
     ]
    }
   ],
   "source": [
    "model1params=CalcParams(model1)\n",
    "print(model1params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "714f2955",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion1 = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a8bfa37b",
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer1 = torch.optim.Adam(model1.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6c211d6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 10\n",
    "train_correct_mod1 = []\n",
    "test_correct_mod1 = []\n",
    "for i in range(epochs):\n",
    "    train_corr = 0\n",
    "    test_corr = 0\n",
    "\n",
    "    # Run the training batches\n",
    "    for b, (X_train, y_train) in enumerate(train_loader1):\n",
    "       \n",
    "        y_pred = model1(X_train.view(5, -1))  \n",
    "        loss = criterion1(y_pred, y_train)\n",
    "\n",
    "        # Tally the number of correct predictions\n",
    "        predicted = torch.max(y_pred.data, 1)[1]\n",
    "        batch_corr = (predicted == y_train).sum()\n",
    "        train_corr += batch_corr\n",
    "        \n",
    "        # Update parameters\n",
    "        optimizer1.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer1.step()\n",
    "        \n",
    "    # Update train loss & accuracy for the epoch\n",
    "    train_losses_mod1=loss\n",
    "    train_correct_mod1.append(train_corr)\n",
    "        \n",
    "    # testing the batches\n",
    "    with torch.no_grad():\n",
    "        for b, (X_test, y_test) in enumerate(test_loader1):\n",
    "\n",
    "            # Apply the model\n",
    "            y_val = model1(X_test.view(5, -1)) \n",
    "\n",
    "            # Tally the number of correct predictions\n",
    "            predicted = torch.max(y_val.data, 1)[1] \n",
    "            test_corr += (predicted == y_test).sum()\n",
    "    \n",
    "    # Update test loss & accuracy for the epoch\n",
    "    loss = criterion1(y_val, y_test)\n",
    "    test_losses_mod1=(loss)\n",
    "    test_correct_mod1.append(test_corr)\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5cf1bbbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_losses_mod1= train_losses_mod1.detach().numpy()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c693794a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(97.0983)\n"
     ]
    }
   ],
   "source": [
    " for t in train_correct_mod1:\n",
    "    trn_accu_mod1=t/600\n",
    "    \n",
    "print(trn_accu_mod1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6df8deb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(95.9600)\n"
     ]
    }
   ],
   "source": [
    " for t in test_correct_mod1:\n",
    "    tst_accu_mod1=t/100\n",
    "    \n",
    "print(tst_accu_mod1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "780e0663",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate sensitivity of every model\n",
    "sensitivity_list = []\n",
    "\n",
    "# Model 1\n",
    "# Get gradient norm (From slides)\n",
    "grad_all = 0.0\n",
    "frob_norm_all = 0\n",
    "counter = 0\n",
    "for p in model1.parameters():\n",
    "    grad = 0.0\n",
    "    if p.grad is not None:\n",
    "        grad = p.grad\n",
    "        # Calculate Frobenius norm of gradients\n",
    "        frob_norm = torch.linalg.norm(grad).numpy()\n",
    "        frob_norm_all += frob_norm\n",
    "        counter += 1\n",
    "sensitivity_list.append(frob_norm_all / counter)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81b5144b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b15b371f",
   "metadata": {},
   "outputs": [],
   "source": [
    "##############################################   Model2 with 16330 parameters   ################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60b35d2b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "690e0fdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model2(nn.Module):\n",
    "    def __init__(self, in_features=784, h1=20, h2=20, out_features=10):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(in_features,h1)    \n",
    "        self.fc2 = nn.Linear(h1, h2)\n",
    "        self.out = nn.Linear(h2, out_features)\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.out(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4af3e8e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "model2=Model2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "42f88175",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Model2(\n",
       "  (fc1): Linear(in_features=784, out_features=20, bias=True)\n",
       "  (fc2): Linear(in_features=20, out_features=20, bias=True)\n",
       "  (out): Linear(in_features=20, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9ebc995c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16330\n"
     ]
    }
   ],
   "source": [
    "model2params=CalcParams(model2)\n",
    "print(model2params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "82205127",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion2 = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a1953a41",
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer2 = torch.optim.Adam(model2.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d728147c",
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 10\n",
    "train_correct_mod2 = []\n",
    "test_correct_mod2 = []\n",
    "for i in range(epochs):\n",
    "    train_corr = 0\n",
    "    test_corr = 0\n",
    "\n",
    "    # Run the training batches\n",
    "    for b, (X_train, y_train) in enumerate(train_loader2):\n",
    "        \n",
    "        y_pred = model2(X_train.view(25, -1))  \n",
    "        loss = criterion1(y_pred, y_train)\n",
    "\n",
    "        # Tally the number of correct predictions\n",
    "        predicted = torch.max(y_pred.data, 1)[1]\n",
    "        batch_corr = (predicted == y_train).sum()\n",
    "        train_corr += batch_corr\n",
    "        \n",
    "        # Update parameters\n",
    "        optimizer2.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer2.step()\n",
    "        \n",
    "    # Update train loss & accuracy for the epoch\n",
    "    train_losses_mod2=loss\n",
    "    train_correct_mod2.append(train_corr)\n",
    "        \n",
    "    #testing the batches\n",
    "    with torch.no_grad():\n",
    "        for b, (X_test, y_test) in enumerate(test_loader2):\n",
    "\n",
    "            # Apply the model\n",
    "            y_val = model2(X_test.view(25, -1)) \n",
    "\n",
    "            # Tally the number of correct predictions\n",
    "            predicted = torch.max(y_val.data, 1)[1] \n",
    "            test_corr += (predicted == y_test).sum()\n",
    "    \n",
    "    # Update test loss & accuracy for the epoch\n",
    "    loss = criterion2(y_val, y_test)\n",
    "    test_losses_mod2=(loss)\n",
    "    test_correct_mod2.append(test_corr)\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "cc3d88d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_losses_mod2= train_losses_mod2.detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "99140dc1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(96.7933)\n"
     ]
    }
   ],
   "source": [
    " for t in train_correct_mod2:\n",
    "    trn_accu_mod2=t/600\n",
    "    \n",
    "print(trn_accu_mod2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "103f213d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(95.9400)\n"
     ]
    }
   ],
   "source": [
    " for t in test_correct_mod2:\n",
    "    tst_accu_mod2=t/100\n",
    "    \n",
    "print(tst_accu_mod2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2e93bbbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating sensitivity of every model2\n",
    "\n",
    "# Model 2\n",
    "# Get gradient norm (From slides)\n",
    "grad_all = 0.0\n",
    "frob_norm_all = 0\n",
    "counter = 0\n",
    "for p in model2.parameters():\n",
    "    grad = 0.0\n",
    "    if p.grad is not None:\n",
    "        grad = p.grad\n",
    "        # Calculate Frobenius norm of gradients\n",
    "        frob_norm = torch.linalg.norm(grad).numpy()\n",
    "        frob_norm_all += frob_norm\n",
    "        counter += 1\n",
    "sensitivity_list.append(frob_norm_all / counter)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce638e5b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "31913cf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "##############################################    Model3 with 16330 parameters    ##############################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db3d6d53",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "63ce47ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model3(nn.Module):\n",
    "    def __init__(self, in_features=784, h1=20, h2=20, out_features=10):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(in_features,h1)    \n",
    "        self.fc2 = nn.Linear(h1, h2)\n",
    "        self.out = nn.Linear(h2, out_features)\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.out(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "67f4c47b",
   "metadata": {},
   "outputs": [],
   "source": [
    "model3=Model3()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "cc59cb72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Model3(\n",
       "  (fc1): Linear(in_features=784, out_features=20, bias=True)\n",
       "  (fc2): Linear(in_features=20, out_features=20, bias=True)\n",
       "  (out): Linear(in_features=20, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "26b8d7e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16330\n"
     ]
    }
   ],
   "source": [
    "model3params=CalcParams(model3)\n",
    "print(model3params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "58065c3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion3 = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "50026e1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer3 = torch.optim.Adam(model3.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "00791973",
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 10\n",
    "train_correct_mod3 = []\n",
    "test_correct_mod3 = []\n",
    "for i in range(epochs):\n",
    "    train_corr = 0\n",
    "    test_corr = 0\n",
    "\n",
    "    # Run the training batches\n",
    "    for b, (X_train, y_train) in enumerate(train_loader3):\n",
    "       \n",
    "        y_pred = model3(X_train.view(125, -1))  \n",
    "        loss = criterion1(y_pred, y_train)\n",
    "\n",
    "        # Tally the number of correct predictions\n",
    "        predicted = torch.max(y_pred.data, 1)[1]\n",
    "        batch_corr = (predicted == y_train).sum()\n",
    "        train_corr += batch_corr\n",
    "        \n",
    "        # Update parameters\n",
    "        optimizer3.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer3.step()\n",
    "        \n",
    "    # Update train loss & accuracy for the epoch\n",
    "    train_losses_mod3=loss\n",
    "    train_correct_mod3.append(train_corr)\n",
    "        \n",
    "    #testing the batches\n",
    "    with torch.no_grad():\n",
    "        for b, (X_test, y_test) in enumerate(test_loader3):\n",
    "\n",
    "            # Apply the model\n",
    "            y_val = model3(X_test.view(125, -1)) \n",
    "\n",
    "            # Tally the number of correct predictions\n",
    "            predicted = torch.max(y_val.data, 1)[1] \n",
    "            test_corr += (predicted == y_test).sum()\n",
    "    \n",
    "    # Update test loss & accuracy for the epoch\n",
    "    loss = criterion3(y_val, y_test)\n",
    "    test_losses_mod3=(loss)\n",
    "    test_correct_mod3.append(test_corr)\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "e7847a27",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_losses_mod3= train_losses_mod3.detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "c84b06a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(95.7450)\n"
     ]
    }
   ],
   "source": [
    "for t in train_correct_mod3:\n",
    "    trn_accu_mod3=t/600\n",
    "    \n",
    "print(trn_accu_mod3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "75256baa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(95.2400)\n"
     ]
    }
   ],
   "source": [
    " for t in test_correct_mod3:\n",
    "    tst_accu_mod3=t/100\n",
    "    \n",
    "print(tst_accu_mod3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "90c4aeea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating sensitivity of every model3\n",
    "\n",
    "# Model 3\n",
    "# Get gradient norm (From slides)\n",
    "grad_all = 0.0\n",
    "frob_norm_all = 0\n",
    "counter = 0\n",
    "for p in model3.parameters():\n",
    "    grad = 0.0\n",
    "    if p.grad is not None:\n",
    "        grad = p.grad\n",
    "        # Calculate Frobenius norm of gradients\n",
    "        frob_norm = torch.linalg.norm(grad).numpy()\n",
    "        frob_norm_all += frob_norm\n",
    "        counter += 1\n",
    "sensitivity_list.append(frob_norm_all / counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b130ae0c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "2f34e639",
   "metadata": {},
   "outputs": [],
   "source": [
    "###############################################    #Model4 with 16330 parameters    ############################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8297e832",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "16065574",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model4(nn.Module):\n",
    "    def __init__(self, in_features=784, h1=20, h2=20, out_features=10):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(in_features,h1)    \n",
    "        self.fc2 = nn.Linear(h1, h2)\n",
    "        self.out = nn.Linear(h2, out_features)\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.out(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "e00eb035",
   "metadata": {},
   "outputs": [],
   "source": [
    "model4=Model4()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "6f3f203c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Model4(\n",
       "  (fc1): Linear(in_features=784, out_features=20, bias=True)\n",
       "  (fc2): Linear(in_features=20, out_features=20, bias=True)\n",
       "  (out): Linear(in_features=20, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "3d37e724",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16330\n"
     ]
    }
   ],
   "source": [
    "model4params=CalcParams(model4)\n",
    "print(model4params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "70007776",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion4 = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "26a9d380",
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer4 = torch.optim.Adam(model4.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "f73bc0c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 10\n",
    "train_correct_mod4 = []\n",
    "test_correct_mod4 = []\n",
    "for i in range(epochs):\n",
    "    train_corr = 0\n",
    "    test_corr = 0\n",
    "\n",
    "    for b, (X_train, y_train) in enumerate(train_loader4):\n",
    "        \n",
    "        y_pred = model4(X_train.view(500, -1))  \n",
    "        loss = criterion1(y_pred, y_train)\n",
    "\n",
    "        predicted = torch.max(y_pred.data, 1)[1]\n",
    "        batch_corr = (predicted == y_train).sum()\n",
    "        train_corr += batch_corr\n",
    "\n",
    "        optimizer4.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer4.step()\n",
    "        \n",
    "    train_losses_mod4=loss\n",
    "    train_correct_mod4.append(train_corr)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for b, (X_test, y_test) in enumerate(test_loader4):\n",
    "\n",
    "            y_val = model4(X_test.view(500, -1)) \n",
    "\n",
    "            predicted = torch.max(y_val.data, 1)[1] \n",
    "            test_corr += (predicted == y_test).sum()\n",
    "\n",
    "    loss = criterion4(y_val, y_test)\n",
    "    test_losses_mod4=(loss)\n",
    "    test_correct_mod4.append(test_corr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "15777782",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_losses_mod4= train_losses_mod4.detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "f895f29f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(94.3483)\n"
     ]
    }
   ],
   "source": [
    "for t in train_correct_mod4:\n",
    "    trn_accu_mod4=t/600\n",
    "    \n",
    "print(trn_accu_mod4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "af62ff28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(94.1800)\n"
     ]
    }
   ],
   "source": [
    " for t in test_correct_mod4:\n",
    "    tst_accu_mod4=t/100\n",
    "    \n",
    "print(tst_accu_mod4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "02519ada",
   "metadata": {},
   "outputs": [],
   "source": [
    "grad_all = 0.0\n",
    "frob_norm_all = 0\n",
    "counter = 0\n",
    "for p in model4.parameters():\n",
    "    grad = 0.0\n",
    "    if p.grad is not None:\n",
    "        grad = p.grad\n",
    "        # Calculate Frobenius norm of gradients\n",
    "        frob_norm = torch.linalg.norm(grad).numpy()\n",
    "        frob_norm_all += frob_norm\n",
    "        counter += 1\n",
    "sensitivity_list.append(frob_norm_all / counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6304c7b8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "cf89b4fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "###################################    Model5 with 16330 parameters#-Model-5    ################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72bc4ca5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "dbab5984",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Model5(nn.Module):\n",
    "    def __init__(self, in_features=784, h1=20, h2=20, out_features=10):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(in_features,h1)    \n",
    "        self.fc2 = nn.Linear(h1, h2)\n",
    "        self.out = nn.Linear(h2, out_features)\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.out(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "80e5e36c",
   "metadata": {},
   "outputs": [],
   "source": [
    "model5=Model5()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "dbbaf2d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Model5(\n",
       "  (fc1): Linear(in_features=784, out_features=20, bias=True)\n",
       "  (fc2): Linear(in_features=20, out_features=20, bias=True)\n",
       "  (out): Linear(in_features=20, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "f3a710d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16330\n"
     ]
    }
   ],
   "source": [
    "model5params=CalcParams(model5)\n",
    "print(model5params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "90515ecb",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion5 = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "1c00f4a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer5 = torch.optim.Adam(model5.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "bf3ebd8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 10\n",
    "train_correct_mod5 = []\n",
    "test_correct_mod5 = []\n",
    "for i in range(epochs):\n",
    "    train_corr = 0\n",
    "    test_corr = 0\n",
    "\n",
    "    # Run the training batches\n",
    "    for b, (X_train, y_train) in enumerate(train_loader5):\n",
    "       \n",
    "        y_pred = model5(X_train.view(1000, -1))  \n",
    "        loss = criterion1(y_pred, y_train)\n",
    "\n",
    "        # Tally the number of correct predictions\n",
    "        predicted = torch.max(y_pred.data, 1)[1]\n",
    "        batch_corr = (predicted == y_train).sum()\n",
    "        train_corr += batch_corr\n",
    "        \n",
    "        # Update parameters\n",
    "        optimizer5.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer5.step()\n",
    "        \n",
    "    # Update train loss & accuracy for the epoch\n",
    "    train_losses_mod5=loss\n",
    "    train_correct_mod5.append(train_corr)\n",
    "        \n",
    "    #testing the batches\n",
    "    with torch.no_grad():\n",
    "        for b, (X_test, y_test) in enumerate(test_loader5):\n",
    "\n",
    "            # Apply the model\n",
    "            y_val = model5(X_test.view(1000, -1)) \n",
    "\n",
    "            # Tally the number of correct predictions\n",
    "            predicted = torch.max(y_val.data, 1)[1] \n",
    "            test_corr += (predicted == y_test).sum()\n",
    "    \n",
    "    # Update test loss & accuracy for the epoch\n",
    "    loss = criterion5(y_val, y_test)\n",
    "    test_losses_mod5=(loss)\n",
    "    test_correct_mod5.append(test_corr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "711a9f59",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_losses_mod5= train_losses_mod5.detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "0c5380fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(92.9933)\n"
     ]
    }
   ],
   "source": [
    "for t in train_correct_mod5:\n",
    "    trn_accu_mod5=t/600\n",
    "    \n",
    "print(trn_accu_mod5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "6cabf287",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(93.1100)\n"
     ]
    }
   ],
   "source": [
    "for t in test_correct_mod5:\n",
    "    tst_accu_mod5=t/100\n",
    "    \n",
    "print(tst_accu_mod5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "0e75ec0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating sensitivity of every model5\n",
    "\n",
    "# Get gradient norm (From slides)\n",
    "grad_all = 0.0\n",
    "frob_norm_all = 0\n",
    "counter = 0\n",
    "for p in model5.parameters():\n",
    "    grad = 0.0\n",
    "    if p.grad is not None:\n",
    "        grad = p.grad\n",
    "        # Calculate Frobenius norm of gradients\n",
    "        frob_norm = torch.linalg.norm(grad).numpy()\n",
    "        frob_norm_all += frob_norm\n",
    "        counter += 1\n",
    "sensitivity_list.append(frob_norm_all / counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92f4df00",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "6d75f0ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loss_list=[]\n",
    "test_loss_list=[]\n",
    "train_accuracy_list=[]\n",
    "test_accuracy_list=[]\n",
    "\n",
    "train_loss_list.append(train_losses_mod1)\n",
    "train_loss_list.append(train_losses_mod2)\n",
    "train_loss_list.append(train_losses_mod3)\n",
    "train_loss_list.append(train_losses_mod4)\n",
    "train_loss_list.append(train_losses_mod5)\n",
    "\n",
    "test_loss_list.append(test_losses_mod1)\n",
    "test_loss_list.append(test_losses_mod2)\n",
    "test_loss_list.append(test_losses_mod3)\n",
    "test_loss_list.append(test_losses_mod4)\n",
    "test_loss_list.append(test_losses_mod5)\n",
    "\n",
    "train_accuracy_list.append(trn_accu_mod1)\n",
    "train_accuracy_list.append(trn_accu_mod2)\n",
    "train_accuracy_list.append(trn_accu_mod3)\n",
    "train_accuracy_list.append(trn_accu_mod4)\n",
    "train_accuracy_list.append(trn_accu_mod5)\n",
    "\n",
    "\n",
    "test_accuracy_list.append(tst_accu_mod1)\n",
    "test_accuracy_list.append(tst_accu_mod2)\n",
    "test_accuracy_list.append(tst_accu_mod3)\n",
    "test_accuracy_list.append(tst_accu_mod4)\n",
    "test_accuracy_list.append(tst_accu_mod5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "afe3d448",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a465f86f70>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visulaize Loss and Sensitivity by batch size of all models\n",
    "fig, ax1 = plt.subplots()\n",
    "ax2 = ax1.twinx()\n",
    "ax1.plot(batch_sizes, train_loss_list, 'b', label='Train')\n",
    "ax1.plot(batch_sizes, test_loss_list, 'b--', label='Test')\n",
    "ax2.plot(batch_sizes, sensitivity_list, 'r', label='Sensitivity')\n",
    "ax1.set_title('Effect of Batch Size on Loss and Sensitivity')\n",
    "ax1.set_xlabel('Batch Sizes')\n",
    "ax1.set_xscale('log')\n",
    "ax1.set_ylabel('Loss', color='b')\n",
    "ax2.set_ylabel('Sensitivity', color='r')\n",
    "ax1.legend(loc='upper center')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "78bb1f66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a46e3af400>"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visulaize Accuracy and Sensitivity by batch size of all models\n",
    "fig, ax1 = plt.subplots()\n",
    "ax2 = ax1.twinx()\n",
    "ax1.plot(batch_sizes, train_accuracy_list, 'b', label='Train')\n",
    "ax1.plot(batch_sizes, test_accuracy_list, 'b--', label='Test')\n",
    "ax2.plot(batch_sizes, sensitivity_list, 'r', label='Sensitivity')\n",
    "ax1.set_title('Effect of Batch Size on Accuracy and Sensitivity')\n",
    "ax1.set_xlabel('Batch Sizes')\n",
    "ax1.set_xscale('log')\n",
    "ax1.set_ylabel('accuracy', color='b')\n",
    "ax2.set_ylabel('Sensitivity', color='r')\n",
    "ax1.legend(loc='upper right')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dea34b5",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}