PyTorch Tutorial - First Neural Network.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **First Neural Network in PyTorch** - Iris Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **0.** Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn.functional as F\n",
    "from sklearn import datasets\n",
    "import torch.nn as nn\n",
    "import pandas as pd\n",
    "import torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **1.** Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = datasets.load_iris()\n",
    "X = pd.DataFrame(iris.data, columns=['SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth'])\n",
    "y = iris.target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we had imported the original dataset, `iris` would have had a `Name` column with the names of the three species.<br>\n",
    "In that case, to transform from species to label we could have used:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mappings = {\n",
    "#    'Iris-setosa':     0,\n",
    "#    'Iris-versicolor': 1,\n",
    "#    'Iris-virginica':  2\n",
    "# }\n",
    "\n",
    "# iris['Name'] = iris['Name'].apply(lambda x: mappings[x])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **2.** Train/Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split in train and test\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since `PyTorch` works with tensors, we need to transform everything from numpy arrays to pytorch tensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# From the dataframe we need to extract only values: type(X_train.values) = numpy.ndarray\n",
    "X_train = torch.FloatTensor(X_train.values)\n",
    "X_test = torch.FloatTensor(X_test.values)\n",
    "\n",
    "# The target was already in a good format: numpy.ndarray\n",
    "y_train = torch.LongTensor(y_train)\n",
    "y_test = torch.LongTensor(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0, 0, 1, 0, 0, 2, 1, 0, 0, 0, 2, 1, 1, 0, 0, 1, 2, 2, 1, 2, 1, 2, 1, 0,\n",
       "        2, 1, 0, 0, 0, 1, 2, 0, 0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 2, 2, 1, 1, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 1, 0, 2, 0, 0, 1, 1, 2, 1, 2, 2, 1, 0, 0, 2, 2, 0, 0,\n",
       "        0, 1, 2, 0, 2, 2, 0, 1, 1, 2, 1, 2, 0, 2, 1, 2, 1, 1, 1, 0, 1, 1, 0, 1,\n",
       "        2, 2, 0, 1, 2, 2, 0, 2, 0, 1, 2, 2, 1, 2, 1, 1, 2, 2, 0, 1, 2, 0, 1, 2])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type of the output\n",
    "y_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **3.** Model definition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`PyTorch` uses an object-orientated way of declaring models.<br>\n",
    "In the constructor we define all the layers and their architecture, while in the `forward()` method we define a forward pass.\n",
    "\n",
    "The structure of the network that we want to implement will be very simple:\n",
    "* fully connected layer (4 input features (number of features in `X`), 16 output features (arbitrary))\n",
    "* fully connected layer (16 input features (number of output features from the previous layer), 12 output features (arbitrary))\n",
    "* output layer (12 input features (number of output features from the previous layer), 3 output features (number of distinct classes))\n",
    "\n",
    "Moreover, we’ll use `ReLU()` as activation function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ANN(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(in_features=4, out_features=16)\n",
    "        self.fc2 = nn.Linear(in_features=16, out_features=12)\n",
    "        self.output = nn.Linear(in_features=12, out_features=3)\n",
    " \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.output(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ANN(\n",
       "  (fc1): Linear(in_features=4, out_features=16, bias=True)\n",
       "  (fc2): Linear(in_features=16, out_features=12, bias=True)\n",
       "  (output): Linear(in_features=12, out_features=3, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = ANN()\n",
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **4.** Compile and train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define:\n",
    "* criterion - how to measure loss (`CrossEntropyLoss()`)\n",
    "* optimizer - optimization algorithm (`Adam()` with a learning rate of 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We’ll train the model for 200 epochs, keeping track of loss.<br>\n",
    "Every 10 epochs we’ll output the current status, indicating on which epoch we are and what is the current loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 Loss: 1.2032405138015747\n",
      "Epoch: 10 Loss: 1.0274580717086792\n",
      "Epoch: 20 Loss: 0.9247804284095764\n",
      "Epoch: 30 Loss: 0.7262775897979736\n",
      "Epoch: 40 Loss: 0.49105897545814514\n",
      "Epoch: 50 Loss: 0.3468307852745056\n",
      "Epoch: 60 Loss: 0.182622030377388\n",
      "Epoch: 70 Loss: 0.10144554823637009\n",
      "Epoch: 80 Loss: 0.07508597522974014\n",
      "Epoch: 90 Loss: 0.06567076593637466\n",
      "Epoch: 100 Loss: 0.06160327047109604\n",
      "Epoch: 110 Loss: 0.05957133322954178\n",
      "Epoch: 120 Loss: 0.05830174311995506\n",
      "Epoch: 130 Loss: 0.05738382413983345\n",
      "Epoch: 140 Loss: 0.056645847856998444\n",
      "Epoch: 150 Loss: 0.05601460486650467\n",
      "Epoch: 160 Loss: 0.055451877415180206\n",
      "Epoch: 170 Loss: 0.05493714287877083\n",
      "Epoch: 180 Loss: 0.05445869266986847\n",
      "Epoch: 190 Loss: 0.05400870367884636\n"
     ]
    }
   ],
   "source": [
    "epochs = 200\n",
    "loss_arr = []\n",
    "\n",
    "for i in range(epochs):\n",
    "    y_hat = model.forward(X_train)\n",
    "    loss = criterion(y_hat, y_train)\n",
    "    loss_arr.append(loss)\n",
    " \n",
    "    if i % 10 == 0:\n",
    "        print(f'Epoch: {i} Loss: {loss}')\n",
    "        \n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Trend of the loss function\n",
    "loss_list = []\n",
    "\n",
    "for i in range(len(loss_arr)):\n",
    "    loss_list.append(float(loss_arr[i].detach()))\n",
    "\n",
    "plt.figure(figsize=(10,5))\n",
    "plt.plot(loss_list);\n",
    "plt.title('Loss Trend');\n",
    "plt.xlabel('Epoch');\n",
    "plt.ylabel('Loss');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **5.** Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to iterate over `X_test` and make a prediction.<br>\n",
    "Later we'll compare it to the actual value.\n",
    "\n",
    "We will use `torch.no_grad()` here because we’re just evaluating, there’s no need to update weights and biases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = []\n",
    "\n",
    "with torch.no_grad():\n",
    "   for val in X_test:\n",
    "       y_hat = model.forward(val)\n",
    "       preds.append(y_hat.argmax().item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The predictions are stored in `preds` array.<br>\n",
    "We can now make a `DataFrame` in `Pandas` with the following three attributes:\n",
    "* `Y` - actual value\n",
    "* `Y_hat` - predicted value\n",
    "* `Correct` - flag, 1 indicating `Y` and `Y_hat` match, 0 otherwise\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Y</th>\n",
       "      <th>Y_hat</th>\n",
       "      <th>Correct</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Y  Y_hat  Correct\n",
       "0  1      1        1\n",
       "1  0      0        1\n",
       "2  2      2        1\n",
       "3  1      1        1\n",
       "4  1      1        1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame({'Y': y_test, 'Y_hat': preds})\n",
    "df['Correct'] = [1 if corr == pred else 0 for corr, pred in zip(df['Y'], df['Y_hat'])]\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Percentage of correct predictions: 100.0 %\n"
     ]
    }
   ],
   "source": [
    "print('Percentage of correct predictions:', 100*df['Correct'].sum()/len(df), '%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The accuracy of the model on previously unseen data is 100%.<br>\n",
    "This is only because the Iris dataset is very simple to classify."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.10 64-bit (system)",
   "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.9.10"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "9805bccb659ffcb6952b8b29440036fac091f8170d71a5a402ad9a8f2988209f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}