Alexnet.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "new structure 2.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMuOWM6OaIoMf0gzXuQ/WBw",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nxf-emma/APS360-Artificial-Intelligence-Fundamentals/blob/main/Alexnet.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1sah8OC1-pIq",
        "outputId": "e852ec86-07c5-4087-8036-29765574e9d3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "#mount googledrive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "import os\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import matplotlib.pyplot as plt\n",
        "import torch.optim as optim\n",
        "import torchvision\n",
        "from torchvision import datasets, models, transforms\n",
        "from torch.utils.data.sampler import SubsetRandomSampler"
      ],
      "metadata": {
        "id": "mDAi3Xqw-vzP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# train"
      ],
      "metadata": {
        "id": "blytVQUDUwYK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_accuracy(model, dataloader):\n",
        "    \n",
        "\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for imgs, labels in dataloader:\n",
        "        \n",
        "        if use_cuda and torch.cuda.is_available():\n",
        "            imgs = imgs.cuda()\n",
        "            labels = labels.cuda()\n",
        "\n",
        "        output = model(imgs)\n",
        "        \n",
        "        #select index with maximum prediction score\n",
        "        pred = output.max(1, keepdim=True)[1]\n",
        "        correct += pred.eq(labels.view_as(pred)).sum().item()\n",
        "        total += imgs.shape[0]\n",
        "    return correct / total"
      ],
      "metadata": {
        "id": "Y22pKAZe-yXW"
      },
      "execution_count": 57,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Convolutional Neural Network Architecture\n",
        "class CNN(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(CNN, self).__init__()\n",
        "\n",
        "        self.pool = nn.MaxPool2d(2, 2) #kernel_size, stride \n",
        "\n",
        "        self.conv1 = nn.Conv2d(3, 5, 3, padding = 2) #in_channels, out_chanels, kernel_size \n",
        "        self.conv2 = nn.Conv2d(5, 25, 3) #in_channels, out_chanels, kernel_size\n",
        "        self.conv3 = nn.Conv2d(25, 50, 1)\n",
        "        self.conv4 = nn.Conv2d(50, 200, 1)\n",
        "        \n",
        "        self.fc1 = nn.Linear(200*2*2, 70) #chanels*dimension\n",
        "        self.fc3 = nn.Linear(70, 32)\n",
        "        self.fc2 = nn.Linear(32, 7) #last output channel always = 7\n",
        "        self.dropout = nn.Dropout(0.4)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        # 25x25\n",
        "        x = self.pool(F.relu(self.conv2(x)))\n",
        "        # 11\n",
        "        x = self.pool(F.relu(self.conv3(x)))\n",
        "        # 5\n",
        "        x = self.pool(F.relu(self.conv4(x)))\n",
        "        # 2\n",
        "\n",
        "\n",
        "        x = x.view(-1, 200*4)\n",
        "        x = F.relu(self.dropout(self.fc1(x)))\n",
        "        x = F.relu(self.dropout(self.fc3(x)))\n",
        "        x = self.fc2(x)\n",
        "        x = x.squeeze(1)\n",
        "        return x"
      ],
      "metadata": {
        "id": "S2CVXHj6-0j2"
      },
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train2(model, train_data, val_data, batch_size=3000, num_epochs=5, lr = 0.01):\n",
        "    \n",
        "    num_workers = 1\n",
        "    train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, \n",
        "                                           num_workers=num_workers, shuffle=True)\n",
        "    val_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size, \n",
        "                                          num_workers=num_workers, shuffle=True)\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0,weight_decay=5e-4)\n",
        "\n",
        "    iters, losses, train_acc, val_acc = [], [], [], []\n",
        "\n",
        "    # training\n",
        "    n = 0 # the number of iterations\n",
        "    for epoch in range(num_epochs):\n",
        "        print(\"Epoch\", epoch)\n",
        "        n = 0\n",
        "        for imgs, labels in iter(train_loader):\n",
        "            # print(\"iteration \", n)\n",
        "\n",
        "            if use_cuda and torch.cuda.is_available():\n",
        "                imgs = imgs.cuda()\n",
        "                labels = labels.cuda()\n",
        "\n",
        "            out = model(imgs)             # forward pass\n",
        "\n",
        "            loss = criterion(out, labels) # compute the total loss\n",
        "            loss.backward()               # backward pass (compute parameter updates)\n",
        "            optimizer.step()              # make the updates for each parameter\n",
        "            optimizer.zero_grad()         # a clean up step for PyTorch\n",
        "            n += 1\n",
        "\n",
        "        # save the current training information\n",
        "        iters.append(epoch)\n",
        "        losses.append(float(loss)/batch_size)             # compute *average* loss\n",
        "        # calculate accuracy at each epoch instead of iteration\n",
        "        # def get_accuracy(model, data):\n",
        "        train_acc.append(get_accuracy(model, train_loader)) # compute training accuracy \n",
        "        # compute validation acc every epoch\n",
        "        val_acc.append(get_accuracy(model, val_loader))  # compute validation accuracy\n",
        "        print(\"Epoch: \", epoch, \" Train Accuracy: \", train_acc[epoch])\n",
        "        print(\"Epoch: \", epoch, \" Validation Accuracy: \", val_acc[epoch])\n",
        "\n",
        "            \n",
        "\n",
        "    # plotting\n",
        "    plt.title(\"Training Curve\")\n",
        "    plt.plot(iters, losses, label=\"Train\")\n",
        "    plt.xlabel(\"Iterations\")\n",
        "    plt.ylabel(\"Loss\")\n",
        "    plt.show()\n",
        "\n",
        "    plt.title(\"Training Curve\")\n",
        "    plt.plot(iters, train_acc, label=\"Train\")\n",
        "    plt.plot(iters, val_acc, label=\"Validation\")\n",
        "    plt.xlabel(\"Iterations\")\n",
        "    plt.ylabel(\"Training Accuracy\")\n",
        "    plt.legend(loc='best')\n",
        "    plt.show()\n",
        "\n",
        "    print(\"Final Training Accuracy: {}\".format(train_acc[-1]))\n",
        "    print(\"Final Validation Accuracy: {}\".format(val_acc[-1]))"
      ],
      "metadata": {
        "id": "3zr9hnXl_ahW"
      },
      "execution_count": 66,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# train_path = '/content/drive/MyDrive/APS360 Team/aps360_dataset/FER-2013_final/train'\n",
        "# val_path = '/content/drive/MyDrive/APS360 Team/aps360_dataset/FER-2013_final/val'\n",
        "# test_path = '/content/drive/MyDrive/APS360 Team/aps360_dataset/FER-2013_final/test'\n",
        "\n",
        "# train_data = datasets.DatasetFolder(train_path, loader=torch.load, extensions=('.tensor'))\n",
        "# val_data = datasets.DatasetFolder(val_path, loader=torch.load, extensions=('.tensor'))\n",
        "# test_data = datasets.DatasetFolder(test_path, loader=torch.load, extensions=('.tensor'))"
      ],
      "metadata": {
        "id": "5Lb5IYAF_iP1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# AlexNet"
      ],
      "metadata": {
        "id": "OsrfMfdZOV46"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "alexnet = torchvision.models.alexnet(pretrained=True)"
      ],
      "metadata": {
        "id": "7nqfB7WJOKy7"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "parent_path = '/content/drive/MyDrive/APS360 Team/aps360_dataset/small-dataset/'\n",
        "\n",
        "data_transform = transforms.Compose(\n",
        "    [\n",
        "        transforms.Resize((224,224)), \n",
        "        #convert image to grayscale\n",
        "        # transforms.Grayscale(num_output_channels=3),\n",
        "        #randomly adding brightness \n",
        "        # transforms.ColorJitter(brightness=(1,1.2)),\n",
        "        #apply ramdom rotation from -30 to 30 degrees\n",
        "        # transforms.RandomRotation(30),\n",
        "        #apply random horizontal flip with probability of 50% \n",
        "        transforms.RandomHorizontalFlip(p=0.5),\n",
        "        transforms.ToTensor(),\n",
        "        #normalize the data with 0.5 mean and variance.\n",
        "        transforms.Normalize((0.5073955,), (0.25,), inplace=True)\n",
        "       \n",
        "    ])\n",
        "training_set = torchvision.datasets.ImageFolder(parent_path+'train',data_transform)\n",
        "valid_set = torchvision.datasets.ImageFolder(parent_path+'valid',data_transform)\n",
        "\n",
        "# train_data = datasets.DatasetFolder(train_path, loader=torch.load, extensions=('.tensor'))\n",
        "# val_data = datasets.DatasetFolder(val_path, loader=torch.load, extensions=('.tensor'))"
      ],
      "metadata": {
        "id": "ZQNca4vpOVXa"
      },
      "execution_count": 58,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_accuracy_alex(model, data):\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    # model.eval() #*********#\n",
        "    for imgs, labels in torch.utils.data.DataLoader(data):\n",
        "\n",
        "\n",
        "        #############################################\n",
        "        #To Enable GPU Usage\n",
        "        if use_cuda and torch.cuda.is_available():\n",
        "          imgs = imgs.cuda()\n",
        "          labels = labels.cuda()\n",
        "        #############################################\n",
        "        output = model(imgs)\n",
        "        pred = output.max(1, keepdim=True)[1] # get the index of the max logit\n",
        "        correct += pred.eq(labels.view_as(pred)).sum().item()\n",
        "        total += imgs.shape[0]\n",
        "    return correct / total"
      ],
      "metadata": {
        "id": "5QqUdVklPNyx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_alex(model, train, valid, batch_size=20, num_iters=1, learn_rate=0.01, weight_decay=0):\n",
        "    train_loader = torch.utils.data.DataLoader(train,\n",
        "                                               batch_size=batch_size,\n",
        "                                               shuffle=True) # shuffle after every epoch\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = optim.SGD(model.parameters(), lr=learn_rate, momentum=0.9, weight_decay=weight_decay)\n",
        "\n",
        "    iters, losses, train_acc, val_acc = [], [], [], []\n",
        "\n",
        "    # training\n",
        "    n = 0 # the number of iterations\n",
        "    while True:\n",
        "        if n >= num_iters:\n",
        "            break\n",
        "        for imgs, labels in iter(train_loader):\n",
        "\n",
        "\n",
        "            #############################################\n",
        "            #To Enable GPU Usage\n",
        "            if use_cuda and torch.cuda.is_available():\n",
        "              imgs = imgs.cuda()\n",
        "              labels = labels.cuda()\n",
        "            #############################################\n",
        "\n",
        "            # model.train() #*****************************#\n",
        "            out = model(imgs)             # forward pass\n",
        "            loss = criterion(out, labels) # compute the total loss\n",
        "            loss.backward()               # backward pass (compute parameter updates)\n",
        "            optimizer.step()              # make the updates for each parameter\n",
        "            optimizer.zero_grad()         # a clean up step for PyTorch\n",
        "\n",
        "            # save the current training information\n",
        "        iters.append(n)\n",
        "        losses.append(float(loss)/batch_size)        # compute *average* loss\n",
        "        train_acc.append(get_accuracy_alex(model, train)) # compute training accuracy \n",
        "        val_acc.append(get_accuracy_alex(model, valid))   # compute validation accuracy\n",
        "        print (\"Epoch \" ,n, \"Train Accuracy \", train_acc[n])\n",
        "        print (\"Epoch \" ,n, \"Validation Accuracy \", val_acc[n])\n",
        "        n += 1\n",
        "\n",
        "        \n",
        "\n",
        "\n",
        "    # plotting\n",
        "    plt.title(\"Training Curve\")\n",
        "    plt.plot(iters, losses, label=\"Train\")\n",
        "    plt.xlabel(\"Epochs\")\n",
        "    plt.ylabel(\"Loss\")\n",
        "    plt.show()\n",
        "\n",
        "    plt.title(\"Accuracy Curve\")\n",
        "    plt.plot(iters, train_acc, label=\"Train\")\n",
        "    plt.plot(iters, val_acc, label=\"Validation\")\n",
        "    plt.xlabel(\"Epochs\")\n",
        "    plt.ylabel(\"Training Accuracy\")\n",
        "    plt.legend(loc='best')\n",
        "    plt.show()\n",
        "\n",
        "    print(\"Final Training Accuracy: {}\".format(train_acc[-1]))\n",
        "    print(\"Final Validation Accuracy: {}\".format(val_acc[-1]))"
      ],
      "metadata": {
        "id": "J9L8eCjUO4sY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def save_feature(data, path):\n",
        "  \n",
        "  # classes = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']\n",
        "  classes = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']\n",
        "\n",
        "\n",
        "  dataloader = torch.utils.data.DataLoader(data, batch_size=1) #save one at a time\n",
        "  i = 0\n",
        "  for imgs, labels in (dataloader):\n",
        "    features = alexnet.features(imgs)\n",
        "    #convert to tensor\n",
        "    x = torch.from_numpy(features.detach().numpy()) \n",
        "    # save into drive\n",
        "    fullPath = path + '/' + classes[labels]\n",
        "\n",
        "    # create folder\n",
        "    if not os.path.isdir(fullPath):\n",
        "      os.mkdir(fullPath)\n",
        "    # give name and squeeze https://piazza.com/class/ky528kuhk7b27q?cid=285\n",
        "    torch.save(x.squeeze(0), fullPath+'/' + str(i) + '.tensor')\n",
        "    i = i+1"
      ],
      "metadata": {
        "id": "iyShXBvXRLPK"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "trainPath = '/content/drive/MyDrive/APS360 Team/Small AlexNet/train'\n",
        "valPath = '/content/drive/MyDrive/APS360 Team/Small AlexNet/valid'"
      ],
      "metadata": {
        "id": "OjZ_ISyvR__h"
      },
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "82y8aOZASuCv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# AlexNet"
      ],
      "metadata": {
        "id": "Sct7ff0TRh7r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# trainData, valData = getSmallerDataLoaders(32)\n",
        "trainData = torchvision.datasets.ImageFolder(trainPath, transform = data_transform)"
      ],
      "metadata": {
        "id": "89qQ0hVoTF3m"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "save_feature(training_set, trainPath)\n",
        "save_feature(valid_set, valPath)"
      ],
      "metadata": {
        "id": "eXKlYr24TKuA"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modified from Tutorial 3a and lecture notes\n",
        "class CNNalex(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(CNNalex, self).__init__()\n",
        "        # nn.Conv2d(256,300,5,2)\n",
        "        self.conv1 = nn.Conv2d(256,300,3, padding = 2) # Modified to 3, in_channels, out_chanels, kernel_size\n",
        "        self.conv2 = nn.Conv2d(300,350,3)\n",
        "\n",
        "        self.pool = nn.MaxPool2d(2, 2) #kernel_size, stride \n",
        "        self.fc1 = nn.Linear(350*2*2, 32) # Modified first parameter\n",
        "        self.fc2 = nn.Linear(32, 7)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(F.relu(self.conv1(x))) # 4\n",
        "        x = (F.relu(self.conv2(x))) #2\n",
        "        x = x.view(-1, 350*2*2) # Modified size\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        return x"
      ],
      "metadata": {
        "id": "clTqe1L2XYdd"
      },
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tPath = '/content/drive/MyDrive/APS360 Team/Small AlexNet/train'\n",
        "vPath = '/content/drive/MyDrive/APS360 Team/Small AlexNet/valid'\n",
        "\n",
        "tData = torchvision.datasets.DatasetFolder(tPath, loader=torch.load, extensions = ('.tensor'))\n",
        "vData = torchvision.datasets.DatasetFolder(vPath,loader=torch.load, extensions = ('.tensor'))"
      ],
      "metadata": {
        "id": "AUqv_LSqYM2k"
      },
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "use_cuda = True\n",
        "model1 = CNNalex()\n",
        "\n",
        "if use_cuda and torch.cuda.is_available():\n",
        "  model1.cuda()\n",
        "  print('CUDA is available!  Training on GPU ...')\n",
        "else:\n",
        "  print('CUDA is not available.  Training on CPU ...')\n",
        "\n",
        "train2(model1, tData, vData, batch_size = 1, lr= 0.001, num_epochs=30)\n"
      ],
      "metadata": {
        "id": "StsTafJpRGPT",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "348aef5b-ba8f-44ca-e7e0-f1528691990e"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CUDA is available!  Training on GPU ...\n",
            "Epoch 0\n",
            "Epoch:  0  Train Accuracy:  0.21\n",
            "Epoch:  0  Validation Accuracy:  0.20305343511450383\n",
            "Epoch 1\n",
            "Epoch:  1  Train Accuracy:  0.32857142857142857\n",
            "Epoch:  1  Validation Accuracy:  0.2748091603053435\n",
            "Epoch 2\n",
            "Epoch:  2  Train Accuracy:  0.28\n",
            "Epoch:  2  Validation Accuracy:  0.26106870229007634\n",
            "Epoch 3\n",
            "Epoch:  3  Train Accuracy:  0.3457142857142857\n",
            "Epoch:  3  Validation Accuracy:  0.2885496183206107\n",
            "Epoch 4\n",
            "Epoch:  4  Train Accuracy:  0.42142857142857143\n",
            "Epoch:  4  Validation Accuracy:  0.34961832061068704\n",
            "Epoch 5\n",
            "Epoch:  5  Train Accuracy:  0.44571428571428573\n",
            "Epoch:  5  Validation Accuracy:  0.31297709923664124\n",
            "Epoch 6\n",
            "Epoch:  6  Train Accuracy:  0.5128571428571429\n",
            "Epoch:  6  Validation Accuracy:  0.3145038167938931\n",
            "Epoch 7\n",
            "Epoch:  7  Train Accuracy:  0.6285714285714286\n",
            "Epoch:  7  Validation Accuracy:  0.35572519083969467\n",
            "Epoch 8\n",
            "Epoch:  8  Train Accuracy:  0.7\n",
            "Epoch:  8  Validation Accuracy:  0.3618320610687023\n",
            "Epoch 9\n",
            "Epoch:  9  Train Accuracy:  0.7485714285714286\n",
            "Epoch:  9  Validation Accuracy:  0.36335877862595417\n",
            "Epoch 10\n",
            "Epoch:  10  Train Accuracy:  0.7371428571428571\n",
            "Epoch:  10  Validation Accuracy:  0.3847328244274809\n",
            "Epoch 11\n",
            "Epoch:  11  Train Accuracy:  0.9\n",
            "Epoch:  11  Validation Accuracy:  0.41068702290076337\n",
            "Epoch 12\n",
            "Epoch:  12  Train Accuracy:  0.9057142857142857\n",
            "Epoch:  12  Validation Accuracy:  0.3969465648854962\n",
            "Epoch 13\n",
            "Epoch:  13  Train Accuracy:  0.96\n",
            "Epoch:  13  Validation Accuracy:  0.4198473282442748\n",
            "Epoch 14\n",
            "Epoch:  14  Train Accuracy:  0.9914285714285714\n",
            "Epoch:  14  Validation Accuracy:  0.4198473282442748\n",
            "Epoch 15\n",
            "Epoch:  15  Train Accuracy:  0.9914285714285714\n",
            "Epoch:  15  Validation Accuracy:  0.4259541984732824\n",
            "Epoch 16\n",
            "Epoch:  16  Train Accuracy:  1.0\n",
            "Epoch:  16  Validation Accuracy:  0.4366412213740458\n",
            "Epoch 17\n",
            "Epoch:  17  Train Accuracy:  1.0\n",
            "Epoch:  17  Validation Accuracy:  0.433587786259542\n",
            "Epoch 18\n",
            "Epoch:  18  Train Accuracy:  1.0\n",
            "Epoch:  18  Validation Accuracy:  0.39083969465648855\n",
            "Epoch 19\n",
            "Epoch:  19  Train Accuracy:  1.0\n",
            "Epoch:  19  Validation Accuracy:  0.42290076335877863\n",
            "Epoch 20\n",
            "Epoch:  20  Train Accuracy:  1.0\n",
            "Epoch:  20  Validation Accuracy:  0.4183206106870229\n",
            "Epoch 21\n",
            "Epoch:  21  Train Accuracy:  1.0\n",
            "Epoch:  21  Validation Accuracy:  0.42290076335877863\n",
            "Epoch 22\n",
            "Epoch:  22  Train Accuracy:  1.0\n",
            "Epoch:  22  Validation Accuracy:  0.4122137404580153\n",
            "Epoch 23\n",
            "Epoch:  23  Train Accuracy:  1.0\n",
            "Epoch:  23  Validation Accuracy:  0.4213740458015267\n",
            "Epoch 24\n",
            "Epoch:  24  Train Accuracy:  1.0\n",
            "Epoch:  24  Validation Accuracy:  0.42900763358778626\n",
            "Epoch 25\n",
            "Epoch:  25  Train Accuracy:  1.0\n",
            "Epoch:  25  Validation Accuracy:  0.4183206106870229\n",
            "Epoch 26\n",
            "Epoch:  26  Train Accuracy:  1.0\n",
            "Epoch:  26  Validation Accuracy:  0.40916030534351144\n",
            "Epoch 27\n",
            "Epoch:  27  Train Accuracy:  1.0\n",
            "Epoch:  27  Validation Accuracy:  0.4213740458015267\n",
            "Epoch 28\n",
            "Epoch:  28  Train Accuracy:  1.0\n",
            "Epoch:  28  Validation Accuracy:  0.42290076335877863\n",
            "Epoch 29\n",
            "Epoch:  29  Train Accuracy:  1.0\n",
            "Epoch:  29  Validation Accuracy:  0.4213740458015267\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Final Training Accuracy: 1.0\n",
            "Final Validation Accuracy: 0.4213740458015267\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train2(model1, tData, vData, batch_size = 10, lr= 0.001, num_epochs=15)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "wNJ6kh1heP9W",
        "outputId": "f95313cc-4a65-4968-a85d-4728303dc5e3"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0\n",
            "Epoch:  0  Train Accuracy:  0.7057142857142857\n",
            "Epoch:  0  Validation Accuracy:  0.3969465648854962\n",
            "Epoch 1\n",
            "Epoch:  1  Train Accuracy:  0.7971428571428572\n",
            "Epoch:  1  Validation Accuracy:  0.3786259541984733\n",
            "Epoch 2\n",
            "Epoch:  2  Train Accuracy:  0.86\n",
            "Epoch:  2  Validation Accuracy:  0.37251908396946565\n",
            "Epoch 3\n",
            "Epoch:  3  Train Accuracy:  0.94\n",
            "Epoch:  3  Validation Accuracy:  0.3511450381679389\n",
            "Epoch 4\n",
            "Epoch:  4  Train Accuracy:  0.9628571428571429\n",
            "Epoch:  4  Validation Accuracy:  0.39541984732824426\n",
            "Epoch 5\n",
            "Epoch:  5  Train Accuracy:  0.9857142857142858\n",
            "Epoch:  5  Validation Accuracy:  0.4152671755725191\n",
            "Epoch 6\n",
            "Epoch:  6  Train Accuracy:  0.9914285714285714\n",
            "Epoch:  6  Validation Accuracy:  0.4152671755725191\n",
            "Epoch 7\n",
            "Epoch:  7  Train Accuracy:  1.0\n",
            "Epoch:  7  Validation Accuracy:  0.3938931297709924\n",
            "Epoch 8\n",
            "Epoch:  8  Train Accuracy:  1.0\n",
            "Epoch:  8  Validation Accuracy:  0.38625954198473283\n",
            "Epoch 9\n",
            "Epoch:  9  Train Accuracy:  1.0\n",
            "Epoch:  9  Validation Accuracy:  0.4076335877862595\n",
            "Epoch 10\n",
            "Epoch:  10  Train Accuracy:  1.0\n",
            "Epoch:  10  Validation Accuracy:  0.39083969465648855\n",
            "Epoch 11\n",
            "Epoch:  11  Train Accuracy:  1.0\n",
            "Epoch:  11  Validation Accuracy:  0.4\n",
            "Epoch 12\n",
            "Epoch:  12  Train Accuracy:  1.0\n",
            "Epoch:  12  Validation Accuracy:  0.4\n",
            "Epoch 13\n",
            "Epoch:  13  Train Accuracy:  1.0\n",
            "Epoch:  13  Validation Accuracy:  0.39541984732824426\n",
            "Epoch 14\n",
            "Epoch:  14  Train Accuracy:  1.0\n",
            "Epoch:  14  Validation Accuracy:  0.3938931297709924\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Final Training Accuracy: 1.0\n",
            "Final Validation Accuracy: 0.3938931297709924\n"
          ]
        }
      ]
    }
  ]
}