ch-03/first_fc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7f1b57c6",
   "metadata": {},
   "source": [
    "### A Binary Classifier built using a FC network, with PyTorch\n",
    "\n",
    "We will be working with the Attrition dataset and we want to build a binary classifier: a model enabling to predict if the employee wants to leave the company (target = 1)\n",
    "\n",
    "Here we explore:\n",
    "* how to define Network Architecture\n",
    "* How to write the training loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "52466b7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "from torch import optim\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "from tqdm import tqdm\n",
    "\n",
    "from attrition_dataset import AttritionDataset\n",
    "\n",
    "# pyplot to plot the training loss\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "978d81c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check that access to GPU is OK\n",
    "torch.cuda.is_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1cbee1b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f7efad99310>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "\n",
    "# need to make training reproducible\n",
    "torch.manual_seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dac93fb9",
   "metadata": {},
   "source": [
    "#### Here you find defined the Network architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6fd48930",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we need to implement a class subclassing nn.Module, writing the forward method\n",
    "\n",
    "#non conviene avere una rete troppo profonda e con troppi parametri... i dati non sono tantissimi\n",
    "class FirstFC(nn.Module):\n",
    "    # here we define the structure\n",
    "    def __init__(self):\n",
    "        super(FirstFC, self).__init__()\n",
    "        self.fc1 = nn.Linear(30, 30)\n",
    "        self.fc2 = nn.Linear(30, 30)\n",
    "        self.fc3 = nn.Linear(30, 30)\n",
    "        self.fc4 = nn.Linear(30, 10)\n",
    "        self.fc5 = nn.Linear(10, 1)\n",
    "        # fondamentale memorizzare anche il dropout tra gli attributi \n",
    "        # per disattivarlo in modalità eval\n",
    "        # altrimenti in eval i risultati non sono pienamente riproducibili\n",
    "        self.drop = nn.Dropout(0.1)\n",
    "    \n",
    "    # here we implement the forward pass\n",
    "    def forward(self, x):\n",
    "        x = self.fc1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.drop(x)\n",
    "        \n",
    "        x = self.fc2(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.drop(x)\n",
    "        \n",
    "        x = F.relu(self.fc3(x))\n",
    "        x = F.relu(self.fc4(x))\n",
    "        \n",
    "        # the last layer must give the prob that it is positive... so we use sigmoid\n",
    "        # so we must use nn.BCELoss\n",
    "        x = torch.sigmoid(self.fc5(x))\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "18d4bc18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have 2219 samples in training set...\n",
      "We have 247 samples in validation set...\n"
     ]
    }
   ],
   "source": [
    "# dataset\n",
    "attrition_path = \"/opt/notebooks/ads-examples/oracle_data/orcl_attrition.csv\"\n",
    "\n",
    "attrition_ds = AttritionDataset(attrition_path, over_sample=True)\n",
    "\n",
    "# split in train and validation\n",
    "FRAC = 0.1\n",
    "N_TRAIN = int(len(attrition_ds)*(1. - FRAC))\n",
    "N_VALID = len(attrition_ds) - N_TRAIN\n",
    "\n",
    "train_set, val_set = torch.utils.data.random_split(attrition_ds, [N_TRAIN, N_VALID], generator=torch.Generator().manual_seed(42))\n",
    "\n",
    "print(f\"We have {len(train_set)} samples in training set...\")\n",
    "print(f\"We have {len(val_set)} samples in validation set...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5262f792",
   "metadata": {},
   "outputs": [],
   "source": [
    "# oversampling the size has greatly increased performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "35e4e58b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dataloaders\n",
    "\n",
    "# aumentando il btch size le prestazioni peggiorano\n",
    "BATCH_SIZE = 64\n",
    "\n",
    "train_dl = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True)\n",
    "val_dl = DataLoader(val_set, batch_size=BATCH_SIZE, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "b7d2aec3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FirstFC(\n",
       "  (fc1): Linear(in_features=30, out_features=30, bias=True)\n",
       "  (fc2): Linear(in_features=30, out_features=30, bias=True)\n",
       "  (fc3): Linear(in_features=30, out_features=30, bias=True)\n",
       "  (fc4): Linear(in_features=30, out_features=10, bias=True)\n",
       "  (fc5): Linear(in_features=10, out_features=1, bias=True)\n",
       "  (drop): Dropout(p=0.1, inplace=False)\n",
       ")"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# istantiate the PyTorch model\n",
    "model_net = FirstFC()\n",
    "\n",
    "# check\n",
    "model_net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "e8d93c6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model has: 3111 trainable params...\n"
     ]
    }
   ],
   "source": [
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "print(f\"The model has: {count_parameters(model_net)} trainable params...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "92f1e143",
   "metadata": {},
   "outputs": [],
   "source": [
    "# move to gpu\n",
    "# model_net = model_net.to(\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "033954c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# here we define, writing all the code, the training loop\n",
    "\n",
    "# this part is (the first time) complicated !!\n",
    "\n",
    "def train(model, optimizer, loss_fn, train_loader, validation_loader, epochs=20, device=\"cpu\"):\n",
    "    vet_epochs = [] \n",
    "    train_loss_history = []\n",
    "    val_loss_history = []\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        \n",
    "        model.train()\n",
    "        training_loss = 0.0\n",
    "        \n",
    "        for batch in train_loader:\n",
    "            optimizer.zero_grad()\n",
    "            inputs, targets = batch\n",
    "            \n",
    "            # move to device\n",
    "            inputs = inputs.to(device)\n",
    "            targets = targets.to(device)\n",
    "            \n",
    "            # apply the model\n",
    "            outputs = model(inputs)\n",
    "            \n",
    "            # we need to add this !\n",
    "            targets = targets.unsqueeze(1)\n",
    "            \n",
    "            loss = loss_fn(outputs, targets)\n",
    "            \n",
    "            # here we do the back propagation !!\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "            training_loss += loss.data.item() * inputs.size(0)\n",
    "        \n",
    "        training_loss /= len(train_loader.dataset)\n",
    "        \n",
    "        # evaluation\n",
    "        model.eval()\n",
    "        val_loss = 0.0\n",
    "        \n",
    "        for batch in validation_loader:\n",
    "            inputs, targets = batch\n",
    "            \n",
    "            inputs = inputs.to(device)\n",
    "            targets = targets.to(device)\n",
    "            \n",
    "            outputs = model(inputs)\n",
    "    \n",
    "            targets = targets.unsqueeze(1)\n",
    "            \n",
    "            loss = loss_fn(outputs, targets)\n",
    "            \n",
    "            val_loss += loss.data.item() * inputs.size(0)\n",
    "            \n",
    "        val_loss /= len(validation_loader.dataset)\n",
    "        \n",
    "        # print only every 20 epochs\n",
    "        if epoch%20 == 0:\n",
    "            vet_epochs.append(epoch)\n",
    "            train_loss_history.append(training_loss)\n",
    "            val_loss_history.append(val_loss)\n",
    "            \n",
    "            print(f'Epoch: {epoch}, Training Loss: {round(training_loss, 3)}, Validation Loss: {round(val_loss, 3)}')\n",
    "    \n",
    "    # prepare output dict\n",
    "    out_dict = {\n",
    "        \"epochs\": vet_epochs,\n",
    "        \"train_loss_hist\": train_loss_history,\n",
    "        \"val_loss_hist\": val_loss_history\n",
    "    }\n",
    "    \n",
    "    return out_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "e0294807",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Training Loss: 10.315, Validation Loss: 2.131\n",
      "Epoch: 20, Training Loss: 0.69, Validation Loss: 0.679\n",
      "Epoch: 40, Training Loss: 0.66, Validation Loss: 0.677\n",
      "Epoch: 60, Training Loss: 0.657, Validation Loss: 0.676\n",
      "Epoch: 80, Training Loss: 0.652, Validation Loss: 0.661\n",
      "Epoch: 100, Training Loss: 0.646, Validation Loss: 0.651\n",
      "Epoch: 120, Training Loss: 0.643, Validation Loss: 0.644\n",
      "Epoch: 140, Training Loss: 0.636, Validation Loss: 0.648\n",
      "Epoch: 160, Training Loss: 0.627, Validation Loss: 0.641\n",
      "Epoch: 180, Training Loss: 0.619, Validation Loss: 0.631\n",
      "Epoch: 200, Training Loss: 0.615, Validation Loss: 0.618\n",
      "Epoch: 220, Training Loss: 0.604, Validation Loss: 0.619\n",
      "Epoch: 240, Training Loss: 0.58, Validation Loss: 0.563\n",
      "Epoch: 260, Training Loss: 0.575, Validation Loss: 0.601\n",
      "Epoch: 280, Training Loss: 0.557, Validation Loss: 0.545\n",
      "Epoch: 300, Training Loss: 0.54, Validation Loss: 0.531\n",
      "Epoch: 320, Training Loss: 0.536, Validation Loss: 0.521\n",
      "Epoch: 340, Training Loss: 0.541, Validation Loss: 0.527\n",
      "Epoch: 360, Training Loss: 0.533, Validation Loss: 0.509\n",
      "Epoch: 380, Training Loss: 0.522, Validation Loss: 0.501\n",
      "Epoch: 400, Training Loss: 0.511, Validation Loss: 0.525\n",
      "Epoch: 420, Training Loss: 0.488, Validation Loss: 0.481\n",
      "Epoch: 440, Training Loss: 0.496, Validation Loss: 0.47\n",
      "Epoch: 460, Training Loss: 0.502, Validation Loss: 0.499\n",
      "Epoch: 480, Training Loss: 0.5, Validation Loss: 0.495\n",
      "Epoch: 500, Training Loss: 0.491, Validation Loss: 0.5\n",
      "Epoch: 520, Training Loss: 0.527, Validation Loss: 0.523\n",
      "Epoch: 540, Training Loss: 0.498, Validation Loss: 0.502\n",
      "Epoch: 560, Training Loss: 0.481, Validation Loss: 0.518\n",
      "Epoch: 580, Training Loss: 0.474, Validation Loss: 0.482\n",
      "Epoch: 600, Training Loss: 0.514, Validation Loss: 0.508\n",
      "Epoch: 620, Training Loss: 0.47, Validation Loss: 0.434\n",
      "Epoch: 640, Training Loss: 0.504, Validation Loss: 0.55\n",
      "Epoch: 660, Training Loss: 0.475, Validation Loss: 0.467\n",
      "Epoch: 680, Training Loss: 0.456, Validation Loss: 0.489\n",
      "Epoch: 700, Training Loss: 0.456, Validation Loss: 0.537\n",
      "Epoch: 720, Training Loss: 0.446, Validation Loss: 0.435\n",
      "Epoch: 740, Training Loss: 0.488, Validation Loss: 0.445\n",
      "Epoch: 760, Training Loss: 0.466, Validation Loss: 0.437\n",
      "Epoch: 780, Training Loss: 0.462, Validation Loss: 0.528\n",
      "CPU times: user 21min 12s, sys: 2min 35s, total: 23min 48s\n",
      "Wall time: 1min 59s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "LEARNING_RATE = 0.001\n",
    "EPOCHS = 800\n",
    "\n",
    "optimizer = optim.Adam(model_net.parameters(), lr=LEARNING_RATE)\n",
    "\n",
    "history = train(model_net, optimizer, nn.BCELoss(), train_dl, val_dl, epochs=EPOCHS, device=\"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "e4ecf130",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# let's exclude the first point to zoom in following steps\n",
    "start_from = 1\n",
    "\n",
    "plt.figure(figsize=(9, 6))\n",
    "plt.title(\"Loss \")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.plot(history[\"epochs\"][start_from:], history[\"train_loss_hist\"][start_from:], label='Training loss')\n",
    "# plt.plot(history[\"epochs\"], history[\"train_loss_hist\"], \"ro\")\n",
    "plt.plot(history[\"epochs\"][start_from:], history[\"val_loss_hist\"][start_from:], label='Validation loss')\n",
    "plt.legend(loc='upper right')\n",
    "plt.grid(True)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1a8098a",
   "metadata": {},
   "source": [
    "#### Ok: from the training loss it seems that the network is learning... let's go to validation\n",
    "\n",
    "Timings:\n",
    "* GPU: 1min. 20'', 700 epochs\n",
    "* CPU: 1 min. 22'', 700 epochs\n",
    "\n",
    "L'utilizzation della GPU è bassa (13%), con cosi pochi dati l'impiego della GPU non fa la differenza.\n",
    "Aumentando il batch size (64->256) ovviamente il tempo diminuisce ma le prestazioni peggiorano\n",
    "\n",
    "Dal grafico si può osservare che da una certa epoch in poi (500?) il LR statico è troppo alto.\n",
    "Un risultato migliore si può ottenere cambiando dinamicamente il LR... una prassi nei modelli \"seri\".\n",
    "Vedremo in un capitolo successivo come si può fare."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21a24e04",
   "metadata": {},
   "source": [
    "### evaluate the model and compute accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "bc324016",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Summary:\n",
      "Accuracy on validation set is: 0.785\n"
     ]
    }
   ],
   "source": [
    "# è fondamentale mettere il modello in modalità eval\n",
    "# per disabilitare il dropout che altrimenti produrrebbe un certo\n",
    "# livello di casualità nell'inferenza\n",
    "\n",
    "model_net.eval()\n",
    "\n",
    "device = \"cpu\"\n",
    "\n",
    "THR = 0.5\n",
    "\n",
    "tot_correct = 0\n",
    "\n",
    "for batch in val_dl:\n",
    "    inputs, targets = batch\n",
    "    \n",
    "    inputs = inputs.to(device)\n",
    "    targets = targets.to(device)\n",
    "        \n",
    "    outputs = model_net(inputs)\n",
    "    \n",
    "    class_outputs = torch.where(outputs >= THR, 1, 0)\n",
    "    class_outputs = class_outputs.squeeze(1)\n",
    "    outputs = outputs.squeeze(1)\n",
    "    \n",
    "    is_ok = torch.eq(class_outputs, targets)\n",
    "    \n",
    "    # ora è suffciente sommare True = 1\n",
    "    tot_correct += is_ok.sum().item()\n",
    "\n",
    "accuracy = round(tot_correct/len(val_set), 3)\n",
    "\n",
    "print()\n",
    "print(\"Summary:\")\n",
    "print(f\"Accuracy on validation set is: {accuracy}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2f4eda8",
   "metadata": {},
   "source": [
    "### conclusioni:\n",
    "* over-sampling (fatto dalla classe AttritionDataset\n",
    "* una definizione attenta degli iper-parametri (faticosa, n. neuroni, LR)\n",
    "\n",
    "consentono di ottenere un'accuratezza tra il 73% e 80%... con TabNet vedremo che si riesce ad arrivare al 95% "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48735ad7",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:pytorch110_p37_gpu_v1]",
   "language": "python",
   "name": "conda-env-pytorch110_p37_gpu_v1-py"
  },
  "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.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}