diff --git "a/Q2/.ipynb_checkpoints/Q2code-checkpoint.ipynb" "b/Q2/.ipynb_checkpoints/Q2code-checkpoint.ipynb"
new file mode 100644--- /dev/null
+++ "b/Q2/.ipynb_checkpoints/Q2code-checkpoint.ipynb"
@@ -0,0 +1,2311 @@
+{
+ "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": null,
+   "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",
+    "    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": [
+    "log backup\n",
+    "```\n",
+    "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",
+    "\n",
+    "```"
+   ]
+  },
+  {
+   "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": [
+    "log backup\n",
+    "```\n",
+    "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",
+    "```"
+   ]
+  },
+  {
+   "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": [
+    "log backup\n",
+    "```\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.14it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:09<00:00, 10.07it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:09<00:00, 10.16it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:09<00:00, 10.10it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:09<00:00, 10.08it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:09<00:00, 10.17it/s]\n",
+    "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",
+    "```"
+   ]
+  },
+  {
+   "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": [
+    "log bakup\n",
+    "```\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.53it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:06<00:00, 10.67it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:05<00:00, 10.67it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:07<00:00, 10.45it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:06<00:00, 10.54it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:05<00:00, 10.69it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:05<00:00, 10.69it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:05<00:00, 10.73it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:06<00:00, 10.60it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:06<00:00, 10.66it/s]\n",
+    "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",
+    "100%|██████████| 704/704 [01:05<00:00, 10.71it/s]\n",
+    "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",
+    "```"
+   ]
+  },
+  {
+   "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": {},
+   "source": [
+    "log backup\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",
+    "```"
+   ]
+  },
+  {
+   "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\n",
+    "batchsize 8 can reach 75.64%accuracy  valid score, and is better than 64"
+   ]
+  },
+  {
+   "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": 8,
+   "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",
+      "2025-06-28 20:23:29.446338 - Epoch [2/10], Train Loss: 0.8909, Train Accuracy: 68.38%, Test Loss: 0.8446, Test Accuracy: 70.96%\n",
+      "2025-06-28 20:26:32.895432 - Epoch [3/10], Train Loss: 0.6601, Train Accuracy: 76.41%, Test Loss: 0.7532, Test Accuracy: 73.72%\n",
+      "2025-06-28 20:29:36.662186 - Epoch [4/10], Train Loss: 0.4688, Train Accuracy: 83.26%, Test Loss: 0.7476, Test Accuracy: 75.42%\n",
+      "2025-06-28 20:32:40.067932 - Epoch [5/10], Train Loss: 0.3055, Train Accuracy: 89.09%, Test Loss: 0.7777, Test Accuracy: 75.02%\n",
+      "2025-06-28 20:35:44.318746 - Epoch [6/10], Train Loss: 0.1880, Train Accuracy: 93.41%, Test Loss: 0.9333, Test Accuracy: 74.04%\n",
+      "2025-06-28 20:38:48.287474 - Epoch [7/10], Train Loss: 0.1244, Train Accuracy: 95.67%, Test Loss: 1.0340, Test Accuracy: 74.74%\n",
+      "2025-06-28 20:41:52.425330 - Epoch [8/10], Train Loss: 0.0899, Train Accuracy: 96.98%, Test Loss: 1.0814, Test Accuracy: 75.04%\n",
+      "2025-06-28 20:44:56.668723 - Epoch [9/10], Train Loss: 0.0756, Train Accuracy: 97.43%, Test Loss: 1.1560, Test Accuracy: 74.24%\n",
+      "2025-06-28 20:48:00.780047 - Epoch [10/10], Train Loss: 0.0649, Train Accuracy: 97.81%, Test Loss: 1.1499, Test Accuracy: 75.64%\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "questioncbatchsize(8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "log backup\n",
+    "```\n",
+    "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",
+    "2025-06-28 20:23:29.446338 - Epoch [2/10], Train Loss: 0.8909, Train Accuracy: 68.38%, Test Loss: 0.8446, Test Accuracy: 70.96%\n",
+    "2025-06-28 20:26:32.895432 - Epoch [3/10], Train Loss: 0.6601, Train Accuracy: 76.41%, Test Loss: 0.7532, Test Accuracy: 73.72%\n",
+    "2025-06-28 20:29:36.662186 - Epoch [4/10], Train Loss: 0.4688, Train Accuracy: 83.26%, Test Loss: 0.7476, Test Accuracy: 75.42%\n",
+    "2025-06-28 20:32:40.067932 - Epoch [5/10], Train Loss: 0.3055, Train Accuracy: 89.09%, Test Loss: 0.7777, Test Accuracy: 75.02%\n",
+    "2025-06-28 20:35:44.318746 - Epoch [6/10], Train Loss: 0.1880, Train Accuracy: 93.41%, Test Loss: 0.9333, Test Accuracy: 74.04%\n",
+    "2025-06-28 20:38:48.287474 - Epoch [7/10], Train Loss: 0.1244, Train Accuracy: 95.67%, Test Loss: 1.0340, Test Accuracy: 74.74%\n",
+    "2025-06-28 20:41:52.425330 - Epoch [8/10], Train Loss: 0.0899, Train Accuracy: 96.98%, Test Loss: 1.0814, Test Accuracy: 75.04%\n",
+    "2025-06-28 20:44:56.668723 - Epoch [9/10], Train Loss: 0.0756, Train Accuracy: 97.43%, Test Loss: 1.1560, Test Accuracy: 74.24%\n",
+    "2025-06-28 20:48:00.780047 - Epoch [10/10], Train Loss: 0.0649, Train Accuracy: 97.81%, Test Loss: 1.1499, Test Accuracy: 75.64%\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "jupyter": {
+     "is_executing": true
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "BatccSize： 64\n",
+      "2025-06-28 20:49:15.817636 - Epoch [1/10], Train Loss: 1.4062, Train Accuracy: 49.76%, Test Loss: 1.1211, Test Accuracy: 60.16%\n",
+      "2025-06-28 20:50:29.020454 - Epoch [2/10], Train Loss: 1.0002, Train Accuracy: 64.55%, Test Loss: 0.9359, Test Accuracy: 67.20%\n",
+      "2025-06-28 20:51:42.258963 - Epoch [3/10], Train Loss: 0.7564, Train Accuracy: 73.41%, Test Loss: 0.8562, Test Accuracy: 70.14%\n",
+      "2025-06-28 20:52:55.395405 - Epoch [4/10], Train Loss: 0.5557, Train Accuracy: 80.52%, Test Loss: 0.8242, Test Accuracy: 72.02%\n",
+      "2025-06-28 20:54:08.659037 - Epoch [5/10], Train Loss: 0.3759, Train Accuracy: 87.49%, Test Loss: 0.8155, Test Accuracy: 73.54%\n",
+      "2025-06-28 20:55:22.073196 - Epoch [6/10], Train Loss: 0.2201, Train Accuracy: 93.25%, Test Loss: 0.8124, Test Accuracy: 74.58%\n",
+      "2025-06-28 20:56:35.510223 - Epoch [7/10], Train Loss: 0.1093, Train Accuracy: 97.31%, Test Loss: 0.8904, Test Accuracy: 73.90%\n",
+      "2025-06-28 20:57:48.597471 - Epoch [8/10], Train Loss: 0.0552, Train Accuracy: 98.92%, Test Loss: 0.9419, Test Accuracy: 75.20%\n",
+      "2025-06-28 20:59:01.979385 - Epoch [9/10], Train Loss: 0.0353, Train Accuracy: 99.34%, Test Loss: 1.0537, Test Accuracy: 73.14%\n",
+      "2025-06-28 21:00:15.292555 - Epoch [10/10], Train Loss: 0.0432, Train Accuracy: 98.99%, Test Loss: 1.0964, Test Accuracy: 72.60%\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "questioncbatchsize(64)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "log backup\n",
+    "```\n",
+    "BatccSize： 64\n",
+    "2025-06-28 20:49:15.817636 - Epoch [1/10], Train Loss: 1.4062, Train Accuracy: 49.76%, Test Loss: 1.1211, Test Accuracy: 60.16%\n",
+    "2025-06-28 20:50:29.020454 - Epoch [2/10], Train Loss: 1.0002, Train Accuracy: 64.55%, Test Loss: 0.9359, Test Accuracy: 67.20%\n",
+    "2025-06-28 20:51:42.258963 - Epoch [3/10], Train Loss: 0.7564, Train Accuracy: 73.41%, Test Loss: 0.8562, Test Accuracy: 70.14%\n",
+    "2025-06-28 20:52:55.395405 - Epoch [4/10], Train Loss: 0.5557, Train Accuracy: 80.52%, Test Loss: 0.8242, Test Accuracy: 72.02%\n",
+    "2025-06-28 20:54:08.659037 - Epoch [5/10], Train Loss: 0.3759, Train Accuracy: 87.49%, Test Loss: 0.8155, Test Accuracy: 73.54%\n",
+    "2025-06-28 20:55:22.073196 - Epoch [6/10], Train Loss: 0.2201, Train Accuracy: 93.25%, Test Loss: 0.8124, Test Accuracy: 74.58%\n",
+    "2025-06-28 20:56:35.510223 - Epoch [7/10], Train Loss: 0.1093, Train Accuracy: 97.31%, Test Loss: 0.8904, Test Accuracy: 73.90%\n",
+    "2025-06-28 20:57:48.597471 - Epoch [8/10], Train Loss: 0.0552, Train Accuracy: 98.92%, Test Loss: 0.9419, Test Accuracy: 75.20%\n",
+    "2025-06-28 20:59:01.979385 - Epoch [9/10], Train Loss: 0.0353, Train Accuracy: 99.34%, Test Loss: 1.0537, Test Accuracy: 73.14%\n",
+    "2025-06-28 21:00:15.292555 - Epoch [10/10], Train Loss: 0.0432, Train Accuracy: 98.99%, Test Loss: 1.0964, Test Accuracy: 72.60%\n",
+    "```"
+   ]
+  },
+  {
+   "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
+}