mlp_pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torch.utils.data as data\n",
    "\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "SEED = 1234\n",
    "\n",
    "random.seed(SEED)\n",
    "np.random.seed(SEED)\n",
    "torch.manual_seed(SEED)\n",
    "torch.cuda.manual_seed(SEED)\n",
    "torch.backends.cudnn.deterministic = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(210, 8)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text_data=open('seeds_dataset.txt').read()\n",
    "text_data=text_data.split('\\n')\n",
    "\n",
    "df=pd.DataFrame(list(map(lambda x:x.split('\\t'), text_data)))\n",
    "df.drop(columns=[8,9],inplace=True)\n",
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>15.26</td>\n",
       "      <td>14.84</td>\n",
       "      <td>0.871</td>\n",
       "      <td>5.763</td>\n",
       "      <td>3.312</td>\n",
       "      <td>2.221</td>\n",
       "      <td>5.22</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>14.88</td>\n",
       "      <td>14.57</td>\n",
       "      <td>0.8811</td>\n",
       "      <td>5.554</td>\n",
       "      <td>3.333</td>\n",
       "      <td>1.018</td>\n",
       "      <td>4.956</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>14.29</td>\n",
       "      <td>14.09</td>\n",
       "      <td>0.905</td>\n",
       "      <td>5.291</td>\n",
       "      <td>3.337</td>\n",
       "      <td>2.699</td>\n",
       "      <td>4.825</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>13.84</td>\n",
       "      <td>13.94</td>\n",
       "      <td>0.8955</td>\n",
       "      <td>5.324</td>\n",
       "      <td>3.379</td>\n",
       "      <td>2.259</td>\n",
       "      <td>4.805</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>16.14</td>\n",
       "      <td>14.99</td>\n",
       "      <td>0.9034</td>\n",
       "      <td>5.658</td>\n",
       "      <td>3.562</td>\n",
       "      <td>1.355</td>\n",
       "      <td>5.175</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       0      1       2      3      4      5      6  7\n",
       "0  15.26  14.84   0.871  5.763  3.312  2.221   5.22  1\n",
       "1  14.88  14.57  0.8811  5.554  3.333  1.018  4.956  1\n",
       "2  14.29  14.09   0.905  5.291  3.337  2.699  4.825  1\n",
       "3  13.84  13.94  0.8955  5.324  3.379  2.259  4.805  1\n",
       "4  16.14  14.99  0.9034  5.658  3.562  1.355  5.175  1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    70\n",
       "2    70\n",
       "3    70\n",
       "Name: 7, dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[7].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "target=df[[7]].astype('int')\n",
    "\n",
    "df.drop(columns=7,inplace=True)\n",
    "\n",
    "scaler=StandardScaler()\n",
    "df=pd.DataFrame(scaler.fit_transform(df),columns=df.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = list(zip(df.values, target.values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(151, 38, 21)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train, test = train_test_split(dataset, test_size=0.1, random_state=SEED)\n",
    "train, val = train_test_split(train, test_size=0.2, random_state=SEED)\n",
    "\n",
    "len(train), len(val), len(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(19, 5, 3)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BATCH_SIZE = 8\n",
    "\n",
    "train_iterator = data.DataLoader(train, shuffle=True, batch_size=BATCH_SIZE)\n",
    "val_iterator = data.DataLoader(val, batch_size=BATCH_SIZE)\n",
    "test_iterator = data.DataLoader(test, batch_size=BATCH_SIZE)\n",
    "\n",
    "len(train_iterator), len(val_iterator), len(test_iterator) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_dim = 7\n",
    "hidden_dim = 32\n",
    "output_dim = 3\n",
    "\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, input_dim, hidden_dim, output_dim):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.input_dim = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.output_dim = output_dim\n",
    "        \n",
    "        self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, output_dim)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        hidden = torch.sigmoid(self.fc1(x))\n",
    "        output = torch.softmax(self.fc2(hidden), axis=1)\n",
    "        \n",
    "        return output\n",
    "    \n",
    "model = MLP(input_dim, hidden_dim, output_dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLP(\n",
       "  (fc1): Linear(in_features=7, out_features=32, bias=True)\n",
       "  (fc2): Linear(in_features=32, out_features=3, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "355"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "count_parameters(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(model.parameters(), lr=0.01)\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.to(device)\n",
    "criterion = criterion.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_accuracy(y_score, y):\n",
    "    \n",
    "    y_pred = torch.argmax(y_score, axis=1)\n",
    "    \n",
    "    return sum(y_pred == y) / len(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>optimizer.zero_grad()</code>\n",
    "\n",
    "In PyTorch, we need to set the gradients to zero before model parameter update because **PyTorch accumulates gradients on subsequent backward passes by default**. The accumulation of gradients happen during the <code>loss.backward()</code> step.\n",
    "\n",
    "<code>loss.backward()</code>\n",
    "    \n",
    "Calculating gradient for all parameters for which <code>requires_grad=True</code> and storing it in <code>parameter.grad</code>. This step is commonly called as **BackPropagation**.\n",
    "\n",
    "<code>optimizer.step()</code>\n",
    "    \n",
    "Updating parameters with gradients calculated in the above step as per optimization algorithm (for example - in Gradient Descent, this would simply subtract the gradients in <code>parameter.grad</code> multiplied by learning rate). Learning Rate is considered as specified **while initializing optimizer**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, iterator, optimizer, criterion, device):\n",
    "\n",
    "    epoch_loss = 0 \n",
    "    epoch_acc = 0\n",
    "    \n",
    "    model.train()\n",
    "    \n",
    "    for x, y in iterator:\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        x=x.float().to(device)\n",
    "        y=y.squeeze(dim=1).long().to(device)-1\n",
    "\n",
    "        batch_size = x.shape[0]\n",
    "        x = x.view(batch_size, -1).float()\n",
    "\n",
    "        y_score = model(x)\n",
    "        \n",
    "        loss = criterion(y_score, y)\n",
    "        acc = calculate_accuracy(y_score, y)\n",
    "        \n",
    "        loss.backward()\n",
    "        \n",
    "        optimizer.step()\n",
    "        \n",
    "        epoch_loss += loss.item()\n",
    "        epoch_acc += acc.item()\n",
    "        \n",
    "    return epoch_loss / len(iterator), epoch_acc / len(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(model, iterator, criterion, device):\n",
    "\n",
    "    epoch_loss = 0 \n",
    "    epoch_acc = 0\n",
    "    \n",
    "    model.eval()\n",
    "    \n",
    "    for x, y in iterator:\n",
    "\n",
    "        x=x.float().to(device)\n",
    "        y=y.squeeze(dim=1).long().to(device)-1\n",
    "\n",
    "        batch_size = x.shape[0]\n",
    "        x = x.view(batch_size, -1).float()\n",
    "\n",
    "        y_score = model(x)\n",
    "        \n",
    "        loss = criterion(y_score, y)\n",
    "        acc = calculate_accuracy(y_score, y)\n",
    "\n",
    "        epoch_loss += loss.item()\n",
    "        epoch_acc += acc.item()\n",
    "        \n",
    "    return epoch_loss / len(iterator), epoch_acc / len(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 100/100 [00:02<00:00, 43.58it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.586 | Train Acc: 0.974\n",
      "Val Loss: 0.633 | Val Acc: 0.925\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 100\n",
    "\n",
    "TRAIN_LOSS=[]\n",
    "VAL_LOSS=[]\n",
    "\n",
    "TRAIN_ACC=[]\n",
    "VAL_ACC=[]\n",
    "\n",
    "for epoch in tqdm(range(EPOCHS)):\n",
    "    \n",
    "    train_loss, train_acc = train(model, train_iterator, optimizer, criterion, device)\n",
    "    \n",
    "    val_loss, val_acc = evaluate(model, val_iterator, criterion, device)\n",
    "    \n",
    "    TRAIN_LOSS.append(train_loss)\n",
    "    VAL_LOSS.append(val_loss)\n",
    "    \n",
    "    TRAIN_ACC.append(train_acc)\n",
    "    VAL_ACC.append(val_acc)\n",
    "    \n",
    "print(f'Train Loss: {train_loss:.3f} | Train Acc: {train_acc:.3f}')\n",
    "print(f'Val Loss: {val_loss:.3f} | Val Acc: {val_acc:.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig=plt.figure(figsize=(18,5))\n",
    "\n",
    "plt.subplot(121)\n",
    "\n",
    "plt.plot(TRAIN_LOSS, label='Training Loss')\n",
    "plt.plot(VAL_LOSS, label='Validation Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.plot(TRAIN_ACC, label='Training Accuracy')\n",
    "plt.plot(VAL_ACC, label='Validation Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_loss, test_acc = evaluate(model, test_iterator, criterion, device)\n",
    "test_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}