Part3-3-2-batch sz.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "712779af",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-02-11 19:31:55.145705: 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_74981/1559922479.py:10: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-<style>'. Alternatively, directly use the seaborn API instead.\n",
      "  plt.style.use('seaborn-whitegrid')\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import torch\n",
    "import torchvision as tv\n",
    "from torchvision import transforms, datasets\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('seaborn-whitegrid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "77b896f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grab MNIST dataset\n",
    "training_Set = datasets.MNIST('', train=True, download=False, transform=transforms.Compose([transforms.ToTensor()]))\n",
    "testing_Set = datasets.MNIST('', train=False, download=False, transform=transforms.Compose([transforms.ToTensor()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3f8433b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set different batch sizes for each of the 5 different models\n",
    "batch_Sizes = [5, 25, 125, 500, 1500]\n",
    "train_1 = torch.utils.data.DataLoader(training_Set, batch_size=batch_Sizes[0], shuffle=True)\n",
    "test_1 = torch.utils.data.DataLoader(testing_Set, batch_size=batch_Sizes[0], shuffle=True)\n",
    "train_2 = torch.utils.data.DataLoader(training_Set, batch_size=batch_Sizes[1], shuffle=True)\n",
    "test_2 = torch.utils.data.DataLoader(testing_Set, batch_size=batch_Sizes[1], shuffle=True)\n",
    "train_3 = torch.utils.data.DataLoader(training_Set, batch_size=batch_Sizes[2], shuffle=True)\n",
    "test_3 = torch.utils.data.DataLoader(testing_Set, batch_size=batch_Sizes[2], shuffle=True)\n",
    "train_4 = torch.utils.data.DataLoader(training_Set, batch_size=batch_Sizes[3], shuffle=True)\n",
    "test_4 = torch.utils.data.DataLoader(testing_Set, batch_size=batch_Sizes[3], shuffle=True)\n",
    "train_5 = torch.utils.data.DataLoader(training_Set, batch_size=batch_Sizes[4], shuffle=True)\n",
    "test_5 = torch.utils.data.DataLoader(testing_Set, batch_size=batch_Sizes[4], shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "893e5a39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model 1 - 2 Hidden layer / 16640 Parameters\n",
    "class Model_1 (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 2 - 2 Hidden layer / 16640 Parameters\n",
    "class Model_2 (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 3 - 2 Hidden layer / 16640 Parameters\n",
    "class Model_3 (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",
    "# Model 4 - 2 Hidden layer / 16640 Parameters\n",
    "class Model_4 (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 / 16640 Parameters\n",
    "class Model_5 (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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c7c6efdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up necessary auxilaries for neural net training\n",
    "model_1 = Model_1()\n",
    "model_2 = Model_2()\n",
    "model_3 = Model_3()\n",
    "model_4 = Model_4()\n",
    "model_5 = Model_5()\n",
    "costFunc = nn.CrossEntropyLoss()\n",
    "model_1_Opt = optim.Adam(model_1.parameters(), lr=0.001)\n",
    "model_2_Opt = optim.Adam(model_2.parameters(), lr=0.001)\n",
    "model_3_Opt = optim.Adam(model_3.parameters(), lr=0.001)\n",
    "model_4_Opt = optim.Adam(model_4.parameters(), lr=0.001)\n",
    "model_5_Opt = optim.Adam(model_5.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6f75a02b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "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"
     ]
    }
   ],
   "source": [
    "# Train all 5 models using different batch sizes\n",
    "EPOCHS = 50\n",
    "for index in range(EPOCHS):\n",
    "    # Print index to show progress of training during computation\n",
    "    print(index)\n",
    "    \n",
    "    # Model 1\n",
    "    for batch in train_1:\n",
    "        ip_img, ground_truth = batch\n",
    "        model_1.zero_grad()\n",
    "        output = model_1(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost.backward()\n",
    "        model_1_Opt.step()\n",
    "\n",
    "    # Model 2\n",
    "    for batch in train_2:\n",
    "        ip_img, ground_truth = batch\n",
    "        model_2.zero_grad()\n",
    "        output = model_2(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost.backward()\n",
    "        model_2_Opt.step()\n",
    "        \n",
    "    # Model 3\n",
    "    for batch in train_3:\n",
    "        ip_img, ground_truth = batch\n",
    "        model_3.zero_grad()\n",
    "        output = model_3(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost.backward()\n",
    "        model_3_Opt.step()\n",
    "        \n",
    "    # Model 4\n",
    "    for batch in train_4:\n",
    "        ip_img, ground_truth = batch\n",
    "        model_4.zero_grad()\n",
    "        output = model_4(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost.backward()\n",
    "        model_4_Opt.step()\n",
    "            \n",
    "    # Model 5\n",
    "    for batch in train_5:\n",
    "        ip_img, ground_truth = batch\n",
    "        model_5.zero_grad()\n",
    "        output = model_5(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost.backward()\n",
    "        model_5_Opt.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c5602e31",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate loss and accuracy for every model for training set\n",
    "train_Cost_List = []\n",
    "train_Acc_List = []\n",
    "\n",
    "# Model 1\n",
    "correct = 0\n",
    "total = 0\n",
    "cost_Total = 0\n",
    "cost_Counter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train_1:\n",
    "        ip_img, ground_truth = batch\n",
    "        output = model_1(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost_Total += cost\n",
    "        cost_Counter += 1\n",
    "        for i, outputTensor in enumerate(output):\n",
    "            if torch.argmax(outputTensor) == ground_truth[i]:\n",
    "                correct += 1\n",
    "            total += 1\n",
    "train_Cost_List.append(cost_Total / cost_Counter)\n",
    "train_Acc_List.append(round(correct/total, 3)) \n",
    "\n",
    "# Model 2\n",
    "correct = 0\n",
    "total = 0\n",
    "cost_Total = 0\n",
    "cost_Counter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train_2:\n",
    "        ip_img, ground_truth = batch\n",
    "        output = model_2(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost_Total += cost\n",
    "        cost_Counter += 1\n",
    "        for i, outputTensor in enumerate(output):\n",
    "            if torch.argmax(outputTensor) == ground_truth[i]:\n",
    "                correct += 1\n",
    "            total += 1\n",
    "train_Cost_List.append(cost_Total / cost_Counter)\n",
    "train_Acc_List.append(round(correct/total, 3)) \n",
    "\n",
    "# Model 3\n",
    "correct = 0\n",
    "total = 0\n",
    "cost_Total = 0\n",
    "cost_Counter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train_3:\n",
    "        ip_img, ground_truth = batch\n",
    "        output = model_3(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost_Total += cost\n",
    "        cost_Counter += 1\n",
    "        for i, outputTensor in enumerate(output):\n",
    "            if torch.argmax(outputTensor) == ground_truth[i]:\n",
    "                correct += 1\n",
    "            total += 1\n",
    "train_Cost_List.append(cost_Total / cost_Counter)\n",
    "train_Acc_List.append(round(correct/total, 3)) \n",
    "\n",
    "# Model 4\n",
    "correct = 0\n",
    "total = 0\n",
    "cost_Total = 0\n",
    "cost_Counter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train_4:\n",
    "        ip_img, ground_truth = batch\n",
    "        output = model_4(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost_Total += cost\n",
    "        cost_Counter += 1\n",
    "        for i, outputTensor in enumerate(output):\n",
    "            if torch.argmax(outputTensor) == ground_truth[i]:\n",
    "                correct += 1\n",
    "            total += 1\n",
    "train_Cost_List.append(cost_Total / cost_Counter)\n",
    "train_Acc_List.append(round(correct/total, 3)) \n",
    "\n",
    "# Model 5\n",
    "correct = 0\n",
    "total = 0\n",
    "cost_Total = 0\n",
    "cost_Counter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in train_5:\n",
    "        ip_img, ground_truth = batch\n",
    "        output = model_5(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost_Total += cost\n",
    "        cost_Counter += 1\n",
    "        for i, outputTensor in enumerate(output):\n",
    "            if torch.argmax(outputTensor) == ground_truth[i]:\n",
    "                correct += 1\n",
    "            total += 1\n",
    "train_Cost_List.append(cost_Total / cost_Counter)\n",
    "train_Acc_List.append(round(correct/total, 3)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b3657062",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate loss and accuracy for every model for testing set\n",
    "test_Cost_List = []\n",
    "test_Acc_List = []\n",
    "\n",
    "# Model 1\n",
    "correct = 0\n",
    "total = 0\n",
    "cost_Total = 0\n",
    "cost_Counter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test_1:\n",
    "        ip_img, ground_truth = batch\n",
    "        output = model_1(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost_Total += cost\n",
    "        cost_Counter += 1\n",
    "        for i, outputTensor in enumerate(output):\n",
    "            if torch.argmax(outputTensor) == ground_truth[i]:\n",
    "                correct += 1\n",
    "            total += 1\n",
    "test_Cost_List.append(cost_Total / cost_Counter)\n",
    "test_Acc_List.append(round(correct/total, 3))\n",
    "\n",
    "# Model 2\n",
    "correct = 0\n",
    "total = 0\n",
    "cost_Total = 0\n",
    "cost_Counter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test_2:\n",
    "        ip_img, ground_truth = batch\n",
    "        output = model_2(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost_Total += cost\n",
    "        cost_Counter += 1\n",
    "        for i, outputTensor in enumerate(output):\n",
    "            if torch.argmax(outputTensor) == ground_truth[i]:\n",
    "                correct += 1\n",
    "            total += 1\n",
    "test_Cost_List.append(cost_Total / cost_Counter)\n",
    "test_Acc_List.append(round(correct/total, 3))\n",
    "\n",
    "# Model 3\n",
    "correct = 0\n",
    "total = 0\n",
    "cost_Total = 0\n",
    "cost_Counter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test_3:\n",
    "        ip_img, ground_truth = batch\n",
    "        output = model_3(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost_Total += cost\n",
    "        cost_Counter += 1\n",
    "        for i, outputTensor in enumerate(output):\n",
    "            if torch.argmax(outputTensor) == ground_truth[i]:\n",
    "                correct += 1\n",
    "            total += 1\n",
    "test_Cost_List.append(cost_Total / cost_Counter)\n",
    "test_Acc_List.append(round(correct/total, 3))\n",
    "\n",
    "# Model 4\n",
    "correct = 0\n",
    "total = 0\n",
    "cost_Total = 0\n",
    "cost_Counter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test_4:\n",
    "        ip_img, ground_truth = batch\n",
    "        output = model_4(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost_Total += cost\n",
    "        cost_Counter += 1\n",
    "        for i, outputTensor in enumerate(output):\n",
    "            if torch.argmax(outputTensor) == ground_truth[i]:\n",
    "                correct += 1\n",
    "            total += 1\n",
    "test_Cost_List.append(cost_Total / cost_Counter)\n",
    "test_Acc_List.append(round(correct/total, 3))\n",
    "\n",
    "# Model 5\n",
    "correct = 0\n",
    "total = 0\n",
    "cost_Total = 0\n",
    "cost_Counter = 0\n",
    "with torch.no_grad():\n",
    "    for batch in test_5:\n",
    "        ip_img, ground_truth = batch\n",
    "        output = model_5(ip_img.view(-1,784))\n",
    "        cost = costFunc(output, ground_truth)\n",
    "        cost_Total += cost\n",
    "        cost_Counter += 1\n",
    "        for i, outputTensor in enumerate(output):\n",
    "            if torch.argmax(outputTensor) == ground_truth[i]:\n",
    "                correct += 1\n",
    "            total += 1\n",
    "test_Cost_List.append(cost_Total / cost_Counter)\n",
    "test_Acc_List.append(round(correct/total, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6eb014f9",
   "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",
    "fNorm_All = 0\n",
    "counter = 0\n",
    "for p in model_1.parameters():\n",
    "    grad = 0.0\n",
    "    if p.grad is not None:\n",
    "        grad = p.grad\n",
    "        # Calculate Frobenius norm of gradients\n",
    "        fNorm = torch.linalg.norm(grad).numpy()\n",
    "        fNorm_All += fNorm\n",
    "        counter += 1\n",
    "sensitivity_List.append(fNorm_All / counter)\n",
    "\n",
    "\n",
    "# Model 2\n",
    "grad_All = 0.0\n",
    "fNorm_All = 0\n",
    "counter = 0\n",
    "for p in model_2.parameters():\n",
    "    grad = 0.0\n",
    "    if p.grad is not None:\n",
    "        grad = p.grad\n",
    "        fNorm = torch.linalg.norm(grad).numpy()\n",
    "        fNorm_All += fNorm\n",
    "        counter += 1\n",
    "sensitivity_List.append(fNorm_All / counter)\n",
    "\n",
    "# Model 3\n",
    "grad_All = 0.0\n",
    "fNorm_All = 0\n",
    "counter = 0\n",
    "for p in model_3.parameters():\n",
    "    grad = 0.0\n",
    "    if p.grad is not None:\n",
    "        grad = p.grad\n",
    "        fNorm = torch.linalg.norm(grad).numpy()\n",
    "        fNorm_All += fNorm\n",
    "        counter += 1\n",
    "sensitivity_List.append(fNorm_All / counter)\n",
    "\n",
    "# Model 4\n",
    "grad_All = 0.0\n",
    "fNorm_All = 0\n",
    "counter = 0\n",
    "for p in model_4.parameters():\n",
    "    grad = 0.0\n",
    "    if p.grad is not None:\n",
    "        grad = p.grad\n",
    "        fNorm = torch.linalg.norm(grad).numpy()\n",
    "        fNorm_All += fNorm\n",
    "        counter += 1\n",
    "sensitivity_List.append(fNorm_All / counter)\n",
    "\n",
    "# Model 5\n",
    "grad_All = 0.0\n",
    "fNorm_All = 0\n",
    "counter = 0\n",
    "for p in model_5.parameters():\n",
    "    grad = 0.0\n",
    "    if p.grad is not None:\n",
    "        grad = p.grad\n",
    "        fNorm = torch.linalg.norm(grad).numpy()\n",
    "        fNorm_All += fNorm\n",
    "        counter += 1\n",
    "sensitivity_List.append(fNorm_All / counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2a3f9f0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f81797d9510>"
      ]
     },
     "execution_count": 10,
     "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 model\n",
    "fig, ax1 = plt.subplots()\n",
    "ax2 = ax1.twinx()\n",
    "ax1.plot(batch_Sizes, train_Acc_List, 'b', label='Train')\n",
    "ax1.plot(batch_Sizes, test_Acc_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": 11,
   "id": "42e48336",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f813813feb0>"
      ]
     },
     "execution_count": 11,
     "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 model\n",
    "fig, ax1 = plt.subplots()\n",
    "ax2 = ax1.twinx()\n",
    "ax1.plot(batch_Sizes, train_Cost_List, 'b', label='Train')\n",
    "ax1.plot(batch_Sizes, test_Cost_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": null,
   "id": "7f2e2afb",
   "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
}