Pytorch_ANN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Pytorch_ANN.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPxjj3iy5igJrl6KgV1LPL0",
      "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/mohripan/Machine-Learning/blob/main/Pytorch_ANN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SibeZGO3zaw6"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision\n",
        "import torch.optim as optim\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import DataLoader\n",
        "import torchvision.datasets as datasets\n",
        "import torchvision.transforms as transforms"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9q5cx6K5zpFi"
      },
      "source": [
        "class NN(nn.Module):\n",
        "  def __init__(self, input_size, output_size):\n",
        "    super(NN, self).__init__()\n",
        "    self.fc1 = nn.Linear(input_size, 128)\n",
        "    self.fc2 = nn.Linear(128, 128)\n",
        "    self.fc3 = nn.Linear(128, output_size)\n",
        "\n",
        "  def forward(self, X):\n",
        "    X = F.relu(self.fc1(X))\n",
        "    X = F.relu(self.fc2(X))\n",
        "    X = self.fc3(X)\n",
        "    return X"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hcy0vVMR0orC"
      },
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2mo1U91x0xYG"
      },
      "source": [
        "input_size = 784\n",
        "output_size = 10\n",
        "learning_rate = 0.001\n",
        "batch_size = 64\n",
        "num_epochs = 10"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gZ0un3W43wy4"
      },
      "source": [
        "train_dataset = datasets.MNIST(root='dataset/', train=True, transform=transforms.ToTensor(), download=True)\n",
        "test_dataset = datasets.MNIST(root='dataset/', train=False, transform=transforms.ToTensor(), download=True)\n",
        "train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)\n",
        "test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1hrXAqMD4D9b"
      },
      "source": [
        "model = NN(input_size, output_size).to(device)"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CWAbgWDS4HRv"
      },
      "source": [
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=learning_rate)"
      ],
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w30reaUP6KvN"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i3_9goi14Mv8",
        "outputId": "a9f050c7-28d9-496d-c496-96a7a6f612dd"
      },
      "source": [
        "train_losses = np.zeros(num_epochs)\n",
        "test_losses = np.zeros(num_epochs)\n",
        "\n",
        "for i in range(num_epochs):\n",
        "  train_loss = []\n",
        "  for batch_idx, (data, targets) in enumerate(train_loader):\n",
        "    optimizer.zero_grad()\n",
        "\n",
        "    data, targets = data.to(device), targets.to(device)\n",
        "\n",
        "    data = data.reshape(data.shape[0], -1)\n",
        "\n",
        "    scores = model(data)\n",
        "    loss = criterion(scores, targets)\n",
        "\n",
        "    train_loss.append(loss.item())\n",
        "\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "  train_loss = np.mean(train_loss)\n",
        "  train_losses[i] = train_loss\n",
        "\n",
        "  test_loss = []\n",
        "\n",
        "  num_correct = 0\n",
        "  num_samples = 0\n",
        "  model.eval()\n",
        "\n",
        "  with torch.no_grad():\n",
        "\n",
        "    for batch_idx, (data, targets) in enumerate(test_loader):\n",
        "      data, targets = data.to(device), targets.to(device)\n",
        "\n",
        "      data = data.reshape(data.shape[0], -1)\n",
        "\n",
        "      scores = model(data)\n",
        "      loss = criterion(scores, targets)\n",
        "\n",
        "      _, predictions = scores.max(1)\n",
        "      num_correct += (predictions == targets).sum()\n",
        "      num_samples += predictions.size(0)\n",
        "\n",
        "      test_loss.append(loss.item())\n",
        "\n",
        "      acc = float(num_correct)/float(num_samples)*100\n",
        "\n",
        "  test_loss = np.mean(test_loss)\n",
        "  test_losses[i] = test_loss\n",
        "\n",
        "  print(f'Epochs: {i+1}/{num_epochs}, train_loss: {train_loss}, test_loss: {test_loss}, Test accuracy: {acc}')"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epochs: 1/10, train_loss: 0.31280439868887094, test_loss: 0.15459419945610842, Test accuracy: 95.37\n",
            "Epochs: 2/10, train_loss: 0.12707158334668417, test_loss: 0.10971448570341584, Test accuracy: 96.67\n",
            "Epochs: 3/10, train_loss: 0.0874579904073758, test_loss: 0.08824128396571822, Test accuracy: 97.2\n",
            "Epochs: 4/10, train_loss: 0.06456104432047009, test_loss: 0.08142106495237802, Test accuracy: 97.32\n",
            "Epochs: 5/10, train_loss: 0.05036966475715954, test_loss: 0.08214104594292036, Test accuracy: 97.47\n",
            "Epochs: 6/10, train_loss: 0.041267792734544353, test_loss: 0.08631752496320164, Test accuracy: 97.43\n",
            "Epochs: 7/10, train_loss: 0.033110116973634994, test_loss: 0.07545758044385355, Test accuracy: 97.65\n",
            "Epochs: 8/10, train_loss: 0.027189154253425156, test_loss: 0.08273697063674598, Test accuracy: 97.72999999999999\n",
            "Epochs: 9/10, train_loss: 0.022530051832221253, test_loss: 0.09087039864909897, Test accuracy: 97.61999999999999\n",
            "Epochs: 10/10, train_loss: 0.020657563840118753, test_loss: 0.08779548073246465, Test accuracy: 97.74000000000001\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bIxlse4h5F-a"
      },
      "source": [
        "def check_accuracy(loader, model):\n",
        "  num_correct = 0\n",
        "  num_samples = 0\n",
        "  model.eval()\n",
        "\n",
        "  with torch.no_grad():\n",
        "    for X, y in loader:\n",
        "      X, y = X.to(device), y.to(device)\n",
        "\n",
        "      X = X.reshape(X.shape[0], -1)\n",
        "\n",
        "      scores = model(X)\n",
        "      _, predictions = scores.max(1)\n",
        "      num_correct += (predictions == y).sum()\n",
        "      num_samples += predictions.size(0)\n",
        "\n",
        "    acc = float(num_correct)/float(num_samples)*100\n",
        "    print(f'Got {num_correct}/{num_samples} with accuracy: {acc}')"
      ],
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "THa9WGGN7FZG",
        "outputId": "071936fe-201f-458e-e545-bf03b53786c7"
      },
      "source": [
        "check_accuracy(test_loader, model)"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Got 9774/10000 with accuracy: 97.74000000000001\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xucasxz87J3n"
      },
      "source": [
        ""
      ],
      "execution_count": 35,
      "outputs": []
    }
  ]
}