mnist-demo-mlp.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa456e22",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets, transforms\n",
    "#import sklearn\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "#from sklearn.metrics import confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import time\n",
    "torch.manual_seed(101)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49dcf1b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "Transform = transforms.ToTensor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "084ad84c",
   "metadata": {},
   "outputs": [],
   "source": [
    "train = datasets.MNIST(root='./Data', train=True, download=True, transform=Transform)\n",
    "train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6659eb2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "test = datasets.MNIST(root='./Data', train=False, download=True, transform=Transform)\n",
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0f5348b",
   "metadata": {},
   "outputs": [],
   "source": [
    "image, label = train[0]\n",
    "print(f'Shape: {image.shape} \\nLabel: {label}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d93850e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(image.reshape(28,28))\n",
    "#default color mpa has a purple/yellow/green -> to convert to grayscale add cmap='grey'\n",
    "plt.imshow(image.reshape(28,28), cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70fd0e6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load data into batches, If shuffle=train, data will be shuffled on each epoch\n",
    "train_loader = DataLoader(train, batch_size=100, shuffle=True)\n",
    "test_loader = DataLoader(test, batch_size=500, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c48e444",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultilayerPerceptron(nn.Module):\n",
    "    def __init__(self, input_size=784, output_size=10, layers=[120, 84]):\n",
    "        super().__init__()\n",
    "        self.d1 = nn.Linear(input_size, layers[0])\n",
    "        self.d2 = nn.Linear(layers[0], layers[1])\n",
    "        self.d3 = nn.Linear(layers[1], output_size)\n",
    "    \n",
    "    def forward(self, X):\n",
    "        X = F.relu(self.d1(X))\n",
    "        X = F.relu(self.d2(X))\n",
    "        X = self.d3(X)\n",
    "        return F.log_softmax(X, dim=1)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c85c663f",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = MultilayerPerceptron()\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f7b8d52",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95cdd68d",
   "metadata": {},
   "outputs": [],
   "source": [
    "for images, labels in train_loader:\n",
    "    print('Initial batch shape', images.size())\n",
    "    break\n",
    "print('Batch shape after flattening ', images.view(100, -1).size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cc138a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 10\n",
    "train_losses = []\n",
    "test_losses = []\n",
    "train_correct = []\n",
    "test_correct = []\n",
    "\n",
    "for i in range(epochs):\n",
    "    \n",
    "    trn_corr = 0\n",
    "    tst_corr = 0\n",
    "    \n",
    "    # Run the trainining batches\n",
    "    for b, (X_train, y_train) in enumerate(train_loader):\n",
    "        b += 1\n",
    "        \n",
    "        #print(f'Training labels: {y_train.shape}')\n",
    "        #Apply the model\n",
    "        y_pred = model(X_train.view(100, -1))\n",
    "        loss = criterion(y_pred, y_train)\n",
    "        #\n",
    "        #print(f'Predicted value: {y_pred.shape}, Loss: {loss}')\n",
    "        #\n",
    "        # number of correct predictions. Max retuns values & indices. We return the indices.\n",
    "        predicted = torch.max(y_pred.data, 1)[1]\n",
    "        #\n",
    "        batch_corr = (predicted == y_train).sum()        \n",
    "        trn_corr += batch_corr\n",
    "        #\n",
    "        # print(f'Batch correct sum: {batch_corr}, Cumulative training/epoch correct: {trn_corr}')\n",
    "        #\n",
    "        # update the parameters\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        #print('Parameters updated')\n",
    "        # print interim result\n",
    "        if b%600 == 0:\n",
    "            print(f'epoch: {i:2} batch: {b:4} [{100*b:6}/60000] Train loss: {loss.item():10.8f} Train Accuracy: {trn_corr.item()*100/60000:.3f}%')\n",
    "            \n",
    "        # update training loss and accuracy for the epoch\n",
    "        train_losses.append(loss)\n",
    "        train_correct.append(trn_corr)\n",
    "        \n",
    "    # run the testing batches\n",
    "    #print('Begin, run the testing batches')\n",
    "    with torch.no_grad():\n",
    "        for b, (X_test, y_test) in enumerate(test_loader):\n",
    "            \n",
    "            #apply the model\n",
    "            y_val = model(X_test.view(500, -1))\n",
    "            \n",
    "            # tally the number of correct predictions\n",
    "            predicted = torch.max(y_val.data, 1)[1]\n",
    "            tst_corr += (predicted == y_test).sum()\n",
    "            #print('End, run the testing batches')\n",
    "            # update the test loss & accuracy for the epoch\n",
    "            loss = criterion(y_val, y_test)\n",
    "            test_losses.append(loss)\n",
    "            test_correct.append(tst_corr)\n",
    "    #\n",
    "    print(f'Test Accuracy: {test_correct[-1].item()*100/10000:.3f}%')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "752c58b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 ('base')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "d4d1e4263499bec80672ea0156c357c1ee493ec2b1c70f0acce89fc37c4a6abe"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}