MiniProject_Pytorch_Version4F(91_650,pat30) .ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fTsVmnn5cBNf"
      },
      "outputs": [],
      "source": [
        "\n",
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "\n",
        "class ResNet(nn.Module):\n",
        "    def __init__(self, num_classes=10):\n",
        "        super(ResNet, self).__init__()\n",
        "\n",
        "        # Initial convolution layer with 3 input channels, 64 output channels, 3x3 kernel size, stride 1, padding 1, and no bias\n",
        "        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        # Batch normalization layer with 64 output channels\n",
        "        self.bn1 = nn.BatchNorm2d(64)\n",
        "        # ReLU activation function\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "\n",
        "        # Residual blocks\n",
        "        # First residual block with 64 input channels, 128 output channels, stride 2, and 2 blocks\n",
        "        self.layer1 = self._make_layer(64, 128, 2, stride=2)\n",
        "        # Second residual block with 128 input and output channels, stride 1, and 2 blocks\n",
        "        self.layer2 = self._make_layer(128, 128, 2, stride=1)\n",
        "        # Third residual block with 128 input channels, 256 output channels, stride 2, and 2 blocks\n",
        "        self.layer3= self._make_layer(128, 256, 2, stride=2)\n",
        "\n",
        "        # Average pooling layer with output size of 1x1\n",
        "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
        "        # Fully connected layer with 256 input features and num_classes output features\n",
        "        self.fc = nn.Linear(256, num_classes)\n",
        "\n",
        "    def _make_layer(self, in_channels, out_channels, num_blocks, stride):\n",
        "        # List to store the layers in the residual block\n",
        "        layers = []\n",
        "        # First layer in the residual block is a ResidualBlock module with in_channels input channels, out_channels output channels, and stride stride\n",
        "        layers.append(ResidualBlock(in_channels, out_channels, stride))\n",
        "        # Add num_blocks - 1 more ResidualBlock modules with out_channels input and output channels, and stride 1\n",
        "        for i in range(1, num_blocks):\n",
        "            layers.append(ResidualBlock(out_channels, out_channels, 1))\n",
        "        # Return a sequential module with all the layers in the residual block\n",
        "        return nn.Sequential(*layers)\n",
        "\n",
        "    def forward(self, x):\n",
        "        # Initial convolution layer, followed by batch normalization and ReLU activation\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        # Residual blocks\n",
        "        # Apply each residual block in turn\n",
        "        x = self.layer1(x)\n",
        "        x = self.layer2(x)\n",
        "        x = self.layer3(x)\n",
        "\n",
        "        # Average pooling and fully-connected layer\n",
        "        # Apply the adaptive average pooling layer to get a 1x1 output\n",
        "        x = self.avgpool(x)\n",
        "        # Flatten the output\n",
        "        x = x.view(x.size(0), -1)\n",
        "        # Apply the fully connected layer to get the output scores\n",
        "        x = self.fc(x)\n",
        "\n",
        "        return x\n"
      ],
      "metadata": {
        "id": "kfpGSDwQcVSj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class ResidualBlock(nn.Module):\n",
        "    def __init__(self, in_channels, out_channels, stride):\n",
        "        super(ResidualBlock, self).__init__()\n",
        "\n",
        "        # First convolutional layer\n",
        "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "\n",
        "        # Second convolutional layer\n",
        "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "\n",
        "        # Third convolutional layer\n",
        "        self.conv3 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn3 = nn.BatchNorm2d(out_channels)\n",
        "        \n",
        "        # Stride value\n",
        "        self.stride = stride\n",
        "\n",
        "        # Skip connection\n",
        "        if stride != 1 or in_channels != out_channels:\n",
        "            # If the number of channels or stride changes, use a convolutional layer for the skip connection\n",
        "            self.skip = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False)\n",
        "        else:\n",
        "            # If the number of channels and stride remain the same, use an identity function for the skip connection\n",
        "            self.skip = nn.Identity()\n",
        "\n",
        "    def forward(self, x):\n",
        "        # Save the original input tensor for the skip connection\n",
        "        identity = self.skip(x)\n",
        "\n",
        "        # First residual block\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        # Second residual block\n",
        "        x = self.conv2(x)\n",
        "        x = self.bn2(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        # Third residual block\n",
        "        x = self.conv3(x)\n",
        "        x = self.bn3(x)\n",
        "        \n",
        "        # Add the original input tensor to the output of the final residual block\n",
        "        x += identity\n",
        "        x = self.relu(x)\n",
        "\n",
        "        # Return the output tensor\n",
        "        return x\n"
      ],
      "metadata": {
        "id": "h5ACrP7RdtIl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this code, PyTorch's transforms module is used to define two different sets of image transformations: one for the training set and another for the test set.\n",
        "\n",
        "The transform_train transform includes the following steps:\n",
        "\n",
        "RandomCrop: randomly crops a 32x32 pixel region from the input image and pads the edges with 4 pixels. This is a form of data augmentation that helps prevent overfitting by creating variations of the same image.\n",
        "RandomHorizontalFlip: randomly flips the image horizontally with a 50% probability. This is another form of data augmentation that helps prevent overfitting by creating mirror images of the same object.\n",
        "ToTensor: converts the image from a NumPy array to a PyTorch tensor, which is the preferred data type for PyTorch models.\n",
        "Normalize: normalizes the tensor by subtracting the mean and dividing by the standard deviation. This step helps improve the convergence of the training algorithm by keeping the values in a reasonable range. The mean and standard deviation values used here are based on the statistics of the CIFAR-10 dataset, which is the dataset that this code is designed to work with."
      ],
      "metadata": {
        "id": "1JrsHgbTkDMB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# Define transform for the training set\n",
        "transform_train = transforms.Compose([\n",
        "    # Apply a random crop to the image, padding the edges by 4 pixels\n",
        "    transforms.RandomCrop(32, padding=4),\n",
        "    # Apply a random horizontal flip to the image\n",
        "    transforms.RandomHorizontalFlip(),\n",
        "    # Convert the image to a PyTorch tensor\n",
        "    transforms.ToTensor(),\n",
        "    # Normalize the tensor by subtracting the mean and dividing by the standard deviation\n",
        "    transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\n",
        "])\n",
        "\n",
        "# Define transform for the test set\n",
        "transform_test = transforms.Compose([\n",
        "    # Convert the image to a PyTorch tensor\n",
        "    transforms.ToTensor(),\n",
        "    # Normalize the tensor by subtracting the mean and dividing by the standard deviation\n",
        "    transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\n",
        "])\n"
      ],
      "metadata": {
        "id": "CKMsKu8weCBn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this code, the CIFAR-10 dataset is loaded into PyTorch tensors using the torchvision.datasets.CIFAR10 class. The dataset is split into three parts: a training set, a validation set, and a test set. Each set is loaded using a DataLoader object, which allows us to iterate over the dataset in batches during training.\n",
        "\n",
        "The trainset variable is initialized with the specified transform_train transform, which applies data augmentation to the images in the training set. The trainloader object is then created with a batch size of 128, and the shuffle parameter set to True, which shuffles the images at the beginning of each epoch to prevent the model from overfitting.\n",
        "\n",
        "The valset and testset variables are initialized with the transform_test transform, which normalizes the images without applying any data augmentation. The valloader and testloader objects are created with the same batch size and number of workers as trainloader, but with shuffle set to False, since we do not need to shuffle the images during validation or testing."
      ],
      "metadata": {
        "id": "zPwf22ZRkPe0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the CIFAR-10 dataset\n",
        "\n",
        "# Load the training set with the specified transforms, batch size, and number of workers for parallel data loading\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)\n",
        "\n",
        "# Load the validation set with the specified transforms, batch size, and number of workers for parallel data loading\n",
        "valset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n",
        "valloader = torch.utils.data.DataLoader(valset, batch_size=128, shuffle=False, num_workers=2)\n",
        "\n",
        "# Load the test set with the specified transforms, batch size, and number of workers for parallel data loading\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False, num_workers=2)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VsNteURCeeKV",
        "outputId": "b835ccb4-ed23-4366-be9e-9798a2b47d45"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 170498071/170498071 [00:04<00:00, 37915306.16it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/cifar-10-python.tar.gz to ./data\n",
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the ResNet model\n",
        "\n",
        "# Set the device to use for training and inference. If a CUDA-enabled GPU is available, use it, otherwise use the CPU\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(device)\n",
        "\n",
        "# Set the learning rate to use for optimization\n",
        "lr = 0.001\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-bmOjHK3e8iG",
        "outputId": "193f78b6-93a6-4a13-9377-730066fbff87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This code block trains a neural network model using the CIFAR-10 dataset with the ResNet architecture and Adam optimizer. The model is trained with early stopping based on the validation accuracy.\n",
        "\n",
        "The ResNet model is created and moved to the device (e.g., CPU or GPU) where the training will occur. The optimizer is defined as Adam with the specified learning rate. The loss function is set as CrossEntropyLoss.\n",
        "\n",
        "The training loop runs for a maximum of 300 epochs. For each epoch, the training data is loaded in batches using a DataLoader, and the model parameters are updated using backpropagation. The loss and accuracy are calculated for the training set for each epoch.\n",
        "\n",
        "The validation accuracy is calculated for each epoch using the validation set. If the validation accuracy improves from the previous epoch, the model state is saved as the best model state. If there is no improvement in the validation accuracy for a number of epochs (determined by the patience parameter), training is stopped early.\n",
        "\n",
        "After training, the saved best model state is loaded, and the accuracy is calculated using the test set. The number of parameters in the model is also printed.\n",
        "\n",
        "Overall, this code block demonstrates the process of training a neural network model on a dataset with early stopping and calculating accuracy metrics."
      ],
      "metadata": {
        "id": "8qW3lpKFkb5-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize lists to store accuracy and loss values\n",
        "train_acc_list = []\n",
        "val_acc_list = []\n",
        "train_loss_list = []\n",
        "val_loss_list = []\n",
        "\n",
        "# Train the model using Adam optimizer with early stopping\n",
        "net = ResNet().to(device)\n",
        "optimizer = torch.optim.Adam(net.parameters(), lr=lr)\n",
        "# Define loss function\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "print(\"\\nTraining model with Adam optimizer...\\n\")\n",
        "best_accuracy = 0.000\n",
        "best_state_dict = None\n",
        "patience = 30 # number of epochs to wait before stopping if val_accuracy doesn't improve\n",
        "counter = 0 # counter for number of epochs without improvement in val_accuracy\n",
        "for epoch in range(300):\n",
        "    running_loss = 0.0\n",
        "    train_correct = 0\n",
        "    train_total = 0\n",
        "  \n",
        "    net.train() # set the model to training mode\n",
        "    for i, data in enumerate(trainloader, 0): # iterate over the training data\n",
        "        inputs, labels = data[0].to(device), data[1].to(device) # move the input data and the labels to the device\n",
        "\n",
        "        optimizer.zero_grad() # zero out the gradients of the optimizer\n",
        "\n",
        "        outputs = net(inputs) # compute the model outputs\n",
        "        loss = criterion(outputs, labels) # compute the loss between the outputs and the labels\n",
        "        loss.backward() # compute the gradients of the loss\n",
        "        optimizer.step() # update the model weights using the optimizer\n",
        "\n",
        "        running_loss += loss.item() # accumulate the loss\n",
        "        _, predicted = torch.max(outputs.data, 1) # get the predicted labels from the model outputs\n",
        "        train_total += labels.size(0) # increment the total number of samples during training\n",
        "        train_correct += (predicted == labels).sum().item() # increment the number of correct predictions during training\n",
        "\n",
        "    epoch_train_loss = running_loss / len(trainloader) # compute the average loss during training\n",
        "    epoch_train_accuracy = 100 * train_correct / train_total # compute the accuracy during training\n",
        "\n",
        "    # Calculate validation accuracy\n",
        "     \n",
        "    net.eval() # set the model to evaluation mode\n",
        "    val_correct = 0 # initialize the number of correct predictions during validation to 0\n",
        "    val_total = 0 # initialize the total number of samples during validation to 0\n",
        "    with torch.no_grad(): # disable gradient computation during validation\n",
        "        for data in valloader: # iterate over the validation data\n",
        "          images, labels = data[0].to(device), data[1].to(device) # move the input data and the labels to the device\n",
        "          outputs = net(images) # compute the model outputs\n",
        "          _, predicted = torch.max(outputs.data, 1) # get the predicted labels from the model outputs\n",
        "          val_total += labels.size(0) # increment the total number of samples during validation\n",
        "          val_correct += (predicted == labels).sum().item() # increment the number of correct predictions during validation\n",
        "      val_accuracy = 100 * val_correct / val_total # compute the accuracy during validation \n",
        "      val_loss = criterion(outputs, labels)\n",
        "\n",
        "    # Save the accuracy and loss values for plotting\n",
        "    train_acc_list.append(epoch_train_accuracy) # append the training accuracy of current epoch to the list\n",
        "    val_acc_list.append(val_accuracy) # append the validation accuracy of current epoch to the list\n",
        "    train_loss_list.append(epoch_train_loss) # append the training loss of current epoch to the list\n",
        "    val_loss_list.append(val_loss) # append the validation loss of current epoch to the list\n",
        "\n",
        "    # Save the model state with the best validation accuracy\n",
        "    if val_accuracy > best_accuracy:\n",
        "        best_accuracy = val_accuracy\n",
        "        best_state_dict = net.state_dict()\n",
        "        counter = 0 # reset counter since there was improvement in val_accuracy\n",
        "    else:\n",
        "        counter += 1 # increment counter since there was no improvement in val_accuracy\n",
        "\n",
        "    print('Epoch %d: train_loss=%.3f, train_accuracy=%.3f, val_accuracy=%.3f, val_loss=%.3f' % (epoch + 1, epoch_train_loss, epoch_train_accuracy, val_accuracy,val_loss))\n",
        "\n",
        "    # Check if early stopping criteria has been met\n",
        "    if counter >= patience:\n",
        "        print(\"No improvement in validation accuracy for %d epochs. Stopping early.\" % patience)\n",
        "        break\n",
        "\n",
        "\n",
        "# Evaluate the test accuracy using the saved model state\n",
        "# Load the saved model state with the best validation accuracy\n",
        "net.load_state_dict(best_state_dict)\n",
        "\n",
        "# Initialize variables for test accuracy calculation\n",
        "test_correct = 0\n",
        "test_total = 0\n",
        "\n",
        "\n",
        "\n",
        "# Disable gradient calculation for faster computation and reduced memory usage\n",
        "with torch.no_grad():\n",
        "    # Loop through the test data\n",
        "    for data in testloader:\n",
        "        # Get the images and labels from the test data\n",
        "        images, labels = data[0].to(device), data[1].to(device)\n",
        "        # Forward pass the images through the network to get the outputs\n",
        "        outputs = net(images)\n",
        "        # Get the predicted labels by taking the index of the maximum value in each output tensor\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        # Calculate the number of correct predictions and the total number of predictions\n",
        "        test_total += labels.size(0)\n",
        "        test_correct += (predicted == labels).sum().item()\n",
        "\n",
        "# Calculate the test accuracy as the percentage of correct predictions\n",
        "test_accuracy = 100 * test_correct / test_total\n",
        "\n",
        "# Print the test accuracy\n",
        "print('Test accuracy: %.3f' % test_accuracy)\n",
        "\n",
        "# Count the number of trainable parameters in the network\n",
        "num_params = sum(p.numel() for p in net.parameters())\n",
        "print(\"\\nNumber of parameters: \", num_params)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "svKn-z2He-IO",
        "outputId": "9d15218c-3ba8-456b-c87d-2c38d408b728"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Training model with Adam optimizer...\n",
            "\n",
            "Epoch 1: train_loss=1.510, train_accuracy=43.644, val_accuracy=50.780, val_loss=1.247\n",
            "Epoch 2: train_loss=1.048, train_accuracy=62.342, val_accuracy=65.790, val_loss=0.898\n",
            "Epoch 3: train_loss=0.849, train_accuracy=69.938, val_accuracy=68.620, val_loss=0.942\n",
            "Epoch 4: train_loss=0.721, train_accuracy=74.784, val_accuracy=74.740, val_loss=0.657\n",
            "Epoch 5: train_loss=0.616, train_accuracy=78.608, val_accuracy=76.570, val_loss=0.861\n",
            "Epoch 6: train_loss=0.547, train_accuracy=81.026, val_accuracy=77.360, val_loss=0.978\n",
            "Epoch 7: train_loss=0.501, train_accuracy=82.668, val_accuracy=81.240, val_loss=0.545\n",
            "Epoch 8: train_loss=0.455, train_accuracy=84.246, val_accuracy=81.690, val_loss=0.530\n",
            "Epoch 9: train_loss=0.418, train_accuracy=85.544, val_accuracy=83.870, val_loss=0.504\n",
            "Epoch 10: train_loss=0.384, train_accuracy=86.772, val_accuracy=84.660, val_loss=0.408\n",
            "Epoch 11: train_loss=0.356, train_accuracy=87.876, val_accuracy=84.200, val_loss=0.477\n",
            "Epoch 12: train_loss=0.329, train_accuracy=88.430, val_accuracy=84.730, val_loss=0.621\n",
            "Epoch 13: train_loss=0.312, train_accuracy=89.210, val_accuracy=86.220, val_loss=0.287\n",
            "Epoch 14: train_loss=0.284, train_accuracy=90.030, val_accuracy=85.410, val_loss=0.474\n",
            "Epoch 15: train_loss=0.273, train_accuracy=90.636, val_accuracy=88.180, val_loss=0.583\n",
            "Epoch 16: train_loss=0.255, train_accuracy=91.088, val_accuracy=87.630, val_loss=0.446\n",
            "Epoch 17: train_loss=0.234, train_accuracy=91.848, val_accuracy=86.450, val_loss=0.683\n",
            "Epoch 18: train_loss=0.223, train_accuracy=92.112, val_accuracy=88.660, val_loss=0.538\n",
            "Epoch 19: train_loss=0.211, train_accuracy=92.682, val_accuracy=87.870, val_loss=0.670\n",
            "Epoch 20: train_loss=0.193, train_accuracy=93.254, val_accuracy=87.470, val_loss=0.280\n",
            "Epoch 21: train_loss=0.184, train_accuracy=93.594, val_accuracy=89.240, val_loss=0.728\n",
            "Epoch 22: train_loss=0.174, train_accuracy=93.868, val_accuracy=89.010, val_loss=0.644\n",
            "Epoch 23: train_loss=0.163, train_accuracy=94.370, val_accuracy=88.210, val_loss=0.541\n",
            "Epoch 24: train_loss=0.153, train_accuracy=94.506, val_accuracy=89.000, val_loss=0.527\n",
            "Epoch 25: train_loss=0.144, train_accuracy=94.982, val_accuracy=87.180, val_loss=0.386\n",
            "Epoch 26: train_loss=0.135, train_accuracy=95.312, val_accuracy=88.360, val_loss=0.733\n",
            "Epoch 27: train_loss=0.127, train_accuracy=95.374, val_accuracy=89.670, val_loss=0.424\n",
            "Epoch 28: train_loss=0.124, train_accuracy=95.580, val_accuracy=89.790, val_loss=0.637\n",
            "Epoch 29: train_loss=0.114, train_accuracy=95.970, val_accuracy=88.780, val_loss=0.653\n",
            "Epoch 30: train_loss=0.114, train_accuracy=96.022, val_accuracy=89.630, val_loss=0.407\n",
            "Epoch 31: train_loss=0.108, train_accuracy=96.182, val_accuracy=89.910, val_loss=0.493\n",
            "Epoch 32: train_loss=0.098, train_accuracy=96.502, val_accuracy=88.970, val_loss=0.982\n",
            "Epoch 33: train_loss=0.096, train_accuracy=96.622, val_accuracy=89.950, val_loss=0.894\n",
            "Epoch 34: train_loss=0.089, train_accuracy=96.820, val_accuracy=89.580, val_loss=0.879\n",
            "Epoch 35: train_loss=0.088, train_accuracy=96.846, val_accuracy=89.630, val_loss=0.649\n",
            "Epoch 36: train_loss=0.080, train_accuracy=97.168, val_accuracy=90.020, val_loss=0.506\n",
            "Epoch 37: train_loss=0.079, train_accuracy=97.120, val_accuracy=90.270, val_loss=0.843\n",
            "Epoch 38: train_loss=0.076, train_accuracy=97.344, val_accuracy=89.460, val_loss=1.106\n",
            "Epoch 39: train_loss=0.073, train_accuracy=97.454, val_accuracy=89.970, val_loss=0.703\n",
            "Epoch 40: train_loss=0.072, train_accuracy=97.442, val_accuracy=89.180, val_loss=0.950\n",
            "Epoch 41: train_loss=0.068, train_accuracy=97.592, val_accuracy=90.230, val_loss=0.800\n",
            "Epoch 42: train_loss=0.067, train_accuracy=97.654, val_accuracy=90.110, val_loss=0.864\n",
            "Epoch 43: train_loss=0.066, train_accuracy=97.668, val_accuracy=90.160, val_loss=0.707\n",
            "Epoch 44: train_loss=0.064, train_accuracy=97.710, val_accuracy=90.240, val_loss=0.780\n",
            "Epoch 45: train_loss=0.062, train_accuracy=97.760, val_accuracy=90.540, val_loss=0.882\n",
            "Epoch 46: train_loss=0.058, train_accuracy=98.032, val_accuracy=90.460, val_loss=0.793\n",
            "Epoch 47: train_loss=0.049, train_accuracy=98.252, val_accuracy=89.610, val_loss=0.597\n",
            "Epoch 48: train_loss=0.058, train_accuracy=97.962, val_accuracy=90.630, val_loss=0.905\n",
            "Epoch 49: train_loss=0.053, train_accuracy=98.156, val_accuracy=90.300, val_loss=0.827\n",
            "Epoch 50: train_loss=0.052, train_accuracy=98.224, val_accuracy=90.310, val_loss=0.910\n",
            "Epoch 51: train_loss=0.054, train_accuracy=98.150, val_accuracy=90.630, val_loss=0.936\n",
            "Epoch 52: train_loss=0.053, train_accuracy=98.114, val_accuracy=90.240, val_loss=0.911\n",
            "Epoch 53: train_loss=0.043, train_accuracy=98.462, val_accuracy=90.510, val_loss=1.001\n",
            "Epoch 54: train_loss=0.048, train_accuracy=98.352, val_accuracy=90.650, val_loss=0.747\n",
            "Epoch 55: train_loss=0.052, train_accuracy=98.156, val_accuracy=89.910, val_loss=0.468\n",
            "Epoch 56: train_loss=0.041, train_accuracy=98.572, val_accuracy=89.670, val_loss=0.924\n",
            "Epoch 57: train_loss=0.043, train_accuracy=98.532, val_accuracy=90.350, val_loss=0.905\n",
            "Epoch 58: train_loss=0.043, train_accuracy=98.550, val_accuracy=90.800, val_loss=0.965\n",
            "Epoch 59: train_loss=0.041, train_accuracy=98.554, val_accuracy=90.600, val_loss=0.771\n",
            "Epoch 60: train_loss=0.044, train_accuracy=98.502, val_accuracy=90.590, val_loss=0.920\n",
            "Epoch 61: train_loss=0.037, train_accuracy=98.660, val_accuracy=90.840, val_loss=0.641\n",
            "Epoch 62: train_loss=0.041, train_accuracy=98.592, val_accuracy=90.770, val_loss=0.845\n",
            "Epoch 63: train_loss=0.035, train_accuracy=98.778, val_accuracy=90.950, val_loss=0.741\n",
            "Epoch 64: train_loss=0.038, train_accuracy=98.646, val_accuracy=91.040, val_loss=0.628\n",
            "Epoch 65: train_loss=0.040, train_accuracy=98.590, val_accuracy=90.670, val_loss=1.051\n",
            "Epoch 66: train_loss=0.033, train_accuracy=98.866, val_accuracy=91.050, val_loss=0.825\n",
            "Epoch 67: train_loss=0.041, train_accuracy=98.620, val_accuracy=90.350, val_loss=0.844\n",
            "Epoch 68: train_loss=0.038, train_accuracy=98.712, val_accuracy=91.330, val_loss=0.842\n",
            "Epoch 69: train_loss=0.033, train_accuracy=98.846, val_accuracy=90.270, val_loss=1.208\n",
            "Epoch 70: train_loss=0.031, train_accuracy=98.972, val_accuracy=90.460, val_loss=0.988\n",
            "Epoch 71: train_loss=0.035, train_accuracy=98.712, val_accuracy=90.530, val_loss=0.828\n",
            "Epoch 72: train_loss=0.035, train_accuracy=98.730, val_accuracy=90.850, val_loss=0.955\n",
            "Epoch 73: train_loss=0.034, train_accuracy=98.778, val_accuracy=90.460, val_loss=0.441\n",
            "Epoch 74: train_loss=0.033, train_accuracy=98.838, val_accuracy=90.590, val_loss=0.861\n",
            "Epoch 75: train_loss=0.031, train_accuracy=98.916, val_accuracy=91.210, val_loss=0.630\n",
            "Epoch 76: train_loss=0.024, train_accuracy=99.148, val_accuracy=90.750, val_loss=1.001\n",
            "Epoch 77: train_loss=0.035, train_accuracy=98.822, val_accuracy=91.150, val_loss=0.701\n",
            "Epoch 78: train_loss=0.034, train_accuracy=98.874, val_accuracy=90.720, val_loss=0.710\n",
            "Epoch 79: train_loss=0.027, train_accuracy=99.062, val_accuracy=91.270, val_loss=1.218\n",
            "Epoch 80: train_loss=0.028, train_accuracy=99.028, val_accuracy=90.970, val_loss=1.182\n",
            "Epoch 81: train_loss=0.024, train_accuracy=99.170, val_accuracy=90.970, val_loss=0.927\n",
            "Epoch 82: train_loss=0.034, train_accuracy=98.820, val_accuracy=90.840, val_loss=1.325\n",
            "Epoch 83: train_loss=0.029, train_accuracy=98.958, val_accuracy=90.890, val_loss=0.536\n",
            "Epoch 84: train_loss=0.026, train_accuracy=99.122, val_accuracy=90.890, val_loss=1.142\n",
            "Epoch 85: train_loss=0.026, train_accuracy=99.134, val_accuracy=91.250, val_loss=1.037\n",
            "Epoch 86: train_loss=0.027, train_accuracy=99.074, val_accuracy=91.060, val_loss=0.319\n",
            "Epoch 87: train_loss=0.024, train_accuracy=99.194, val_accuracy=91.130, val_loss=0.496\n",
            "Epoch 88: train_loss=0.028, train_accuracy=99.012, val_accuracy=90.270, val_loss=1.534\n",
            "Epoch 89: train_loss=0.024, train_accuracy=99.182, val_accuracy=90.400, val_loss=1.180\n",
            "Epoch 90: train_loss=0.026, train_accuracy=99.170, val_accuracy=91.440, val_loss=1.120\n",
            "Epoch 91: train_loss=0.026, train_accuracy=99.084, val_accuracy=91.270, val_loss=1.003\n",
            "Epoch 92: train_loss=0.023, train_accuracy=99.228, val_accuracy=91.270, val_loss=0.849\n",
            "Epoch 93: train_loss=0.026, train_accuracy=99.140, val_accuracy=91.130, val_loss=0.656\n",
            "Epoch 94: train_loss=0.023, train_accuracy=99.218, val_accuracy=91.300, val_loss=0.668\n",
            "Epoch 95: train_loss=0.023, train_accuracy=99.190, val_accuracy=90.160, val_loss=1.130\n",
            "Epoch 96: train_loss=0.023, train_accuracy=99.192, val_accuracy=90.710, val_loss=1.141\n",
            "Epoch 97: train_loss=0.025, train_accuracy=99.134, val_accuracy=90.560, val_loss=1.035\n",
            "Epoch 98: train_loss=0.023, train_accuracy=99.172, val_accuracy=90.990, val_loss=0.748\n",
            "Epoch 99: train_loss=0.020, train_accuracy=99.332, val_accuracy=90.990, val_loss=1.657\n",
            "Epoch 100: train_loss=0.023, train_accuracy=99.210, val_accuracy=90.600, val_loss=0.817\n",
            "Epoch 101: train_loss=0.024, train_accuracy=99.200, val_accuracy=90.940, val_loss=0.911\n",
            "Epoch 102: train_loss=0.020, train_accuracy=99.360, val_accuracy=91.260, val_loss=1.072\n",
            "Epoch 103: train_loss=0.022, train_accuracy=99.274, val_accuracy=91.670, val_loss=1.016\n",
            "Epoch 104: train_loss=0.017, train_accuracy=99.392, val_accuracy=90.800, val_loss=1.113\n",
            "Epoch 105: train_loss=0.023, train_accuracy=99.250, val_accuracy=90.510, val_loss=2.179\n",
            "Epoch 106: train_loss=0.023, train_accuracy=99.226, val_accuracy=90.930, val_loss=1.011\n",
            "Epoch 107: train_loss=0.021, train_accuracy=99.276, val_accuracy=91.400, val_loss=1.002\n",
            "Epoch 108: train_loss=0.020, train_accuracy=99.294, val_accuracy=90.940, val_loss=0.853\n",
            "Epoch 109: train_loss=0.019, train_accuracy=99.374, val_accuracy=91.230, val_loss=1.088\n",
            "Epoch 110: train_loss=0.020, train_accuracy=99.324, val_accuracy=91.070, val_loss=0.702\n",
            "Epoch 111: train_loss=0.020, train_accuracy=99.332, val_accuracy=91.200, val_loss=0.167\n",
            "Epoch 112: train_loss=0.019, train_accuracy=99.306, val_accuracy=91.550, val_loss=0.916\n",
            "Epoch 113: train_loss=0.020, train_accuracy=99.306, val_accuracy=91.300, val_loss=0.746\n",
            "Epoch 114: train_loss=0.020, train_accuracy=99.260, val_accuracy=91.320, val_loss=0.387\n",
            "Epoch 115: train_loss=0.019, train_accuracy=99.366, val_accuracy=90.960, val_loss=1.052\n",
            "Epoch 116: train_loss=0.020, train_accuracy=99.292, val_accuracy=91.060, val_loss=1.382\n",
            "Epoch 117: train_loss=0.016, train_accuracy=99.428, val_accuracy=91.240, val_loss=1.134\n",
            "Epoch 118: train_loss=0.016, train_accuracy=99.456, val_accuracy=91.130, val_loss=0.874\n",
            "Epoch 119: train_loss=0.017, train_accuracy=99.434, val_accuracy=90.950, val_loss=0.978\n",
            "Epoch 120: train_loss=0.022, train_accuracy=99.236, val_accuracy=90.890, val_loss=0.567\n",
            "Epoch 121: train_loss=0.019, train_accuracy=99.344, val_accuracy=91.590, val_loss=0.633\n",
            "Epoch 122: train_loss=0.017, train_accuracy=99.418, val_accuracy=91.250, val_loss=0.886\n",
            "Epoch 123: train_loss=0.019, train_accuracy=99.382, val_accuracy=91.190, val_loss=0.782\n",
            "Epoch 124: train_loss=0.015, train_accuracy=99.514, val_accuracy=90.960, val_loss=0.983\n",
            "Epoch 125: train_loss=0.017, train_accuracy=99.364, val_accuracy=91.350, val_loss=0.955\n",
            "Epoch 126: train_loss=0.016, train_accuracy=99.476, val_accuracy=91.010, val_loss=1.055\n",
            "Epoch 127: train_loss=0.020, train_accuracy=99.288, val_accuracy=90.860, val_loss=0.534\n",
            "Epoch 128: train_loss=0.017, train_accuracy=99.382, val_accuracy=91.480, val_loss=0.501\n",
            "Epoch 129: train_loss=0.019, train_accuracy=99.376, val_accuracy=91.190, val_loss=1.013\n",
            "Epoch 130: train_loss=0.017, train_accuracy=99.434, val_accuracy=90.970, val_loss=0.966\n",
            "Epoch 131: train_loss=0.014, train_accuracy=99.540, val_accuracy=91.130, val_loss=1.415\n",
            "Epoch 132: train_loss=0.017, train_accuracy=99.412, val_accuracy=91.660, val_loss=1.607\n",
            "Epoch 133: train_loss=0.016, train_accuracy=99.480, val_accuracy=91.650, val_loss=1.135\n",
            "No improvement in validation accuracy for 30 epochs. Stopping early.\n",
            "Test accuracy: 91.650\n",
            "\n",
            "Number of parameters:  4991306\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from torchsummary import summary\n",
        "net = ResNet().to(device)\n",
        "summary(net, input_size=(3, 32, 32))"
      ],
      "metadata": {
        "id": "IJYAkL6gu40q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3618ec09-222f-49ac-9bd9-0425d65a0cfe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Conv2d-1           [-1, 64, 32, 32]           1,728\n",
            "       BatchNorm2d-2           [-1, 64, 32, 32]             128\n",
            "              ReLU-3           [-1, 64, 32, 32]               0\n",
            "            Conv2d-4          [-1, 128, 16, 16]           8,192\n",
            "            Conv2d-5          [-1, 128, 16, 16]          73,728\n",
            "       BatchNorm2d-6          [-1, 128, 16, 16]             256\n",
            "              ReLU-7          [-1, 128, 16, 16]               0\n",
            "            Conv2d-8          [-1, 128, 16, 16]         147,456\n",
            "       BatchNorm2d-9          [-1, 128, 16, 16]             256\n",
            "             ReLU-10          [-1, 128, 16, 16]               0\n",
            "           Conv2d-11          [-1, 128, 16, 16]         147,456\n",
            "      BatchNorm2d-12          [-1, 128, 16, 16]             256\n",
            "             ReLU-13          [-1, 128, 16, 16]               0\n",
            "    ResidualBlock-14          [-1, 128, 16, 16]               0\n",
            "         Identity-15          [-1, 128, 16, 16]               0\n",
            "           Conv2d-16          [-1, 128, 16, 16]         147,456\n",
            "      BatchNorm2d-17          [-1, 128, 16, 16]             256\n",
            "             ReLU-18          [-1, 128, 16, 16]               0\n",
            "           Conv2d-19          [-1, 128, 16, 16]         147,456\n",
            "      BatchNorm2d-20          [-1, 128, 16, 16]             256\n",
            "             ReLU-21          [-1, 128, 16, 16]               0\n",
            "           Conv2d-22          [-1, 128, 16, 16]         147,456\n",
            "      BatchNorm2d-23          [-1, 128, 16, 16]             256\n",
            "             ReLU-24          [-1, 128, 16, 16]               0\n",
            "    ResidualBlock-25          [-1, 128, 16, 16]               0\n",
            "         Identity-26          [-1, 128, 16, 16]               0\n",
            "           Conv2d-27          [-1, 128, 16, 16]         147,456\n",
            "      BatchNorm2d-28          [-1, 128, 16, 16]             256\n",
            "             ReLU-29          [-1, 128, 16, 16]               0\n",
            "           Conv2d-30          [-1, 128, 16, 16]         147,456\n",
            "      BatchNorm2d-31          [-1, 128, 16, 16]             256\n",
            "             ReLU-32          [-1, 128, 16, 16]               0\n",
            "           Conv2d-33          [-1, 128, 16, 16]         147,456\n",
            "      BatchNorm2d-34          [-1, 128, 16, 16]             256\n",
            "             ReLU-35          [-1, 128, 16, 16]               0\n",
            "    ResidualBlock-36          [-1, 128, 16, 16]               0\n",
            "         Identity-37          [-1, 128, 16, 16]               0\n",
            "           Conv2d-38          [-1, 128, 16, 16]         147,456\n",
            "      BatchNorm2d-39          [-1, 128, 16, 16]             256\n",
            "             ReLU-40          [-1, 128, 16, 16]               0\n",
            "           Conv2d-41          [-1, 128, 16, 16]         147,456\n",
            "      BatchNorm2d-42          [-1, 128, 16, 16]             256\n",
            "             ReLU-43          [-1, 128, 16, 16]               0\n",
            "           Conv2d-44          [-1, 128, 16, 16]         147,456\n",
            "      BatchNorm2d-45          [-1, 128, 16, 16]             256\n",
            "             ReLU-46          [-1, 128, 16, 16]               0\n",
            "    ResidualBlock-47          [-1, 128, 16, 16]               0\n",
            "           Conv2d-48            [-1, 256, 8, 8]          32,768\n",
            "           Conv2d-49            [-1, 256, 8, 8]         294,912\n",
            "      BatchNorm2d-50            [-1, 256, 8, 8]             512\n",
            "             ReLU-51            [-1, 256, 8, 8]               0\n",
            "           Conv2d-52            [-1, 256, 8, 8]         589,824\n",
            "      BatchNorm2d-53            [-1, 256, 8, 8]             512\n",
            "             ReLU-54            [-1, 256, 8, 8]               0\n",
            "           Conv2d-55            [-1, 256, 8, 8]         589,824\n",
            "      BatchNorm2d-56            [-1, 256, 8, 8]             512\n",
            "             ReLU-57            [-1, 256, 8, 8]               0\n",
            "    ResidualBlock-58            [-1, 256, 8, 8]               0\n",
            "         Identity-59            [-1, 256, 8, 8]               0\n",
            "           Conv2d-60            [-1, 256, 8, 8]         589,824\n",
            "      BatchNorm2d-61            [-1, 256, 8, 8]             512\n",
            "             ReLU-62            [-1, 256, 8, 8]               0\n",
            "           Conv2d-63            [-1, 256, 8, 8]         589,824\n",
            "      BatchNorm2d-64            [-1, 256, 8, 8]             512\n",
            "             ReLU-65            [-1, 256, 8, 8]               0\n",
            "           Conv2d-66            [-1, 256, 8, 8]         589,824\n",
            "      BatchNorm2d-67            [-1, 256, 8, 8]             512\n",
            "             ReLU-68            [-1, 256, 8, 8]               0\n",
            "    ResidualBlock-69            [-1, 256, 8, 8]               0\n",
            "AdaptiveAvgPool2d-70            [-1, 256, 1, 1]               0\n",
            "           Linear-71                   [-1, 10]           2,570\n",
            "================================================================\n",
            "Total params: 4,991,306\n",
            "Trainable params: 4,991,306\n",
            "Non-trainable params: 0\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.01\n",
            "Forward/backward pass size (MB): 15.25\n",
            "Params size (MB): 19.04\n",
            "Estimated Total Size (MB): 34.30\n",
            "----------------------------------------------------------------\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# Plot the accuracy and loss values per epoch\n",
        "epochs = range(1, len(train_acc_list) + 1)\n",
        "\n",
        "plt.plot(epochs, train_acc_list, 'b', label='Training accuracy')\n",
        "plt.plot(epochs, val_acc_list, 'r', label='Validation accuracy')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "val_loss_list_cpu = []\n",
        "for val_loss in val_loss_list:\n",
        "    val_loss_cpu = val_loss.cpu()\n",
        "    val_loss_list_cpu.append(val_loss_cpu)\n",
        "\n",
        "plt.plot(epochs, train_loss_list, 'b', label='Training loss')\n",
        "plt.plot(epochs, val_loss_list_cpu, 'r', label='Validation loss')\n",
        "plt.title('Training and validation loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "_NU8vECI8YyR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 927
        },
        "outputId": "3bbe7d8e-e240-43fc-9d58-bc37f1f2d8d6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Testing with various hyperparameters :\n",
        "We ran this section of the code as a script file on NYU HPC and got the results as a text file."
      ],
      "metadata": {
        "id": "PynDJeIRcpnX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Optimisers :"
      ],
      "metadata": {
        "id": "dmRT16YHcywg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "\n",
        "class ResNet(nn.Module):\n",
        "    def __init__(self, num_classes=10):\n",
        "        super(ResNet, self).__init__()\n",
        "\n",
        "        # Initial convolution layer\n",
        "        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(64)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "\n",
        "        # Residual blocks\n",
        "        \n",
        "        self.layer1 = self._make_layer(64, 128, 2, stride=2)\n",
        "        self.layer2 = self._make_layer(128, 128, 2, stride=1)\n",
        "        #self.layer3 = self._make_layer(128, 128, 2, stride=1)\n",
        "        self.layer3= self._make_layer(128, 256, 2, stride=2)\n",
        "        \n",
        "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
        "        self.fc = nn.Linear(256, num_classes)\n",
        "\n",
        "    def _make_layer(self, in_channels, out_channels, num_blocks, stride):\n",
        "        layers = []\n",
        "        layers.append(ResidualBlock(in_channels, out_channels, stride))\n",
        "        for i in range(1, num_blocks):\n",
        "            layers.append(ResidualBlock(out_channels, out_channels, 1))\n",
        "        return nn.Sequential(*layers)\n",
        "\n",
        "    def forward(self, x):\n",
        "        # Initial convolution layer\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        # Residual blocks\n",
        "        x = self.layer1(x)\n",
        "        x = self.layer2(x)\n",
        "        x = self.layer3(x)\n",
        "      \n",
        "\n",
        "        # Average pooling and fully-connected layer\n",
        "        x = self.avgpool(x)\n",
        "        x = x.view(x.size(0), -1)\n",
        "        x = self.fc(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "\n",
        "class ResidualBlock(nn.Module):\n",
        "    def __init__(self, in_channels, out_channels, stride):\n",
        "        super(ResidualBlock, self).__init__()\n",
        "\n",
        "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.conv3 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn3 = nn.BatchNorm2d(out_channels)\n",
        "        \n",
        "        self.stride = stride\n",
        "\n",
        "        # Skip connection\n",
        "        if stride != 1 or in_channels != out_channels:\n",
        "            self.skip = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False)\n",
        "        else:\n",
        "            self.skip = nn.Identity()\n",
        "\n",
        "    def forward(self, x):\n",
        "        identity = self.skip(x)\n",
        "\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        x = self.conv2(x)\n",
        "        x = self.bn2(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        x = self.conv3(x)\n",
        "        x = self.bn3(x)\n",
        "        \n",
        "\n",
        "        x += identity\n",
        "        x = self.relu(x)\n",
        "\n",
        "        return x\n",
        "    \n",
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "\n",
        "\n",
        "# Define transforms for the dataset\n",
        "transform_train = transforms.Compose([\n",
        "    transforms.RandomCrop(32, padding=4),\n",
        "    transforms.RandomHorizontalFlip(),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\n",
        "])\n",
        "\n",
        "transform_test = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\n",
        "])\n",
        "\n",
        "# Load the CIFAR-10 dataset\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)\n",
        "\n",
        "valset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n",
        "valloader = torch.utils.data.DataLoader(valset, batch_size=128, shuffle=False, num_workers=2)\n",
        "\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False, num_workers=2)\n",
        "\n",
        "# Define the ResNet model\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(device)\n",
        "lr = 0.001\n",
        "\n",
        "\n",
        "# Define different optimizers\n",
        "optimizers = {\n",
        "    'SGD': optim.SGD,\n",
        "    'Adam': optim.Adam,\n",
        "    'RMSprop': optim.RMSprop,\n",
        "    'Adadelta': optim.Adadelta,\n",
        "    'Adagrad': optim.Adagrad,\n",
        "    'ASGD': optim.ASGD,\n",
        "    'Adamax': optim.Adamax,\n",
        "   \n",
        "}\n",
        "\n",
        "# Train the model using different optimizers\n",
        "for optimizer_name, optimizer_class in optimizers.items():\n",
        "    net = ResNet().to(device)\n",
        "    optimizer = optimizer_class(net.parameters(), lr=lr)\n",
        "    # Define loss function\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    print(f\"\\nTraining model with {optimizer_name} optimizer...\\n\")\n",
        "    best_accuracy = 0.0\n",
        "    best_state_dict = None\n",
        "    for epoch in range(300):\n",
        "        running_loss = 0.0\n",
        "        train_correct = 0\n",
        "        train_total = 0\n",
        "\n",
        "        net.train()\n",
        "        for i, data in enumerate(trainloader, 0):\n",
        "            inputs, labels = data[0].to(device), data[1].to(device)\n",
        "\n",
        "            optimizer.zero_grad()\n",
        "\n",
        "            outputs = net(inputs)\n",
        "            loss = criterion(outputs, labels)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            running_loss += loss.item()\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            train_total += labels.size(0)\n",
        "            train_correct += (predicted == labels).sum().item()\n",
        "\n",
        "        epoch_train_loss = running_loss / len(trainloader)\n",
        "        epoch_train_accuracy = 100 * train_correct / train_total\n",
        "\n",
        "        # Calculate validation accuracy\n",
        "        net.eval()\n",
        "        val_correct = 0\n",
        "        val_total = 0\n",
        "        with torch.no_grad():\n",
        "            for data in valloader:\n",
        "                images, labels = data[0].to(device), data[1].to(device)\n",
        "                outputs = net(images)\n",
        "                _, predicted = torch.max(outputs.data, 1)\n",
        "                val_total += labels.size(0)\n",
        "                val_correct += (predicted == labels).sum().item()\n",
        "        val_accuracy = 100 * val_correct / val_total\n",
        "    \n",
        "        #print('Epoch %d: train_loss=%.3f, train_accuracy=%.3f, val_accuracy=%.3f' % (epoch + 1, epoch_train_loss, epoch_train_accuracy, val_accuracy))\n",
        "        \n",
        "        # Save the model state with the best validation accuracy\n",
        "        if val_accuracy > best_accuracy:\n",
        "            best_accuracy = val_accuracy\n",
        "            best_state_dict = net.state_dict()\n",
        "            #print('Epoch %d: train_loss=%.3f, train_accuracy=%.3f, val_accuracy=%.3f' % (epoch + 1, epoch_train_loss, epoch_train_accuracy, val_accuracy))\n",
        "        \n",
        "\n",
        "    # Evaluate the test accuracy using the saved model state\n",
        "    net.load_state_dict(best_state_dict)\n",
        "    test_correct = 0\n",
        "    test_total = 0\n",
        "    with torch.no_grad():\n",
        "        for data in testloader:\n",
        "            images, labels = data[0].to(device), data[1].to(device)\n",
        "            outputs = net(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            test_total += labels.size(0)\n",
        "            test_correct += (predicted == labels).sum().item()\n",
        "\n",
        "    test_accuracy = 100 * test_correct / test_total\n",
        "    print('Test accuracy: %.3f' % test_accuracy)\n",
        "\n",
        "\n",
        "    num_params = sum(p.numel() for p in net.parameters())\n",
        "    print(\"\\nNumber of parameters: \", num_params)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "IBiwTLUuc110"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Output:\n",
        "\n",
        "\n",
        "Files already downloaded and verified\n",
        "\n",
        "Files already downloaded and verified\n",
        "\n",
        "Files already downloaded and verified\n",
        "\n",
        "cuda\n",
        "\n",
        "Training model with SGD optimizer...\n",
        "\n",
        "Test accuracy: 85.790\n",
        "\n",
        "Number of parameters:  4991306\n",
        "\n",
        "Training model with Adam optimizer...\n",
        "\n",
        "Test accuracy: 91.860\n",
        "\n",
        "Number of parameters:  4991306\n",
        "\n",
        "Training model with RMSprop optimizer...\n",
        "\n",
        "Test accuracy: 91.620\n",
        "\n",
        "Number of parameters:  4991306\n",
        "\n",
        "Training model with Adadelta optimizer...\n",
        "\n",
        "Test accuracy: 79.860\n",
        "\n",
        "Number of parameters:  4991306\n",
        "\n",
        "Training model with Adagrad optimizer...\n",
        "\n",
        "Test accuracy: 86.010\n",
        "\n",
        "Number of parameters:  4991306\n",
        "\n",
        "Training model with ASGD optimizer...\n",
        "\n",
        "Test accuracy: 85.390\n",
        "\n",
        "Number of parameters:  4991306\n",
        "\n",
        "Training model with Adamax optimizer...\n",
        "\n",
        "Test accuracy: 91.520\n",
        "\n",
        "Number of parameters:  4991306\n",
        "\n"
      ],
      "metadata": {
        "id": "5CmL58YCeDpn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Learning Rate"
      ],
      "metadata": {
        "id": "aL_1wtRGeWWy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "\n",
        "class ResNet(nn.Module):\n",
        "    def __init__(self, num_classes=10):\n",
        "        super(ResNet, self).__init__()\n",
        "\n",
        "        # Initial convolution layer\n",
        "        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(64)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "\n",
        "        # Residual blocks\n",
        "        #self.layer1 = self._make_layer(32, 32, 2, stride=1)\n",
        "        #self.layer1 = self._make_layer(64, 64, 2, stride=1)\n",
        "        self.layer1 = self._make_layer(64, 128, 2, stride=2)\n",
        "        self.layer2 = self._make_layer(128, 128, 2, stride=1)\n",
        "        #self.layer3 = self._make_layer(128, 128, 2, stride=1)\n",
        "        self.layer3= self._make_layer(128, 256, 2, stride=2)\n",
        "        # Average pooling and fully-connected layer\n",
        "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
        "        self.fc = nn.Linear(256, num_classes)\n",
        "\n",
        "    def _make_layer(self, in_channels, out_channels, num_blocks, stride):\n",
        "        layers = []\n",
        "        layers.append(ResidualBlock(in_channels, out_channels, stride))\n",
        "        for i in range(1, num_blocks):\n",
        "            layers.append(ResidualBlock(out_channels, out_channels, 1))\n",
        "        return nn.Sequential(*layers)\n",
        "\n",
        "    def forward(self, x):\n",
        "        # Initial convolution layer\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        # Residual blocks\n",
        "        x = self.layer1(x)\n",
        "        x = self.layer2(x)\n",
        "        x = self.layer3(x)\n",
        "        #x = self.layer4(x)\n",
        "        # x = self.layer5(x)\n",
        "        # x = self.layer6(x)\n",
        "\n",
        "        # Average pooling and fully-connected layer\n",
        "        x = self.avgpool(x)\n",
        "        x = x.view(x.size(0), -1)\n",
        "        x = self.fc(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "\n",
        "class ResidualBlock(nn.Module):\n",
        "    def __init__(self, in_channels, out_channels, stride):\n",
        "        super(ResidualBlock, self).__init__()\n",
        "\n",
        "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.conv3 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn3 = nn.BatchNorm2d(out_channels)\n",
        "        \n",
        "        self.stride = stride\n",
        "\n",
        "        # Skip connection\n",
        "        if stride != 1 or in_channels != out_channels:\n",
        "            self.skip = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False)\n",
        "        else:\n",
        "            self.skip = nn.Identity()\n",
        "\n",
        "    def forward(self, x):\n",
        "        identity = self.skip(x)\n",
        "\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        x = self.conv2(x)\n",
        "        x = self.bn2(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        x = self.conv3(x)\n",
        "        x = self.bn3(x)\n",
        "        \n",
        "\n",
        "        x += identity\n",
        "        x = self.relu(x)\n",
        "\n",
        "        return x\n",
        "    \n",
        "\n",
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "\n",
        "# Define transforms for the dataset\n",
        "transform_train = transforms.Compose([\n",
        "    transforms.RandomCrop(32, padding=4),\n",
        "    transforms.RandomHorizontalFlip(),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\n",
        "])\n",
        "\n",
        "transform_test = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\n",
        "])\n",
        "\n",
        "# Load the CIFAR-10 dataset# Define the validation dataset\n",
        "\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)\n",
        "\n",
        "valset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n",
        "valloader = torch.utils.data.DataLoader(valset, batch_size=128, shuffle=False, num_workers=2)\n",
        "\n",
        "\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False, num_workers=2)\n",
        "\n",
        "\n",
        "\n",
        "# Define the ResNet model and optimizer\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(device)\n",
        "\n",
        "\n",
        "learning_rates = [0.1, 0.01, 0.001,0.0001]\n",
        "best_accuracy = 0.0\n",
        "best_state_dict = None\n",
        "\n",
        "for lr in learning_rates:\n",
        "    net = ResNet().to(device)\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = torch.optim.SGD(net.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)\n",
        "    print(f\"\\n\\nTraining model with {lr} learning rate \\n\\n\")\n",
        "    # Train the model\n",
        "    for epoch in range(300):\n",
        "        running_loss = 0.0\n",
        "        train_correct = 0\n",
        "        train_total = 0\n",
        "\n",
        "        net.train()\n",
        "        for i, data in enumerate(trainloader, 0):\n",
        "            inputs, labels = data[0].to(device), data[1].to(device)\n",
        "\n",
        "            optimizer.zero_grad()\n",
        "\n",
        "            outputs = net(inputs)\n",
        "            loss = criterion(outputs, labels)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            running_loss += loss.item()\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            train_total += labels.size(0)\n",
        "            train_correct += (predicted == labels).sum().item()\n",
        "\n",
        "        epoch_train_loss = running_loss / len(trainloader)\n",
        "        epoch_train_accuracy = 100 * train_correct / train_total\n",
        "\n",
        "        # Calculate validation accuracy\n",
        "        net.eval()\n",
        "        val_correct = 0\n",
        "        val_total = 0\n",
        "        with torch.no_grad():\n",
        "            for data in valloader:\n",
        "                images, labels = data[0].to(device), data[1].to(device)\n",
        "                outputs = net(images)\n",
        "                _, predicted = torch.max(outputs.data, 1)\n",
        "                val_total += labels.size(0)\n",
        "                val_correct += (predicted == labels).sum().item()\n",
        "        val_accuracy = 100 * val_correct / val_total\n",
        "\n",
        "        #print('Epoch %d: lr=%.3f, train_loss=%.3f, train_accuracy=%.3f, val_accuracy=%.3f' % (epoch + 1, lr, epoch_train_loss, epoch_train_accuracy, val_accuracy))\n",
        "    \n",
        "        # Save the model state with the best validation accuracy\n",
        "        if val_accuracy > best_accuracy:\n",
        "            best_accuracy = val_accuracy\n",
        "            best_state_dict = net.state_dict()\n",
        "\n",
        "    # Evaluate the test accuracy using the saved model state\n",
        "    net.load_state_dict(best_state_dict)\n",
        "    test_correct = 0\n",
        "    test_total = 0\n",
        "    with torch.no_grad():\n",
        "        for data in testloader:\n",
        "            images, labels = data[0].to(device), data[1].to(device)\n",
        "            outputs = net(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            test_total += labels.size(0)\n",
        "            test_correct += (predicted == labels).sum().item()\n",
        "\n",
        "    test_accuracy = 100 * test_correct / test_total\n",
        "    print('Test accuracy: %.3f' % test_accuracy)\n",
        "\n",
        "\n",
        "    num_params = sum(p.numel() for p in net.parameters())\n",
        "    print(\"\\nNumber of parameters: \", num_params)\n"
      ],
      "metadata": {
        "id": "oN5gK8exeLoH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Output:\n",
        "\n",
        "Files already downloaded and verified\n",
        "\n",
        "Files already downloaded and verified\n",
        "\n",
        "Files already downloaded and verified\n",
        "\n",
        "cuda\n",
        "\n",
        "\n",
        "Training model with 0.1 learning rate \n",
        "\n",
        "\n",
        "Test accuracy: 85.310\n",
        "\n",
        "Number of parameters:  4991306\n",
        "\n",
        "\n",
        "Training model with 0.01 learning rate \n",
        "\n",
        "\n",
        "Test accuracy: 92.280\n",
        "\n",
        "Number of parameters:  4991306\n",
        "\n",
        "\n",
        "Training model with 0.001 learning rate \n",
        "\n",
        "\n",
        "Test accuracy: 92.280\n",
        "\n",
        "Number of parameters:  4991306\n",
        "\n",
        "\n",
        "Training model with 0.0001 learning rate \n",
        "\n",
        "\n",
        "Test accuracy: 92.280\n",
        "\n",
        "Number of parameters:  4991306\n"
      ],
      "metadata": {
        "id": "go2Sge_Ae0gW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Batchsize"
      ],
      "metadata": {
        "id": "GxzcypKRfEgs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "\n",
        "class ResNet(nn.Module):\n",
        "    def __init__(self, num_classes=10):\n",
        "        super(ResNet, self).__init__()\n",
        "\n",
        "        # Initial convolution layer\n",
        "        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(64)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "\n",
        "        # Residual blocks\n",
        "        #self.layer1 = self._make_layer(32, 32, 2, stride=1)\n",
        "        #self.layer1 = self._make_layer(64, 64, 2, stride=1)\n",
        "        self.layer1 = self._make_layer(64, 128, 2, stride=2)\n",
        "        self.layer2 = self._make_layer(128, 128, 2, stride=1)\n",
        "        #self.layer3 = self._make_layer(128, 128, 2, stride=1)\n",
        "        self.layer3= self._make_layer(128, 256, 2, stride=2)\n",
        "        # Average pooling and fully-connected layer\n",
        "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
        "        self.fc = nn.Linear(256, num_classes)\n",
        "\n",
        "    def _make_layer(self, in_channels, out_channels, num_blocks, stride):\n",
        "        layers = []\n",
        "        layers.append(ResidualBlock(in_channels, out_channels, stride))\n",
        "        for i in range(1, num_blocks):\n",
        "            layers.append(ResidualBlock(out_channels, out_channels, 1))\n",
        "        return nn.Sequential(*layers)\n",
        "\n",
        "    def forward(self, x):\n",
        "        # Initial convolution layer\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        # Residual blocks\n",
        "        x = self.layer1(x)\n",
        "        x = self.layer2(x)\n",
        "        x = self.layer3(x)\n",
        "        #x = self.layer4(x)\n",
        "        # x = self.layer5(x)\n",
        "        # x = self.layer6(x)\n",
        "\n",
        "        # Average pooling and fully-connected layer\n",
        "        x = self.avgpool(x)\n",
        "        x = x.view(x.size(0), -1)\n",
        "        x = self.fc(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "\n",
        "class ResidualBlock(nn.Module):\n",
        "    def __init__(self, in_channels, out_channels, stride):\n",
        "        super(ResidualBlock, self).__init__()\n",
        "\n",
        "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.conv3 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)\n",
        "        self.bn3 = nn.BatchNorm2d(out_channels)\n",
        "        \n",
        "        self.stride = stride\n",
        "\n",
        "        # Skip connection\n",
        "        if stride != 1 or in_channels != out_channels:\n",
        "            self.skip = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False)\n",
        "        else:\n",
        "            self.skip = nn.Identity()\n",
        "\n",
        "    def forward(self, x):\n",
        "        identity = self.skip(x)\n",
        "\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        x = self.conv2(x)\n",
        "        x = self.bn2(x)\n",
        "        x = self.relu(x)\n",
        "\n",
        "        x = self.conv3(x)\n",
        "        x = self.bn3(x)\n",
        "        \n",
        "\n",
        "        x += identity\n",
        "        x = self.relu(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "\n",
        "# Define transforms for the dataset\n",
        "transform_train = transforms.Compose([\n",
        "    transforms.RandomCrop(32, padding=4),\n",
        "    transforms.RandomHorizontalFlip(),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\n",
        "])\n",
        "\n",
        "transform_test = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\n",
        "])\n",
        "\n",
        "# Load the CIFAR-10 dataset\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)\n",
        "\n",
        "valset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n",
        "\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n",
        "\n",
        "\n",
        "# Define the ResNet model and optimizer\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(device)\n",
        "batch_sizes = [32,64, 128, 256, 512]\n",
        "best_accuracy = 0.0\n",
        "best_state_dict = None\n",
        "for batch_size in batch_sizes:\n",
        "    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=2)\n",
        "    valloader = torch.utils.data.DataLoader(valset, batch_size=batch_size, shuffle=False, num_workers=2)\n",
        "    testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2)\n",
        "\n",
        "    net = ResNet().to(device)\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = torch.optim.Adam(net.parameters(), lr=0.001, weight_decay=5e-4)\n",
        "    print(f\"\\n\\nTraining model with {batch_size} Batch size\\n\\n\")\n",
        "    # Train the model\n",
        "    for epoch in range(300):\n",
        "        running_loss = 0.0\n",
        "        train_correct = 0\n",
        "        train_total = 0\n",
        "\n",
        "        net.train()\n",
        "        for i, data in enumerate(trainloader, 0):\n",
        "            inputs, labels = data[0].to(device), data[1].to(device)\n",
        "\n",
        "            optimizer.zero_grad()\n",
        "\n",
        "            outputs = net(inputs)\n",
        "            loss = criterion(outputs, labels)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            running_loss += loss.item()\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            train_total += labels.size(0)\n",
        "            train_correct += (predicted == labels).sum().item()\n",
        "\n",
        "        epoch_train_loss = running_loss / len(trainloader)\n",
        "        epoch_train_accuracy = 100 * train_correct / train_total\n",
        "\n",
        "        # Calculate validation accuracy\n",
        "        net.eval()\n",
        "        val_correct = 0\n",
        "        val_total = 0\n",
        "        with torch.no_grad():\n",
        "            for data in valloader:\n",
        "                images, labels = data[0].to(device), data[1].to(device)\n",
        "                outputs = net(images)\n",
        "                _, predicted = torch.max(outputs.data, 1)\n",
        "                val_total += labels.size(0)\n",
        "                val_correct += (predicted == labels).sum().item()\n",
        "        val_accuracy = 100 * val_correct / val_total\n",
        "\n",
        "        #print('Epoch %d: lr=%.3f, train_loss=%.3f, train_accuracy=%.3f, val_accuracy=%.3f' % (epoch + 1, lr, epoch_train_loss, epoch_train_accuracy, val_accuracy))\n",
        "    \n",
        "        # Save the model state with the best validation accuracy\n",
        "        if val_accuracy > best_accuracy:\n",
        "            best_accuracy = val_accuracy\n",
        "            best_state_dict = net.state_dict()\n",
        "\n",
        "    # Evaluate the test accuracy using the saved model state\n",
        "    net.load_state_dict(best_state_dict)\n",
        "    test_correct = 0\n",
        "    test_total = 0\n",
        "    with torch.no_grad():\n",
        "        for data in testloader:\n",
        "            images, labels = data[0].to(device), data[1].to(device)\n",
        "            outputs = net(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            test_total += labels.size(0)\n",
        "            test_correct += (predicted == labels).sum().item()\n",
        "\n",
        "    test_accuracy = 100 * test_correct / test_total\n",
        "    print('Test accuracy: %.3f' % test_accuracy)\n"
      ],
      "metadata": {
        "id": "NJ20fMcofHRq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Output:\n",
        "\n",
        "Files already downloaded and verified\n",
        "\n",
        "Files already downloaded and verified\n",
        "\n",
        "Files already downloaded and verified\n",
        "\n",
        "cuda\n",
        "\n",
        "\n",
        "\n",
        "Training model with 32 Batch size\n",
        "\n",
        "\n",
        "Test accuracy: 85.470\n",
        "\n",
        "\n",
        "Training model with 64 Batch size\n",
        "\n",
        "\n",
        "Test accuracy: 87.170\n",
        "\n",
        "\n",
        "Training model with 128 Batch size\n",
        "\n",
        "\n",
        "Test accuracy: 87.780\n",
        "\n",
        "\n",
        "Training model with 256 Batch size\n",
        "\n",
        "\n",
        "Test accuracy: 87.190\n",
        "\n",
        "\n",
        "Training model with 512 Batch size\n",
        "\n",
        "\n",
        "Test accuracy: 86.840\n",
        "\n"
      ],
      "metadata": {
        "id": "FQxi9qT3fW5T"
      }
    }
  ]
}