diff --git "a/Q2/.ipynb_checkpoints/Copy of COMP5541 AlexNet CIFAR-10-checkpoint.ipynb" "b/Q2/.ipynb_checkpoints/Copy of COMP5541 AlexNet CIFAR-10-checkpoint.ipynb"
new file mode 100644--- /dev/null
+++ "b/Q2/.ipynb_checkpoints/Copy of COMP5541 AlexNet CIFAR-10-checkpoint.ipynb"
@@ -0,0 +1,2113 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Answer (a)\n",
+    "P.S. we trained our models for 10 epochs, it really takes long time to train, and colab stop my program\n",
+    "\n",
+    "The tainging statistics are recorded and is plotted 折线图,\n",
+    "\n",
+    "We plot 4 groups of training statistics. (i).For details, you can read the codes\n",
+    "\n",
+    "`observation: `Most of the time, our model can decrease the loss value in early 4 epochs, and start to rise up. The accuracy score can reach about 70%\n",
+    "\n",
+    "The details analyasis is written above each figures"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Answer (b)\n",
+    "\n",
+    "The model optimized by Adam is a little bit stronger than that of RMSProp\n",
+    "\n",
+    "`observation: `Adam make the model converge quickly, since Adam is not only rmsprop, but also momentum\n",
+    "\n",
+    "Maybe momentum technique make the model perform better on this task\n",
+    "\n",
+    "The details analyasis is written above each figures"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Answer (c)\n",
+    "We propose 2 methods to improve the performances. \n",
+    "\n",
+    "- Test time data augmentation\n",
+    "- Deeper Network (failed)\n",
+    "- optimizer (sgd vs adam) (failed, adam is good)\n",
+    "- training batch size\n",
+    "\n",
+    "### Test time data augmentation\n",
+    "During inference phase, we input the original image and flipped image to the network.\n",
+    "\n",
+    "The network outputs 2groups of logits, we decide the final classification results based on both 2 logits.\n",
+    "\n",
+    "This test time data augmentation method can increase about 3% of accuracy score.\n",
+    "\n",
+    "Our observation is test time augmentation can strengthen the robustness.\n",
+    "\n",
+    "### Deeper Network\n",
+    "ResNet is able to build deeper network, since it can resolve the problem of gradient elimination.\n",
+    "\n",
+    "We try to build deeper resnet, we add an deeper output layer to resnet18. The deeper resnet has not yet converge, while simple net have already perfectly converged\n",
+    "\n",
+    "\n",
+    "Our observation is Deeper network usually have better ability to fit data, but it takes more time to learn.\n",
+    "\n",
+    "### training batch size\n",
+    "larger batch size can effectively utilize the computation resource, and accelerate training.\n",
+    "\n",
+    "smaller batch size is facing risk of that the model may leave its best optimal state because of outliar data.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VGo_qfSb8i46"
+   },
+   "source": [
+    "## Importing Libraries\n",
+    "\n",
+    "The Notebook knows to use a GPU to train the model if it's available."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-27T16:33:36.902787Z",
+     "start_time": "2025-06-27T16:33:17.939660Z"
+    },
+    "executionInfo": {
+     "elapsed": 289,
+     "status": "ok",
+     "timestamp": 1750515281845,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "w_2OoM5JQVmT"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import datasets\n",
+    "from torchvision import transforms\n",
+    "from torch.utils.data.sampler import SubsetRandomSampler\n",
+    "from datetime import datetime\n",
+    "from tqdm import tqdm\n",
+    "import matplotlib.pyplot as plt\n",
+    "from torchvision import transforms\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "# Device configuration\n",
+    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Twnee3ln8lIp"
+   },
+   "source": [
+    "## Loading the CIFAR10 Dataset\n",
+    "\n",
+    "Using torchvision (a helper library for computer vision tasks), we will load our dataset. This method has some helper functions that makes pre-processing pretty easy and straight-forward. Let's define the functions get_train_valid_loader and get_test_loader, and then call them to load in and process our CIFAR-10 data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-27T16:33:53.557936Z",
+     "start_time": "2025-06-27T16:33:46.670634Z"
+    },
+    "executionInfo": {
+     "elapsed": 2579,
+     "status": "ok",
+     "timestamp": 1750516889052,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "muLZxw7_TG5O"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████| 170M/170M [00:18<00:00, 9.04MB/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_train_valid_loader(\n",
+    "    data_dir, batch_size, augment, random_seed, valid_size=0.1, shuffle=True\n",
+    "):\n",
+    "    normalize = transforms.Normalize(\n",
+    "        mean=[0.4914, 0.4822, 0.4465],\n",
+    "        std=[0.2023, 0.1994, 0.2010],\n",
+    "    )\n",
+    "\n",
+    "    # define transforms\n",
+    "    transform = transforms.Compose(\n",
+    "        [\n",
+    "            transforms.Resize((224, 224)),\n",
+    "            transforms.ToTensor(),\n",
+    "            normalize,\n",
+    "        ]\n",
+    "    )\n",
+    "\n",
+    "    # load the dataset\n",
+    "    train_dataset = datasets.CIFAR10(\n",
+    "        root=data_dir,\n",
+    "        train=True,\n",
+    "        download=True,\n",
+    "        transform=transform,\n",
+    "    )\n",
+    "\n",
+    "    valid_dataset = datasets.CIFAR10(\n",
+    "        root=data_dir,\n",
+    "        train=True,\n",
+    "        download=True,\n",
+    "        transform=transform,\n",
+    "    )\n",
+    "\n",
+    "    num_train = len(train_dataset)\n",
+    "    indices = list(range(num_train))\n",
+    "    split = int(np.floor(valid_size * num_train))\n",
+    "\n",
+    "    if shuffle:\n",
+    "        np.random.seed(random_seed)\n",
+    "        np.random.shuffle(indices)\n",
+    "\n",
+    "    train_idx, valid_idx = indices[split:], indices[:split]\n",
+    "    train_sampler = SubsetRandomSampler(train_idx)\n",
+    "    valid_sampler = SubsetRandomSampler(valid_idx)\n",
+    "\n",
+    "    train_loader = torch.utils.data.DataLoader(\n",
+    "        train_dataset, batch_size=batch_size, sampler=train_sampler\n",
+    "    )\n",
+    "\n",
+    "    valid_loader = torch.utils.data.DataLoader(\n",
+    "        valid_dataset, batch_size=batch_size, sampler=valid_sampler\n",
+    "    )\n",
+    "\n",
+    "    return (train_loader, valid_loader)\n",
+    "\n",
+    "\n",
+    "def get_test_loader(data_dir, batch_size, shuffle=True):\n",
+    "    normalize = transforms.Normalize(\n",
+    "        mean=[0.485, 0.456, 0.406],\n",
+    "        std=[0.229, 0.224, 0.225],\n",
+    "    )\n",
+    "\n",
+    "    # define transform\n",
+    "    transform = transforms.Compose(\n",
+    "        [\n",
+    "            transforms.Resize((224, 224)),\n",
+    "            transforms.ToTensor(),\n",
+    "            normalize,\n",
+    "        ]\n",
+    "    )\n",
+    "\n",
+    "    dataset = datasets.CIFAR10(\n",
+    "        root=data_dir,\n",
+    "        train=False,\n",
+    "        download=True,\n",
+    "        transform=transform,\n",
+    "    )\n",
+    "\n",
+    "    data_loader = torch.utils.data.DataLoader(\n",
+    "        dataset, batch_size=batch_size, shuffle=shuffle\n",
+    "    )\n",
+    "\n",
+    "    return data_loader\n",
+    "\n",
+    "\n",
+    "# CIFAR10 dataset\n",
+    "train_loader, valid_loader = get_train_valid_loader(\n",
+    "    data_dir=\"./data\", batch_size=64, augment=False, random_seed=1,shuffle=False\n",
+    ")\n",
+    "\n",
+    "test_loader = get_test_loader(data_dir=\"../data\", batch_size=64)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "urw6pzcZT6Xi"
+   },
+   "source": [
+    "## Building AlexNet\n",
+    "\n",
+    "- The first step to defining any neural network (whether a CNN or not) in PyTorch is to define a class that inherits `nn.Module` as it contains many of the methods that we will need to utilize\n",
+    "- There are two main steps after that. First is initializing the layers that we are going to use in our CNN inside `__init__`, and the other is to define the sequence in which those layers will process the image. This is defined inside the forward function\n",
+    "- For the architecture itself, we first define the convolutional layers using the `nn.Conv2D` function with the appropriate kernel size and the input/output channels. We also apply max pooling using `nn.MaxPool2D` function. The nice thing about PyTorch is that we can combine the convolutional layer, activation function, and max pooling into one single layer (they will be separately applied, but it helps with organization) using the `nn.Sequential` function\n",
+    "- Then we define the fully connected layers using linear (`nn.Linear`) and dropout (`nn.Dropout`) along with ReLu activation function (`nn.ReLU`) and combining these with the nn.Sequential function\n",
+    "- Finally, our last layer outputs 10 neurons which are our final predictions for the 10 classes of objects\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:18:01.875274Z",
+     "start_time": "2025-06-22T20:18:01.868417Z"
+    },
+    "executionInfo": {
+     "elapsed": 60,
+     "status": "ok",
+     "timestamp": 1750516891525,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "K5hfwshJR9fz"
+   },
+   "outputs": [],
+   "source": [
+    "class AlexNet(nn.Module):\n",
+    "    def __init__(self, num_classes = 1000, dropout = 0.5):\n",
+    "        super().__init__()\n",
+    "        self.features = nn.Sequential(\n",
+    "            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
+    "            nn.Conv2d(64, 192, kernel_size=5, padding=2),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
+    "            nn.Conv2d(192, 384, kernel_size=3, padding=1),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(384, 256, kernel_size=3, padding=1),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(256, 256, kernel_size=3, padding=1),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
+    "        )\n",
+    "        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))\n",
+    "        self.classifier = nn.Sequential(\n",
+    "            nn.Dropout(p=dropout),\n",
+    "            nn.Linear(256 * 6 * 6, 4096),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Dropout(p=dropout),\n",
+    "            nn.Linear(4096, 4096),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Linear(4096, num_classes),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.features(x)\n",
+    "        x = self.avgpool(x)\n",
+    "        x = torch.flatten(x, 1)\n",
+    "        x = self.classifier(x)\n",
+    "        return x\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CGzCpjRbp2ut"
+   },
+   "source": [
+    "## Building VGGNet\n",
+    "\n",
+    "vggnet is a pyramid net. The numbers of channel increase with its depth, whild the feature maps decrease. whcih can enable itself to capture high level information."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:18:01.898665Z",
+     "start_time": "2025-06-22T20:18:01.892686Z"
+    },
+    "executionInfo": {
+     "elapsed": 82,
+     "status": "ok",
+     "timestamp": 1750523869057,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "PUJbOzCnp2Ss"
+   },
+   "outputs": [],
+   "source": [
+    "class VGG11(nn.Module):\n",
+    "    def __init__(self, num_classes=10):\n",
+    "        super().__init__()\n",
+    "\n",
+    "        def buildblock(numlayer, input_channels, output_channels):\n",
+    "            layers = [nn.Conv2d(input_channels, output_channels, kernel_size=3, stride=1, padding=1), nn.ReLU()]\n",
+    "            layers += [nn.Conv2d(output_channels, output_channels, kernel_size=3, stride=1, padding=1), nn.ReLU()] * (numlayer - 1)\n",
+    "            layers += [nn.MaxPool2d(2)]\n",
+    "            return nn.Sequential(*layers)\n",
+    "\n",
+    "        self.block1 = buildblock(numlayer=1, input_channels=3, output_channels=64)\n",
+    "        self.block2 = buildblock(numlayer=1, input_channels=64, output_channels=128)\n",
+    "        self.block3 = buildblock(numlayer=2, input_channels=128, output_channels=256)\n",
+    "        self.block4 = buildblock(numlayer=2, input_channels=256, output_channels=512)\n",
+    "        self.block5 = buildblock(numlayer=2, input_channels=512, output_channels=512)\n",
+    "\n",
+    "        self.conv_layers = nn.Sequential(\n",
+    "            self.block1, self.block2, self.block3, self.block4, self.block5\n",
+    "        )\n",
+    "\n",
+    "        self.output_layers = nn.Sequential(\n",
+    "            nn.Linear(7*7*512, 4096),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(4096, 4096),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(4096, num_classes)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv_layers(x)\n",
+    "        x = torch.flatten(x, 1)\n",
+    "        x = self.output_layers(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DUW9zW0CIG_f"
+   },
+   "source": [
+    "## Building ResNet\n",
+    "ResNet builds skip connections on each block, preventing gradient from vanishing during back"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-27T16:33:57.181361Z",
+     "start_time": "2025-06-27T16:33:57.172110Z"
+    },
+    "id": "1pG1QAEVjFj5"
+   },
+   "outputs": [],
+   "source": [
+    "class ResBlock(nn.Module):\n",
+    "    def __init__(self, in_channels, out_channels):\n",
+    "        super().__init__()\n",
+    "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1)\n",
+    "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)\n",
+    "        self.downsample = nn.Sequential(\n",
+    "                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=2),\n",
+    "                nn.BatchNorm2d(out_channels)\n",
+    "            )\n",
+    "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2)\n",
+    "        self.relu = nn.ReLU()\n",
+    "    def forward(self, x):\n",
+    "        identity = self.downsample(x)\n",
+    "        out = self.conv1(x)\n",
+    "        out = self.relu(out)\n",
+    "        out = self.conv2(out)\n",
+    "        out = self.relu(out)\n",
+    "        out = out + identity\n",
+    "        out = self.relu(out)\n",
+    "        return out\n",
+    "\n",
+    "class ResNet(nn.Module):\n",
+    "    def __init__(self,num_classes,deeper=\"No\"):\n",
+    "        super().__init__()\n",
+    "\n",
+    "        self.conv1 = nn.Sequential(nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3), nn.ReLU())\n",
+    "        self.conv2 = ResBlock(64, 64)\n",
+    "        self.conv3 = ResBlock(64, 128)\n",
+    "        self.conv4 = ResBlock(128, 256)\n",
+    "        self.conv5 = ResBlock(256, 512)\n",
+    "        self.output_layers = nn.Sequential(\n",
+    "            nn.Linear(7*7*512, 4096),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(4096, num_classes)\n",
+    "        )\n",
+    "        self.final_output_layers = nn.Sequential(\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(num_classes, num_classes)\n",
+    "        ) if deeper==\"Yes\" else None\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv1(x)\n",
+    "        x = self.conv2(x)\n",
+    "        x = self.conv3(x)\n",
+    "        x = self.conv4(x)\n",
+    "        x = self.conv5(x)\n",
+    "        x = torch.flatten(x, 1)\n",
+    "        x = self.output_layers(x)\n",
+    "        if self.final_output_layers is None:return x\n",
+    "        else: return self.final_output_layers(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fLywGzaK-49r"
+   },
+   "source": [
+    "## Setting Hyperparameters\n",
+    "\n",
+    "Before training, we need to set some hyperparameters, such as the loss function and the optimizer to be used along with batch size, learning rate, and number of epochs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-27T16:34:00.260087Z",
+     "start_time": "2025-06-27T16:34:00.255917Z"
+    },
+    "executionInfo": {
+     "elapsed": 1188,
+     "status": "ok",
+     "timestamp": 1750529671175,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "VlgLxD1BSFoz"
+   },
+   "outputs": [],
+   "source": [
+    "num_classes = 10\n",
+    "num_epochs = 20\n",
+    "batch_size = 64\n",
+    "learning_rate = 0.001\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "early_stopping = 10"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1IcOPh6vMODr"
+   },
+   "source": [
+    "## Training\n",
+    "\n",
+    "We are ready to train our model at this point:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5PdTVFW_Hh4x"
+   },
+   "source": [
+    "### VGGNet\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Adam"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:18:02.731889Z",
+     "start_time": "2025-06-22T20:18:01.968436Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "vggnet = VGG11(num_classes).to(device)\n",
+    "vggnet_optimizer = torch.optim.Adam(vggnet.parameters(), lr=learning_rate)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:47:44.152533Z",
+     "start_time": "2025-06-22T20:18:02.752584Z"
+    },
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "2NAGdpAolF3C",
+    "outputId": "fdeca377-6490-4d4c-a978-379674aab98c"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 04:20:44.524153 - Epoch [1/20], Train Loss: 1.6914, Train Accuracy: 38.15%, Test Loss: 1.3849, Test Accuracy: 49.28%\n",
+      "2025-06-23 04:23:25.634491 - Epoch [2/20], Train Loss: 1.2069, Train Accuracy: 56.76%, Test Loss: 1.1299, Test Accuracy: 59.24%\n",
+      "2025-06-23 04:26:06.755900 - Epoch [3/20], Train Loss: 0.8893, Train Accuracy: 68.65%, Test Loss: 0.9190, Test Accuracy: 67.68%\n",
+      "2025-06-23 04:28:48.206214 - Epoch [4/20], Train Loss: 0.6472, Train Accuracy: 77.10%, Test Loss: 0.8593, Test Accuracy: 71.46%\n",
+      "2025-06-23 04:31:30.101735 - Epoch [5/20], Train Loss: 0.4086, Train Accuracy: 85.69%, Test Loss: 1.0176, Test Accuracy: 70.20%\n",
+      "2025-06-23 04:34:12.604158 - Epoch [6/20], Train Loss: 0.2352, Train Accuracy: 91.92%, Test Loss: 1.1922, Test Accuracy: 69.84%\n",
+      "2025-06-23 04:36:54.953503 - Epoch [7/20], Train Loss: 0.1550, Train Accuracy: 94.71%, Test Loss: 1.4235, Test Accuracy: 69.44%\n",
+      "2025-06-23 04:39:37.690299 - Epoch [8/20], Train Loss: 0.1191, Train Accuracy: 96.00%, Test Loss: 1.4372, Test Accuracy: 70.48%\n",
+      "2025-06-23 04:42:19.648764 - Epoch [9/20], Train Loss: 0.0907, Train Accuracy: 97.00%, Test Loss: 1.6494, Test Accuracy: 69.46%\n",
+      "2025-06-23 04:45:02.180740 - Epoch [10/20], Train Loss: 0.0941, Train Accuracy: 96.91%, Test Loss: 1.5076, Test Accuracy: 70.30%\n",
+      "2025-06-23 04:47:44.147419 - Epoch [11/20], Train Loss: 0.0821, Train Accuracy: 97.36%, Test Loss: 1.7451, Test Accuracy: 70.96%\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_loss_history = []\n",
+    "test_loss_history = []\n",
+    "train_accuracy_history = []\n",
+    "test_accuracy_history = []\n",
+    "\n",
+    "total_step = len(train_loader)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    if epoch>early_stopping:break\n",
+    "    # Training\n",
+    "    accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "    for i, (images, labels) in enumerate(train_loader):\n",
+    "        # Move tensors to the configured device\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = vggnet(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "\n",
+    "        # Backward and optimize\n",
+    "        vggnet_optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        vggnet_optimizer.step()\n",
+    "\n",
+    "        accumulate_train_loss += loss.item()\n",
+    "        num_total_train_sample += labels.size()[0]\n",
+    "        num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "\n",
+    "\n",
+    "    #print ('{} - Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
+    "    #               .format(str(datetime.now()), epoch+1, num_epochs, i+1, total_step, accumulate_train_loss/len(train_loader)))\n",
+    "\n",
+    "    train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "    train_loss_history += [train_loss]\n",
+    "    train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "    # Validation\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        accumulate_test_loss = 0\n",
+    "        for images, labels in valid_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = vggnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            accumulate_test_loss += loss.item()\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            del images, labels, outputs\n",
+    "        test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "        #print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))\n",
+    "        test_accuracy_history += [test_accuracy]\n",
+    "        test_loss_history += [test_loss]\n",
+    "    print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "training loss is decreasing and test accuracy is increasing all the time\n",
+    "\n",
+    "however, test loss decreases before 2nd epoch and begin to rise after 2nd epoch, which is a sign of overfitting\n",
+    "\n",
+    "however, test accuracy is increasing before 4th epoch, and becomes stable after 4th epoch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:47:44.431116Z",
+     "start_time": "2025-06-22T20:47:44.265071Z"
+    },
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 452
+    },
+    "executionInfo": {
+     "elapsed": 658,
+     "status": "ok",
+     "timestamp": 1750529640037,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "zmn4IOgQo_Eh",
+    "outputId": "079d6c74-1988-4ed1-eb41-408b061f967e"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(train_loss_history,label=\"Train Loss\")\n",
+    "plt.plot(test_loss_history,label=\"Test Loss\")\n",
+    "plt.title(\"train loss history\")\n",
+    "plt.legend()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(train_accuracy_history,label=\"Train Accuracy\")\n",
+    "plt.plot(test_accuracy_history,label=\"Test Accuracy\")\n",
+    "plt.title(\"train accuracy history\")\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 110,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:47:57.680163Z",
+     "start_time": "2025-06-22T20:47:44.447319Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "torch.save(vggnet.state_dict(),\"adam_vggnet.pth\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### RMSProp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:47:58.302532Z",
+     "start_time": "2025-06-22T20:47:57.694317Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "vggnet = VGG11(num_classes).to(device)\n",
+    "vggnet_optimizer = torch.optim.Adam(vggnet.parameters(), lr=learning_rate)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:17:39.163284Z",
+     "start_time": "2025-06-22T20:47:58.315771Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 04:50:40.501190 - Epoch [1/20], Train Loss: 1.7087, Train Accuracy: 36.42%, Test Loss: 1.4292, Test Accuracy: 48.66%\n",
+      "2025-06-23 04:53:22.418651 - Epoch [2/20], Train Loss: 1.2031, Train Accuracy: 56.94%, Test Loss: 1.0615, Test Accuracy: 63.34%\n",
+      "2025-06-23 04:56:04.288794 - Epoch [3/20], Train Loss: 0.9421, Train Accuracy: 66.54%, Test Loss: 0.9265, Test Accuracy: 67.38%\n",
+      "2025-06-23 04:58:45.882516 - Epoch [4/20], Train Loss: 0.7686, Train Accuracy: 72.83%, Test Loss: 0.8521, Test Accuracy: 69.58%\n",
+      "2025-06-23 05:01:28.096352 - Epoch [5/20], Train Loss: 0.6449, Train Accuracy: 77.15%, Test Loss: 0.8663, Test Accuracy: 70.02%\n",
+      "2025-06-23 05:04:09.579174 - Epoch [6/20], Train Loss: 0.5151, Train Accuracy: 81.59%, Test Loss: 0.8479, Test Accuracy: 72.26%\n",
+      "2025-06-23 05:06:51.889913 - Epoch [7/20], Train Loss: 0.4149, Train Accuracy: 85.24%, Test Loss: 0.8980, Test Accuracy: 71.88%\n",
+      "2025-06-23 05:09:33.670596 - Epoch [8/20], Train Loss: 0.3185, Train Accuracy: 88.70%, Test Loss: 1.0517, Test Accuracy: 70.92%\n",
+      "2025-06-23 05:12:15.518445 - Epoch [9/20], Train Loss: 0.2554, Train Accuracy: 90.95%, Test Loss: 1.1934, Test Accuracy: 71.68%\n",
+      "2025-06-23 05:14:57.302865 - Epoch [10/20], Train Loss: 0.1939, Train Accuracy: 93.22%, Test Loss: 1.2796, Test Accuracy: 70.30%\n",
+      "2025-06-23 05:17:39.154287 - Epoch [11/20], Train Loss: 0.1616, Train Accuracy: 94.36%, Test Loss: 1.4073, Test Accuracy: 69.84%\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_loss_history = []\n",
+    "test_loss_history = []\n",
+    "train_accuracy_history = []\n",
+    "test_accuracy_history = []\n",
+    "\n",
+    "total_step = len(train_loader)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    if epoch>early_stopping:break\n",
+    "    # Training\n",
+    "    accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "    for i, (images, labels) in enumerate(train_loader):\n",
+    "        # Move tensors to the configured device\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = vggnet(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "\n",
+    "        # Backward and optimize\n",
+    "        vggnet_optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        vggnet_optimizer.step()\n",
+    "\n",
+    "        accumulate_train_loss += loss.item()\n",
+    "        num_total_train_sample += labels.size()[0]\n",
+    "        num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "\n",
+    "\n",
+    "    #print ('{} - Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
+    "    #               .format(str(datetime.now()), epoch+1, num_epochs, i+1, total_step, accumulate_train_loss/len(train_loader)))\n",
+    "\n",
+    "    train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "    train_loss_history += [train_loss]\n",
+    "    train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "    # Validation\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        accumulate_test_loss = 0\n",
+    "        for images, labels in valid_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = vggnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            accumulate_test_loss += loss.item()\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            del images, labels, outputs\n",
+    "        test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "        #print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))\n",
+    "        test_accuracy_history += [test_accuracy]\n",
+    "        test_loss_history += [test_loss]\n",
+    "    print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "training loss is decreasing and test accuracy is increasing all the time\n",
+    "\n",
+    "however, test loss decreases before 3nd epoch and begin to rise after 3nd epoch, which is a sign of overfitting\n",
+    "\n",
+    "however, test accuracy is increasing before 4th epoch, and becomes stable after 4th epoch, and seems to decrease slightly"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 113,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:17:39.454809Z",
+     "start_time": "2025-06-22T21:17:39.301878Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(train_loss_history,label=\"Train Loss\")\n",
+    "plt.plot(test_loss_history,label=\"Test Loss\")\n",
+    "plt.title(\"train loss history\")\n",
+    "plt.legend()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(train_accuracy_history,label=\"Train Accuracy\")\n",
+    "plt.plot(test_accuracy_history,label=\"Test Accuracy\")\n",
+    "plt.title(\"train accuracy history\")\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 114,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:17:52.760224Z",
+     "start_time": "2025-06-22T21:17:39.474325Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "torch.save(vggnet.state_dict(),\"rmsprop_vggnet.pth\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 115,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:17:52.815410Z",
+     "start_time": "2025-06-22T21:17:52.774788Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "del vggnet\n",
+    "torch.cuda.empty_cache()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ResNet"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Adam"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 116,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:17:53.350761Z",
+     "start_time": "2025-06-22T21:17:52.829414Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "resnet = ResNet(num_classes).to(device)\n",
+    "resnet_optimizer = torch.optim.Adam(resnet.parameters(), lr=learning_rate)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 117,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:31:25.898877Z",
+     "start_time": "2025-06-22T21:17:53.365713Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.07it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:19:07.547883 - Epoch [1/20], Train Loss: 1.7771, Train Accuracy: 44.64%, Test Loss: 1.2217, Test Accuracy: 56.62%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:10<00:00, 10.00it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:20:22.067992 - Epoch [2/20], Train Loss: 1.1118, Train Accuracy: 60.20%, Test Loss: 1.0549, Test Accuracy: 62.44%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.14it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:21:35.647345 - Epoch [3/20], Train Loss: 0.9123, Train Accuracy: 67.71%, Test Loss: 0.9352, Test Accuracy: 67.80%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:22:49.510506 - Epoch [4/20], Train Loss: 0.7586, Train Accuracy: 72.79%, Test Loss: 0.8830, Test Accuracy: 69.00%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:24:03.338762 - Epoch [5/20], Train Loss: 0.6262, Train Accuracy: 77.67%, Test Loss: 0.8580, Test Accuracy: 71.00%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.07it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:25:17.463466 - Epoch [6/20], Train Loss: 0.4943, Train Accuracy: 82.47%, Test Loss: 0.8950, Test Accuracy: 70.88%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:26:31.100507 - Epoch [7/20], Train Loss: 0.3866, Train Accuracy: 85.99%, Test Loss: 0.8949, Test Accuracy: 71.96%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.16it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:27:44.472171 - Epoch [8/20], Train Loss: 0.2787, Train Accuracy: 90.05%, Test Loss: 1.0742, Test Accuracy: 70.98%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.10it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:28:58.348512 - Epoch [9/20], Train Loss: 0.2043, Train Accuracy: 92.64%, Test Loss: 1.1987, Test Accuracy: 70.54%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.08it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:30:12.275953 - Epoch [10/20], Train Loss: 0.1604, Train Accuracy: 94.40%, Test Loss: 1.3451, Test Accuracy: 70.96%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.17it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:31:25.891467 - Epoch [11/20], Train Loss: 0.1357, Train Accuracy: 95.31%, Test Loss: 1.3470, Test Accuracy: 70.62%\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_loss_history = []\n",
+    "test_loss_history = []\n",
+    "train_accuracy_history = []\n",
+    "test_accuracy_history = []\n",
+    "\n",
+    "total_step = len(train_loader)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    if epoch>early_stopping:break\n",
+    "    # Training\n",
+    "    accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "    for i, (images, labels) in enumerate(tqdm(train_loader)):\n",
+    "        # Move tensors to the configured device\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = resnet(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "\n",
+    "        # Backward and optimize\n",
+    "        resnet_optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        resnet_optimizer.step()\n",
+    "\n",
+    "        accumulate_train_loss += loss.item()\n",
+    "        num_total_train_sample += labels.size()[0]\n",
+    "        num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "\n",
+    "\n",
+    "    #print ('{} - Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
+    "    #               .format(str(datetime.now()), epoch+1, num_epochs, i+1, total_step, accumulate_train_loss/len(train_loader)))\n",
+    "\n",
+    "    train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "    train_loss_history += [train_loss]\n",
+    "    train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "    # Validation\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        accumulate_test_loss = 0\n",
+    "        for images, labels in valid_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = resnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            accumulate_test_loss += loss.item()\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            del images, labels, outputs\n",
+    "        test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "        #print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))\n",
+    "        test_accuracy_history += [test_accuracy]\n",
+    "        test_loss_history += [test_loss]\n",
+    "    print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "training loss is decreasing and test accuracy is increasing all the time\n",
+    "\n",
+    "however, test loss decreases before 5nd epoch and begin to rise after 5nd epoch, which is a sign of overfitting\n",
+    "\n",
+    "however, test accuracy is increasing before 5th epoch, and becomes stable after 5th epoch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 118,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:31:26.241463Z",
+     "start_time": "2025-06-22T21:31:26.073218Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(train_loss_history,label=\"Train Loss\")\n",
+    "plt.plot(test_loss_history,label=\"Test Loss\")\n",
+    "plt.title(\"train loss history\")\n",
+    "plt.legend()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(train_accuracy_history,label=\"Train Accuracy\")\n",
+    "plt.plot(test_accuracy_history,label=\"Test Accuracy\")\n",
+    "plt.title(\"train accuracy history\")\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 119,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:31:37.323973Z",
+     "start_time": "2025-06-22T21:31:26.257911Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "torch.save(resnet.state_dict(),\"adam_resnet.pth\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### RMSProp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 120,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:31:37.852755Z",
+     "start_time": "2025-06-22T21:31:37.352299Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "resnet = ResNet(num_classes).to(device)\n",
+    "resnet_optimizer = torch.optim.RMSprop(resnet.parameters(), lr=learning_rate)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:44:33.021400Z",
+     "start_time": "2025-06-22T21:31:37.868176Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.53it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:32:48.903460 - Epoch [1/20], Train Loss: 1859.9671, Train Accuracy: 31.96%, Test Loss: 2.4824, Test Accuracy: 28.88%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.67it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:33:58.906021 - Epoch [2/20], Train Loss: 1.5068, Train Accuracy: 47.25%, Test Loss: 3.2892, Test Accuracy: 25.48%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:05<00:00, 10.67it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:35:09.563930 - Epoch [3/20], Train Loss: 1.2458, Train Accuracy: 55.40%, Test Loss: 1.6373, Test Accuracy: 43.82%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:07<00:00, 10.45it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:36:21.116295 - Epoch [4/20], Train Loss: 1.1347, Train Accuracy: 61.66%, Test Loss: 1.1753, Test Accuracy: 58.22%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.54it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:37:31.933524 - Epoch [5/20], Train Loss: 0.9069, Train Accuracy: 67.75%, Test Loss: 1.4641, Test Accuracy: 55.56%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:05<00:00, 10.69it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:38:42.170325 - Epoch [6/20], Train Loss: 0.7611, Train Accuracy: 73.24%, Test Loss: 0.9630, Test Accuracy: 66.82%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:05<00:00, 10.69it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:39:52.094915 - Epoch [7/20], Train Loss: 0.6048, Train Accuracy: 78.73%, Test Loss: 1.0539, Test Accuracy: 67.42%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:05<00:00, 10.73it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:41:01.826187 - Epoch [8/20], Train Loss: 0.4501, Train Accuracy: 84.21%, Test Loss: 1.0981, Test Accuracy: 65.50%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.60it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:42:12.497261 - Epoch [9/20], Train Loss: 0.3200, Train Accuracy: 88.69%, Test Loss: 1.2404, Test Accuracy: 66.90%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.66it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:43:22.670162 - Epoch [10/20], Train Loss: 0.2183, Train Accuracy: 92.24%, Test Loss: 1.3505, Test Accuracy: 68.54%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:05<00:00, 10.71it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:44:33.016152 - Epoch [11/20], Train Loss: 0.1635, Train Accuracy: 94.24%, Test Loss: 1.5689, Test Accuracy: 68.40%\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_loss_history = []\n",
+    "test_loss_history = []\n",
+    "train_accuracy_history = []\n",
+    "test_accuracy_history = []\n",
+    "\n",
+    "total_step = len(train_loader)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    if epoch>early_stopping:break\n",
+    "    # Training\n",
+    "    accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "    for i, (images, labels) in enumerate(tqdm(train_loader)):\n",
+    "        # Move tensors to the configured device\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = resnet(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "\n",
+    "        # Backward and optimize\n",
+    "        resnet_optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        resnet_optimizer.step()\n",
+    "\n",
+    "        accumulate_train_loss += loss.item()\n",
+    "        num_total_train_sample += labels.size()[0]\n",
+    "        num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "\n",
+    "\n",
+    "    #print ('{} - Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
+    "    #               .format(str(datetime.now()), epoch+1, num_epochs, i+1, total_step, accumulate_train_loss/len(train_loader)))\n",
+    "\n",
+    "    train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "    train_loss_history += [train_loss]\n",
+    "    train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "    # Validation\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        accumulate_test_loss = 0\n",
+    "        for images, labels in valid_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = resnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            accumulate_test_loss += loss.item()\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            del images, labels, outputs\n",
+    "        test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "        #print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))\n",
+    "        test_accuracy_history += [test_accuracy]\n",
+    "        test_loss_history += [test_loss]\n",
+    "    print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "rmsprop's resnet can reach 98% accuracy on train data, but only 69% accuracy on test data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 122,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:44:33.307945Z",
+     "start_time": "2025-06-22T21:44:33.148107Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(np.log(train_loss_history),label=\"Train Loss\")\n",
+    "plt.plot(np.log(test_loss_history),label=\"Test Loss\")\n",
+    "plt.title(\"train loss history\")\n",
+    "plt.legend()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(train_accuracy_history,label=\"Train Accuracy\")\n",
+    "plt.plot(test_accuracy_history,label=\"Test Accuracy\")\n",
+    "plt.title(\"train accuracy history\")\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 123,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:44:44.543491Z",
+     "start_time": "2025-06-22T21:44:33.323316Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "torch.save(resnet.state_dict(),\"rmsprop_resnet.pth\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3qcjhswc5_Ay"
+   },
+   "source": [
+    "### Backup of Training Log\n",
+    "\n",
+    "#### AlexNet\n",
+    "```\n",
+    "Epoch [1/20], Step [704/704], Loss: 1.6327\n",
+    "Accuracy of the network on the 5000 validation images: 42.66 %\n",
+    "Epoch [2/20], Step [704/704], Loss: 1.1153\n",
+    "Accuracy of the network on the 5000 validation images: 52.42 %\n",
+    "Epoch [3/20], Step [704/704], Loss: 0.8354\n",
+    "Accuracy of the network on the 5000 validation images: 61.48 %\n",
+    "Epoch [4/20], Step [704/704], Loss: 0.5581\n",
+    "Accuracy of the network on the 5000 validation images: 62.56 %\n",
+    "Epoch [5/20], Step [704/704], Loss: 1.6696\n",
+    "Accuracy of the network on the 5000 validation images: 68.84 %\n",
+    "Epoch [6/20], Step [704/704], Loss: 0.6406\n",
+    "Accuracy of the network on the 5000 validation images: 70.98 %\n",
+    "Epoch [7/20], Step [704/704], Loss: 0.8516\n",
+    "Accuracy of the network on the 5000 validation images: 71.82 %\n",
+    "Epoch [8/20], Step [704/704], Loss: 0.3658\n",
+    "Accuracy of the network on the 5000 validation images: 69.96 %\n",
+    "Epoch [9/20], Step [704/704], Loss: 0.4399\n",
+    "Accuracy of the network on the 5000 validation images: 74.84 %\n",
+    "Epoch [10/20], Step [704/704], Loss: 0.1435\n",
+    "Accuracy of the network on the 5000 validation images: 76.46 %\n",
+    "Epoch [11/20], Step [704/704], Loss: 0.5190\n",
+    "Accuracy of the network on the 5000 validation images: 74.78 %\n",
+    "Epoch [12/20], Step [704/704], Loss: 0.5558\n",
+    "Accuracy of the network on the 5000 validation images: 76.96 %\n",
+    "Epoch [13/20], Step [704/704], Loss: 0.4064\n",
+    "Accuracy of the network on the 5000 validation images: 76.66 %\n",
+    "Epoch [14/20], Step [704/704], Loss: 0.4210\n",
+    "Accuracy of the network on the 5000 validation images: 76.6 %\n",
+    "Epoch [15/20], Step [704/704], Loss: 0.3571\n",
+    "Accuracy of the network on the 5000 validation images: 75.68 %\n",
+    "Epoch [16/20], Step [704/704], Loss: 0.8136\n",
+    "Accuracy of the network on the 5000 validation images: 76.82 %\n",
+    "Epoch [17/20], Step [704/704], Loss: 0.3949\n",
+    "Accuracy of the network on the 5000 validation images: 78.76 %\n",
+    "Epoch [18/20], Step [704/704], Loss: 0.3319\n",
+    "Accuracy of the network on the 5000 validation images: 78.0 %\n",
+    "Epoch [19/20], Step [704/704], Loss: 0.5933\n",
+    "Accuracy of the network on the 5000 validation images: 79.92 %\n",
+    "Epoch [20/20], Step [704/704], Loss: 0.3297\n",
+    "Accuracy of the network on the 5000 validation images: 75.88 %\n",
+    "```\n",
+    "\n",
+    "VGG11\n",
+    "we apply early stopping to avoid overfitting\n",
+    "```\n",
+    "\n",
+    "100%|██████████| 704/704 [07:16<00:00,  1.61it/s]\n",
+    "2025-06-21 16:45:56.248537 - Epoch [1/20], Train Loss: 1.8241, Train Accuracy: 31.59%, Test Loss: 1.4884, Test Accuracy: 47.34%\n",
+    "100%|██████████| 704/704 [07:12<00:00,  1.63it/s]\n",
+    "2025-06-21 16:53:30.465123 - Epoch [2/20], Train Loss: 1.1994, Train Accuracy: 56.53%, Test Loss: 1.1081, Test Accuracy: 60.92%\n",
+    "100%|██████████| 704/704 [07:13<00:00,  1.63it/s]\n",
+    "2025-06-21 17:01:05.513070 - Epoch [3/20], Train Loss: 0.9004, Train Accuracy: 68.23%, Test Loss: 0.9152, Test Accuracy: 67.56%\n",
+    "100%|██████████| 704/704 [07:13<00:00,  1.62it/s]\n",
+    "2025-06-21 17:08:40.880336 - Epoch [4/20], Train Loss: 0.6816, Train Accuracy: 76.00%, Test Loss: 0.8753, Test Accuracy: 70.18%\n",
+    "100%|██████████| 704/704 [07:12<00:00,  1.63it/s]\n",
+    "2025-06-21 17:16:14.916988 - Epoch [5/20], Train Loss: 0.4868, Train Accuracy: 82.80%, Test Loss: 0.9323, Test Accuracy: 70.28%\n",
+    "100%|██████████| 704/704 [07:13<00:00,  1.63it/s]\n",
+    "2025-06-21 17:23:49.801789 - Epoch [6/20], Train Loss: 0.3109, Train Accuracy: 89.14%, Test Loss: 1.1114, Test Accuracy: 71.10%\n",
+    "100%|██████████| 704/704 [07:13<00:00,  1.62it/s]\n",
+    "2025-06-21 17:31:25.042103 - Epoch [7/20], Train Loss: 0.2071, Train Accuracy: 92.81%, Test Loss: 1.2503, Test Accuracy: 71.28%\n",
+    "100%|██████████| 704/704 [07:13<00:00,  1.62it/s]\n",
+    "2025-06-21 17:39:01.094586 - Epoch [8/20], Train Loss: 0.1387, Train Accuracy: 95.29%, Test Loss: 1.3280, Test Accuracy: 70.26%\n",
+    "100%|██████████| 704/704 [07:16<00:00,  1.61it/s]\n",
+    "2025-06-21 17:46:39.042234 - Epoch [9/20], Train Loss: 0.1117, Train Accuracy: 96.21%, Test Loss: 1.5484, Test Accuracy: 71.40%\n",
+    "100%|██████████| 704/704 [07:16<00:00,  1.61it/s]\n",
+    "2025-06-21 17:54:17.174933 - Epoch [10/20], Train Loss: 0.1071, Train Accuracy: 96.52%, Test Loss: 1.5823, Test Accuracy: 69.84%\n",
+    "  1%|▏         | 9/704 [00:06<07:59,  1.45it/s]\n",
+    "\n",
+    "```\n",
+    "\n",
+    "ResNet\n",
+    "```\n",
+    "100%|██████████| 704/704 [01:11<00:00,  9.84it/s]\n",
+    "2025-06-22 03:37:47.552381 - Epoch [1/20], Train Loss: 1.4436, Train Accuracy: 47.92%, Test Loss: 1.2438, Test Accuracy: 55.76%\n",
+    "100%|██████████| 704/704 [01:10<00:00, 10.04it/s]\n",
+    "2025-06-22 03:39:01.986240 - Epoch [2/20], Train Loss: 1.1279, Train Accuracy: 59.60%, Test Loss: 1.0987, Test Accuracy: 61.04%\n",
+    "100%|██████████| 704/704 [01:11<00:00,  9.91it/s]\n",
+    "2025-06-22 03:40:17.410401 - Epoch [3/20], Train Loss: 0.9505, Train Accuracy: 66.48%, Test Loss: 0.9712, Test Accuracy: 65.80%\n",
+    "100%|██████████| 704/704 [01:11<00:00,  9.81it/s]\n",
+    "2025-06-22 03:41:34.491176 - Epoch [4/20], Train Loss: 0.8170, Train Accuracy: 71.10%, Test Loss: 0.9468, Test Accuracy: 67.10%\n",
+    "100%|██████████| 704/704 [01:10<00:00,  9.94it/s]\n",
+    "2025-06-22 03:42:50.428944 - Epoch [5/20], Train Loss: 0.6911, Train Accuracy: 75.64%, Test Loss: 0.8987, Test Accuracy: 69.74%\n",
+    "100%|██████████| 704/704 [01:10<00:00, 10.00it/s]\n",
+    "2025-06-22 03:44:05.027102 - Epoch [6/20], Train Loss: 0.5825, Train Accuracy: 79.30%, Test Loss: 0.8809, Test Accuracy: 71.00%\n",
+    "100%|██████████| 704/704 [01:12<00:00,  9.65it/s]\n",
+    "2025-06-22 03:45:21.973571 - Epoch [7/20], Train Loss: 0.4729, Train Accuracy: 83.17%, Test Loss: 0.9303, Test Accuracy: 70.92%\n",
+    "100%|██████████| 704/704 [01:08<00:00, 10.22it/s]\n",
+    "2025-06-22 03:46:35.133883 - Epoch [8/20], Train Loss: 0.3653, Train Accuracy: 87.13%, Test Loss: 1.0199, Test Accuracy: 70.80%\n",
+    "100%|██████████| 704/704 [01:08<00:00, 10.24it/s]\n",
+    "2025-06-22 03:47:47.784789 - Epoch [9/20], Train Loss: 0.2976, Train Accuracy: 89.47%, Test Loss: 1.0985, Test Accuracy: 70.20%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.19it/s]\n",
+    "2025-06-22 03:49:00.769455 - Epoch [10/20], Train Loss: 0.2226, Train Accuracy: 92.18%, Test Loss: 1.1940, Test Accuracy: 70.12%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.15it/s]\n",
+    "2025-06-22 03:50:14.153546 - Epoch [11/20], Train Loss: 0.1748, Train Accuracy: 93.76%, Test Loss: 1.2457, Test Accuracy: 70.96%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.20it/s]\n",
+    "2025-06-22 03:51:27.119316 - Epoch [12/20], Train Loss: 0.1418, Train Accuracy: 95.06%, Test Loss: 1.3119, Test Accuracy: 70.10%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.06it/s]\n",
+    "2025-06-22 03:52:41.577209 - Epoch [13/20], Train Loss: 0.1214, Train Accuracy: 95.76%, Test Loss: 1.5131, Test Accuracy: 69.92%\n",
+    "  4%|▍         | 27/704 [00:02<01:12,  9.34it/s]\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:44:44.569024Z",
+     "start_time": "2025-06-22T21:44:44.566015Z"
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## question (c) ablation study on test time augmentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7PDLeXcXpLct"
+   },
+   "source": [
+    "#### VGGNet"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:46:14.213680Z",
+     "start_time": "2025-06-22T21:44:44.582898Z"
+    },
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 107675,
+     "status": "ok",
+     "timestamp": 1750529265618,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "Pp6MLe7PoYXm",
+    "outputId": "b8f8dbde-f821-4bc4-d618-7a3ae17496ce"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Adam VGGNet\n",
+      "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.62 %\n",
+      "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 68.12 %\n",
+      "RMSProp VGGNet\n",
+      "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.61 %\n",
+      "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 69.27 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_time_augmentor = transforms.RandomHorizontalFlip(1.0)\n",
+    "vggnet = VGG11(num_classes)\n",
+    "vggnet.load_state_dict(torch.load(\"adam_vggnet.pth\"))\n",
+    "vggnet.eval().to(device)\n",
+    "print(\"Adam VGGNet\")\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = (vggnet(images)+vggnet(test_time_augmentor(images)))/2\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = vggnet(images)\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[No Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "\n",
+    "test_time_augmentor = transforms.RandomHorizontalFlip(1.0)\n",
+    "vggnet = VGG11(10)\n",
+    "vggnet.load_state_dict(torch.load(\"rmsprop_vggnet.pth\"))\n",
+    "vggnet.eval().to(device)\n",
+    "print(\"RMSProp VGGNet\")\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = (vggnet(images)+vggnet(test_time_augmentor(images)))/2\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = vggnet(images)\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[No Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "cG1h1T2speNq"
+   },
+   "source": [
+    "#### ResNet"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:46:32.447350Z",
+     "start_time": "2025-06-22T21:46:14.287205Z"
+    },
+    "id": "i0mPxCxDpdT8"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Adam ResNet\n",
+      "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.99 %\n",
+      "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 69.95 %\n",
+      "RMSProp ResNet\n",
+      "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 70.09 %\n",
+      "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 67.07 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_time_augmentor = transforms.RandomHorizontalFlip(1.0)\n",
+    "print(\"Adam ResNet\")\n",
+    "resnet = ResNet(num_classes)\n",
+    "resnet.load_state_dict(torch.load(\"adam_resnet.pth\"))\n",
+    "resnet.to(device)\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = (resnet(images)+resnet(test_time_augmentor(images)))/2\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = resnet(images)\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[No Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "test_time_augmentor = transforms.RandomHorizontalFlip(1.0)\n",
+    "print(\"RMSProp ResNet\")\n",
+    "resnet = ResNet(num_classes)\n",
+    "resnet.load_state_dict(torch.load(\"rmsprop_resnet.pth\"))\n",
+    "resnet.to(device)\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = (resnet(images)+resnet(test_time_augmentor(images)))/2\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = resnet(images)\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[No Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "P7j0NIu2qCNr"
+   },
+   "source": [
+    "### Backup of Testing Log\n",
+    "\n",
+    "#### VGGNet\n",
+    "```\n",
+    "Adam VGGNet\n",
+    "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.62 %\n",
+    "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 68.12 %\n",
+    "RMSProp VGGNet\n",
+    "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.61 %\n",
+    "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 69.27 %\n",
+    "\n",
+    "```\n",
+    "#### ResNet\n",
+    "```\n",
+    "Adam ResNet\n",
+    "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.99 %\n",
+    "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 69.95 %\n",
+    "RMSProp ResNet\n",
+    "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 70.09 %\n",
+    "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 67.07 %\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## question (c) ablation study on batch size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-28T11:36:24.813646Z",
+     "start_time": "2025-06-28T11:36:24.803134Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def questioncbatchsize(batch_size):\n",
+    "    train_loader, valid_loader = get_train_valid_loader(\n",
+    "        data_dir=\"./data\", batch_size=batch_size, augment=False, random_seed=1,shuffle=False\n",
+    "    )\n",
+    "    print(f\"BatccSize：\"+f\" {batch_size}\")\n",
+    "    num_epochs = 10\n",
+    "    learning_rate = 0.0001\n",
+    "    num_classes = 10\n",
+    "    train_loss_history = []\n",
+    "    test_loss_history = []\n",
+    "    train_accuracy_history = []\n",
+    "    test_accuracy_history = []\n",
+    "    criterion = nn.CrossEntropyLoss()\n",
+    "    total_step = len(train_loader)\n",
+    "    resnet = ResNet(num_classes).to(device)\n",
+    "    resnet_optimizer = torch.optim.Adam(resnet.parameters(), lr=learning_rate)\n",
+    "\n",
+    "    for epoch in range(num_epochs):\n",
+    "        # Training\n",
+    "        accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "        for i, (images, labels) in enumerate(train_loader):\n",
+    "            # Move tensors to the configured device\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "\n",
+    "            # Forward pass\n",
+    "            outputs = resnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "\n",
+    "            # Backward and optimize\n",
+    "            resnet_optimizer.zero_grad()\n",
+    "            loss.backward()\n",
+    "            resnet_optimizer.step()\n",
+    "\n",
+    "            accumulate_train_loss += loss.item()\n",
+    "            num_total_train_sample += labels.size()[0]\n",
+    "            num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "        train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "        train_loss_history += [train_loss]\n",
+    "        train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "        # Validation\n",
+    "        with torch.no_grad():\n",
+    "            correct = 0\n",
+    "            total = 0\n",
+    "            accumulate_test_loss = 0\n",
+    "            for images, labels in valid_loader:\n",
+    "                images = images.to(device)\n",
+    "                labels = labels.to(device)\n",
+    "                outputs = resnet(images)\n",
+    "                loss = criterion(outputs, labels)\n",
+    "                accumulate_test_loss += loss.item()\n",
+    "                _, predicted = torch.max(outputs.data, 1)\n",
+    "                total += labels.size(0)\n",
+    "                correct += (predicted == labels).sum().item()\n",
+    "                del images, labels, outputs\n",
+    "            test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "            test_accuracy_history += [test_accuracy]\n",
+    "            test_loss_history += [test_loss]\n",
+    "        print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")\n",
+    "\n",
+    "    plt.figure(figsize=(20,10))\n",
+    "    plt.subplot(2,2,1)\n",
+    "    plt.plot(train_loss_history,label=\"Train Loss\")\n",
+    "    plt.plot(test_loss_history,label=\"Test Loss\")\n",
+    "    plt.title(\"train loss history\")\n",
+    "    plt.legend()\n",
+    "    plt.subplot(2,2,2)\n",
+    "    plt.plot(train_accuracy_history,label=\"Train Accuracy\")\n",
+    "    plt.plot(test_accuracy_history,label=\"Test Accuracy\")\n",
+    "    plt.title(\"train accuracy history\")\n",
+    "    plt.legend()\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "start_time": "2025-06-28T11:36:28.678601Z"
+    },
+    "jupyter": {
+     "is_executing": true
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "BatccSize： 8\n",
+      "2025-06-28 20:20:23.975613 - Epoch [1/10], Train Loss: 1.3601, Train Accuracy: 51.18%, Test Loss: 1.0763, Test Accuracy: 62.42%\n"
+     ]
+    }
+   ],
+   "source": [
+    "questioncbatchsize(8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "jupyter": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "questioncbatchsize(64)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "OWQ9Lrw1MbBt"
+   },
+   "source": [
+    "## Resources\n",
+    "\n",
+    "- [Writing AlexNet from Scratch in PyTorch](https://blog.paperspace.com/alexnet-pytorch/#training)\n",
+    "- [AlexNet | PyTorch](https://pytorch.org/hub/pytorch_vision_alexnet/)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "bawRnlZ4qVkh"
+   },
+   "source": [
+    "VGGNet and data totally take 13.9 GB of VRAM\n",
+    "\n",
+    "ResNet and data totally take 7.2 GB of VRAM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "oWuOLBUtqgFf",
+    "jupyter": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": [
+    {
+     "file_id": "1s8ZM5vSQQ8o3dZINdOP6GdZykzAqr-L8",
+     "timestamp": 1750346413209
+    }
+   ]
+  },
+  "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.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}