Main.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ai.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "39L80QvK9uKn"
      },
      "source": [
        "import torch \n",
        "import torch.nn as nn\n",
        "from torch.nn import functional as F\n",
        "from torchvision import datasets\n",
        "from torchvision import transforms as T\n",
        "from matplotlib import pyplot as plt"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e9DTWIIlVK0_",
        "outputId": "f604b4f2-8598-4621-e3a9-8eaa0b9ab133"
      },
      "source": [
        "train_dataset = datasets.SVHN(root='data', split='train', transform=T.ToTensor(), download=True)\n",
        "test_dataset = datasets.SVHN(root='data', split='test', transform=T.ToTensor(), download=True)\n",
        "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=256, shuffle=True)\n",
        "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=256, shuffle=True)\n"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using downloaded and verified file: data/train_32x32.mat\n",
            "Using downloaded and verified file: data/test_32x32.mat\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "398dGzAbaHoT"
      },
      "source": [
        "def train(model, train_loader, optimizer, i_epoch, device):\n",
        "  \n",
        "  for i, (image, target) in enumerate(train_loader):\n",
        "    image, target = image.to(device), target.to(device)\n",
        "    output = model(image)\n",
        "    \n",
        "    loss = F.cross_entropy(output, target)\n",
        "\n",
        "    model.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uqImjubSaMUY"
      },
      "source": [
        "def test(model, test_loader, i_epoch, device):\n",
        "  accurate = 0 \n",
        "  test_loss_list = []\n",
        "  with torch.no_grad():\n",
        "    for i, (image, target) in enumerate(test_loader):\n",
        "      image,target = image.to(device), target.to(device)\n",
        "      output = model(image)\n",
        "\n",
        "      prediction = torch.argmax(output, dim=1)\n",
        "\n",
        "      test_loss = F.cross_entropy(output, target)\n",
        "\n",
        "      for p, t in zip(prediction, target):\n",
        "        if p==t:\n",
        "          accurate +=1\n",
        "      test_loss_list.append(test_loss.detach().numpy())\n",
        "\n",
        "  accuracy = accurate / len(test_loader.dataset)\n",
        "  accuracy_value.append(accuracy)\n",
        "\n",
        "  average_test_loss = sum(test_loss_list) / len(test_loss_list)\n",
        "  test_loss_by_epoch.append(average_test_loss)\n",
        "  print('epoch: {}, accuracy: {}, loss: {}'.format(i_epoch, accuracy, average_test_loss))"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fXnixsAeZHJa"
      },
      "source": [
        "class CNN(nn.Module):\n",
        "  def __init__(self):\n",
        "    super(CNN, self).__init__()\n",
        "\n",
        "    self.conv = nn.Sequential(\n",
        "        nn.Conv2d(3,32,4,2,1),\n",
        "        nn.Dropout(p=0.2),\n",
        "        nn.BatchNorm2d(32),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(32,32,4,2,1),\n",
        "        nn.Dropout(p=0.2),\n",
        "        nn.BatchNorm2d(32),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(32,32,3,1,1),\n",
        "        nn.Dropout(p=0.2),\n",
        "        nn.BatchNorm2d(32),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(32,32,3,2,1),\n",
        "        nn.Dropout(p=0.2),\n",
        "        nn.BatchNorm2d(32),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(32,32,4,2,1),\n",
        "        nn.Dropout(p=0.2),\n",
        "        nn.BatchNorm2d(32),\n",
        "        nn.ReLU(),\n",
        "        nn.AvgPool2d(2),\n",
        "    )\n",
        "\n",
        "    self.fc = nn.Sequential(\n",
        "        nn.Linear(32,10),\n",
        "        nn.Softmax()\n",
        "    )\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = self.conv(x)\n",
        "    x = x.view(-1,32)\n",
        "    return self.fc(x)"
      ],
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IFzN0upDZXRC",
        "outputId": "09812397-6106-4ef9-c414-daa52666de96"
      },
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "\n",
        "accuracy_value = []\n",
        "\n",
        "CNN_model = CNN()\n",
        "CNN_model.to(device)\n",
        "\n",
        "CNN_optimizer = torch.optim.Adam(CNN_model.parameters(), lr=0.001)\n",
        "\n",
        "\n",
        "for i_epoch in range(10):\n",
        "  CNN_model.train()\n",
        "  train(CNN_model, train_loader, CNN_optimizer, i_epoch, device)\n",
        "  CNN_model.eval()\n",
        "  test(CNN_model, test_loader, i_epoch, device)"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/nn/modules/container.py:139: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "  input = module(input)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "epoch: 0, accuracy: 0.5444837123540258, loss: 1.9132964844797171\n",
            "epoch: 1, accuracy: 0.8234480639213276, loss: 1.6694780331031949\n",
            "epoch: 2, accuracy: 0.8312077443146896, loss: 1.6389366388320923\n",
            "epoch: 3, accuracy: 0.8493776889981561, loss: 1.6170364291060204\n",
            "epoch: 4, accuracy: 0.865319606637984, loss: 1.5991896449350844\n",
            "epoch: 5, accuracy: 0.8709280885064536, loss: 1.5939782787771786\n",
            "epoch: 6, accuracy: 0.878841425937308, loss: 1.5842415889104207\n",
            "epoch: 7, accuracy: 0.8805316533497234, loss: 1.58312009713229\n",
            "epoch: 8, accuracy: 0.8699293177627535, loss: 1.5940937259617973\n",
            "epoch: 9, accuracy: 0.8827980946527351, loss: 1.5804366165516424\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 325
        },
        "id": "tzWSbbt8aX7a",
        "outputId": "d5fb0992-fe77-4f25-8886-8f301647a33c"
      },
      "source": [
        "fig = plt.figure(figsize=(10,10))\n",
        "accuracy_d = fig.add_subplot(2,1,2)\n",
        "\n",
        "accuracy_d.plot(accuracy_value, color='red')\n",
        "accuracy_d.grid(True, axis='y')\n",
        "accuracy_d.set_title('accuracy')\n",
        "\n",
        "plt.xlabel('epoch')\n",
        "plt.show()"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}