SmartFall_GRU_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:27:46.173057Z",
     "start_time": "2020-07-28T10:27:45.616963Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tqdm\n",
    "import collections \n",
    "import time\n",
    "%matplotlib inline\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from torch.optim.lr_scheduler import _LRScheduler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:27:46.865374Z",
     "start_time": "2020-07-28T10:27:46.824337Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cuda:0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "device = 'cuda:0' if torch.cuda.is_available() else 'cpu'\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:27:47.536122Z",
     "start_time": "2020-07-28T10:27:47.464966Z"
    }
   },
   "outputs": [],
   "source": [
    "data_dir = \"/workspace/inkyung/Fall Detection/\"\n",
    "\n",
    "train = pd.read_csv('/workspace/inkyung/Fall Detection/SmartFall_dataset/SmartFall Training.csv')\n",
    "test = pd.read_csv('/workspace/inkyung/Fall Detection/SmartFall_dataset/SmartFall Testing.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprecessing\n",
    "\n",
    "- sliding window size of 40\n",
    "- if data contains all fall samples(25 samples) then, label as 'FALL'\n",
    "- unless, it's all labelled as 'ADL'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:31:06.773038Z",
     "start_time": "2020-07-28T10:30:37.415715Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7b5318b9ddf74035ad4982125158d1d0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=92741.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "n = 40\n",
    "X_train, y_train = list(), list()\n",
    "\n",
    "for i in tqdm.notebook.tqdm(range(0, len(train)-40)):\n",
    "    temp = list()\n",
    "    \n",
    "    temp.append(train[' ms_accelerometer_x'][i : i + n])\n",
    "    temp.append(train[' ms_accelerometer_y'][i : i + n])\n",
    "    temp.append(train[' ms_accelerometer_z'][i : i + n])\n",
    "    \n",
    "    cnt = collections.Counter(train['outcome'][i: i + n])\n",
    "    num_adl = cnt[0]\n",
    "    num_fall = cnt[1]\n",
    "    \n",
    "    if num_fall == 25:\n",
    "        y_train.append(1)\n",
    "    else:\n",
    "        y_train.append(0)\n",
    "    \n",
    "    X_train.append(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:33:49.234112Z",
     "start_time": "2020-07-28T10:33:20.713591Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6e14cc36e6cc4ea49ba04bcbaaf968a0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=90985.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "n = 40\n",
    "X_test_adl, X_test_fall, y_test_adl, y_test_fall = list(), list(), list(), list()\n",
    "for i in tqdm.notebook.tqdm(range(0, len(test) - 40)):\n",
    "    temp = list()\n",
    "    \n",
    "    temp.append(test[' ms_accelerometer_x'][i : i + n])\n",
    "    temp.append(test[' ms_accelerometer_y'][i : i + n])\n",
    "    temp.append(test[' ms_accelerometer_z'][i : i + n])\n",
    "    \n",
    "    cnt = collections.Counter(test['outcome'][i : i + n])\n",
    "    num_adl = cnt[0]\n",
    "    num_fall = cnt[1]\n",
    "    \n",
    "    if num_fall == 25:\n",
    "        y_test_fall.append(1)\n",
    "        X_test_fall.append(temp)\n",
    "    else:\n",
    "        y_test_adl.append(0)\n",
    "        X_test_adl.append(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:33:52.059775Z",
     "start_time": "2020-07-28T10:33:52.052917Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3216\n",
      "87769\n"
     ]
    }
   ],
   "source": [
    "print(len(y_test_fall))\n",
    "print(len(y_test_adl))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:34:15.323838Z",
     "start_time": "2020-07-28T10:34:15.078385Z"
    }
   },
   "outputs": [],
   "source": [
    "# to keep the balance between ADL and FALL data, used only part of ADL data\n",
    "\n",
    "X_test_adl = X_test_adl[:3216]\n",
    "y_test_adl = y_test_adl[:3216]\n",
    "\n",
    "y_test = y_test_adl + y_test_fall\n",
    "X_test = X_test_adl + X_test_fall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:34:43.212536Z",
     "start_time": "2020-07-28T10:34:43.202680Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length of test data 6432\n"
     ]
    }
   ],
   "source": [
    "print('length of test data', len(X_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:34:59.594029Z",
     "start_time": "2020-07-28T10:34:59.580077Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train data adl and fall ratio\n",
      "--------------------------------\n",
      "train data adl ratio:  87509\n",
      "train data fall ratio:  5232\n",
      "--------------------------------\n",
      "test data adl ratio:  3216\n",
      "test data fall ratio:  3216\n"
     ]
    }
   ],
   "source": [
    "print('train data adl and fall ratio')\n",
    "print('--------------------------------')\n",
    "cnt_train = collections.Counter(y_train)\n",
    "print('train data adl ratio: ', cnt_train[0])\n",
    "print('train data fall ratio: ', cnt_train[1])\n",
    "print('--------------------------------')\n",
    "\n",
    "cnt_test = collections.Counter(y_test)\n",
    "print('test data adl ratio: ', cnt_test[0])\n",
    "print('test data fall ratio: ', cnt_test[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## implementing cyclic learning rate\n",
    "\n",
    "- implementing a simple cosine scheduler "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:39:52.765328Z",
     "start_time": "2020-07-28T10:39:52.744636Z"
    }
   },
   "outputs": [],
   "source": [
    "class CyclicLR(_LRScheduler):\n",
    "    \n",
    "    def __init__(self, optimizer, schedule, last_epoch=-1):\n",
    "        assert callable(schedule)\n",
    "        self.schedule = schedule\n",
    "        super().__init__(optimizer, last_epoch)\n",
    "\n",
    "    def get_lr(self):\n",
    "        return [self.schedule(self.last_epoch, lr) for lr in self.base_lrs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:39:53.481098Z",
     "start_time": "2020-07-28T10:39:53.469755Z"
    }
   },
   "outputs": [],
   "source": [
    "def cosine(t_max, eta_min=0):\n",
    "    \n",
    "    def scheduler(epoch, base_lr):\n",
    "        t = epoch % t_max\n",
    "        return eta_min + (base_lr - eta_min)*(1 + np.cos(np.pi*t/t_max))/2\n",
    "    \n",
    "    return scheduler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:39:54.469197Z",
     "start_time": "2020-07-28T10:39:54.342062Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f33e0d6bb10>]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 100\n",
    "sched = cosine(n)\n",
    "lrs = [sched(t, 1) for t in range(n * 4)]\n",
    "plt.plot(lrs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GRU model declaration \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:39:59.476547Z",
     "start_time": "2020-07-28T10:39:59.453707Z"
    }
   },
   "outputs": [],
   "source": [
    "class GRUNet(nn.Module):\n",
    "    def __init__(self, input_dim, hidden_dim, output_dim, n_layers):\n",
    "        super(GRUNet, self).__init__()\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.n_layers = n_layers\n",
    "        \n",
    "        self.GRU = nn.GRU(input_size = input_dim,\n",
    "                          hidden_size = hidden_dim, \n",
    "                          num_layers = n_layers,\n",
    "                          batch_first=True)\n",
    "        self.fc = nn.Linear(hidden_dim, output_dim)\n",
    "        self.relu = nn.ReLU()\n",
    "        \n",
    "    def forward(self, x):\n",
    "        h0 = self.init_hidden(x)\n",
    "        out, hn = self.GRU(x, h0)\n",
    "        out = self.fc(self.relu(out[:, -1]))\n",
    "        return out\n",
    "    \n",
    "    def init_hidden(self, x):\n",
    "        h0 = torch.zeros(self.n_layers, x.size(0), self.hidden_dim)\n",
    "        return h0.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:40:23.899605Z",
     "start_time": "2020-07-28T10:40:06.398708Z"
    }
   },
   "outputs": [],
   "source": [
    "X_train = np.asarray(X_train).reshape(-1, 40, 3)\n",
    "y_train = np.asarray(y_train).reshape(-1, )\n",
    "\n",
    "X_test = np.asarray(X_test).reshape(-1, 40, 3)\n",
    "y_test = np.asarray(y_test).reshape(-1, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:40:23.909096Z",
     "start_time": "2020-07-28T10:40:23.901300Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "enc = LabelEncoder()\n",
    "\n",
    "y_train = enc.fit_transform(y_train)\n",
    "y_test = enc.fit_transform(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:40:23.982434Z",
     "start_time": "2020-07-28T10:40:23.911036Z"
    }
   },
   "outputs": [],
   "source": [
    "X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:40:32.576125Z",
     "start_time": "2020-07-28T10:40:32.566613Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "\n",
    "train_data = TensorDataset(torch.from_numpy(X_train), torch.from_numpy(y_train))\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    train_data,\n",
    "    shuffle=True, batch_size=batch_size)\n",
    "\n",
    "valid_data = TensorDataset(torch.from_numpy(X_valid), torch.from_numpy(y_valid))\n",
    "valid_loader = torch.utils.data.DataLoader(\n",
    "    valid_data,\n",
    "    shuffle=True, batch_size=batch_size)\n",
    "\n",
    "test_data =TensorDataset(torch.from_numpy(X_test), torch.from_numpy(y_test))\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    test_data,\n",
    "    shuffle=True, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:48:41.930197Z",
     "start_time": "2020-07-28T10:48:41.898982Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GRUNet(\n",
      "  (GRU): GRU(3, 256, num_layers=2, batch_first=True)\n",
      "  (fc): Linear(in_features=256, out_features=2, bias=True)\n",
      "  (relu): ReLU()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "input_dim = next(iter(train_loader))[0].shape[2]\n",
    "output_dim = 2\n",
    "n_layers = 2\n",
    "hidden_dim = 256\n",
    "\n",
    "lr = 0.0001\n",
    "n_epochs = 40\n",
    "iterations_per_epoch = len(train_loader)\n",
    "best_acc = 0.\n",
    "patience, trials = 15, 0\n",
    "\n",
    "model = GRUNet(input_dim, hidden_dim, output_dim, n_layers).cuda()\n",
    "print(model)\n",
    "criterion = nn.CrossEntropyLoss().cuda()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "sched = CyclicLR(optimizer, cosine(t_max=iterations_per_epoch * 2, eta_min = lr/10))\n",
    "epoch_times = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:54:37.562768Z",
     "start_time": "2020-07-28T10:48:42.417547Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start model training\n",
      "Epoch 1 best model saved with accuracy: 94.39%\n",
      "Epoch 2 best model saved with accuracy: 94.79%\n",
      "Epoch 3 best model saved with accuracy: 97.15%\n",
      "Epoch 4 best model saved with accuracy: 97.40%\n",
      "Epoch:   5. Loss: 0.0880. Acc.: 97.73%\n",
      "Epoch 5 best model saved with accuracy: 97.73%\n",
      "Epoch 6 best model saved with accuracy: 97.94%\n",
      "Epoch 7 best model saved with accuracy: 98.11%\n",
      "Epoch 8 best model saved with accuracy: 98.16%\n",
      "Epoch 9 best model saved with accuracy: 98.34%\n",
      "Epoch:  10. Loss: 0.0110. Acc.: 98.25%\n",
      "Epoch 11 best model saved with accuracy: 98.36%\n",
      "Epoch 12 best model saved with accuracy: 98.48%\n",
      "Epoch 13 best model saved with accuracy: 98.57%\n",
      "Epoch:  15. Loss: 0.3438. Acc.: 98.51%\n",
      "Epoch 16 best model saved with accuracy: 98.62%\n",
      "Epoch 18 best model saved with accuracy: 98.70%\n",
      "Epoch:  20. Loss: 0.0545. Acc.: 98.74%\n",
      "Epoch 20 best model saved with accuracy: 98.74%\n",
      "Epoch 23 best model saved with accuracy: 98.80%\n",
      "Epoch:  25. Loss: 0.0000. Acc.: 98.68%\n",
      "Epoch 26 best model saved with accuracy: 98.86%\n",
      "Epoch 28 best model saved with accuracy: 98.89%\n",
      "Epoch:  30. Loss: 0.0164. Acc.: 98.94%\n",
      "Epoch 30 best model saved with accuracy: 98.94%\n",
      "Epoch 32 best model saved with accuracy: 98.95%\n",
      "Epoch 34 best model saved with accuracy: 99.02%\n",
      "Epoch:  35. Loss: 0.0038. Acc.: 98.85%\n",
      "Epoch 36 best model saved with accuracy: 99.05%\n",
      "Epoch 38 best model saved with accuracy: 99.12%\n",
      "Epoch:  40. Loss: 0.0013. Acc.: 99.17%\n",
      "Epoch 40 best model saved with accuracy: 99.17%\n",
      "Total Training Time: 225.94266624700032 seconds\n"
     ]
    }
   ],
   "source": [
    "train_loss, train_acc = list(), list()\n",
    "print('Start model training')\n",
    "\n",
    "for epoch in range(1, n_epochs + 1):\n",
    "    start_time = time.process_time()\n",
    "    for i, (X_batch, y_batch) in enumerate(train_loader):\n",
    "        model.train()\n",
    "        X_batch = X_batch.float().cuda()\n",
    "        y_batch = y_batch.cuda()\n",
    "        optimizer.zero_grad()\n",
    "        out = model(X_batch)\n",
    "        loss = criterion(out, y_batch)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        sched.step()\n",
    "    current_time = time.process_time()\n",
    "    epoch_times.append(current_time-start_time)\n",
    "    \n",
    "    model.eval()\n",
    "    correct, total = 0, 0\n",
    "    for x_val, y_val in valid_loader:\n",
    "        x_val, y_val = [t.cuda() for t in (x_val.float(), y_val)]\n",
    "        out = model(x_val)\n",
    "        preds = F.log_softmax(out, dim=1).argmax(dim=1)\n",
    "        total += y_val.size(0)\n",
    "        correct += (preds == y_val).sum().item()\n",
    "        \n",
    "    acc = correct / total\n",
    "    \n",
    "    train_loss.append(loss.item())\n",
    "    train_acc.append(acc)\n",
    "    \n",
    "    if epoch % 5 == 0:\n",
    "        print(f'Epoch: {epoch:3d}. Loss: {loss.item():.4f}. Acc.: {acc:2.2%}')\n",
    "\n",
    "    if acc > best_acc:\n",
    "        trials = 0\n",
    "        best_acc = acc\n",
    "        torch.save(model.state_dict(), 'SmartFall_gru.pth')\n",
    "        print(f'Epoch {epoch} best model saved with accuracy: {best_acc:2.2%}')\n",
    "    else:\n",
    "        trials += 1\n",
    "        if trials >= patience:\n",
    "            print(f'Early stopping on epoch {epoch}')\n",
    "            break\n",
    "print(\"Total Training Time: {} seconds\".format(str(sum(epoch_times))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:54:37.682082Z",
     "start_time": "2020-07-28T10:54:37.564415Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 3))\n",
    "plt.suptitle('GRU Model', fontsize=20, y=1.1)\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(np.arange(len(train_loss)), train_loss)\n",
    "plt.yticks([0.0, 0.1, 0.2], fontsize=15)\n",
    "plt.xticks([0, 20, 40], fontsize=15)\n",
    "plt.title('Loss', fontsize=20)\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(np.arange(len(train_acc)), train_acc)\n",
    "plt.yticks([0.94, 0.97, 1.0], fontsize=15)\n",
    "plt.xticks([0, 20, 40], fontsize=15)\n",
    "plt.title('Accuracy',fontsize=20)\n",
    "plt.subplots_adjust(hspace=1)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:54:37.883189Z",
     "start_time": "2020-07-28T10:54:37.684430Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "93.17475124378109\n",
      "[[3209    7]\n",
      " [ 432 2784]]\n"
     ]
    }
   ],
   "source": [
    "# evaluation with test dataset\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
    "\n",
    "targets = list()\n",
    "preds = list()\n",
    "correct = 0\n",
    "model.load_state_dict(torch.load('SmartFall_gru.pth'))\n",
    "with torch.no_grad():\n",
    "    for X, y in test_loader:\n",
    "        X, y = X.cuda(), y.cuda()\n",
    "        output = model(X.float())\n",
    "        pred = output.max(1, keepdim=True)[1]\n",
    "        correct += pred.eq(y.view_as(pred)).sum().item()\n",
    "\n",
    "        targets += list(y.cpu().numpy())\n",
    "        preds += list(pred.cpu().numpy())\n",
    "\n",
    "test_acc = 100. * correct / len(test_loader.dataset)\n",
    "confusion_mtx = confusion_matrix(targets, preds)\n",
    "print(test_acc)\n",
    "print(confusion_mtx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:54:37.905583Z",
     "start_time": "2020-07-28T10:54:37.884854Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.88      1.00      0.94      3216\n",
      "           1       1.00      0.87      0.93      3216\n",
      "\n",
      "    accuracy                           0.93      6432\n",
      "   macro avg       0.94      0.93      0.93      6432\n",
      "weighted avg       0.94      0.93      0.93      6432\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(targets, preds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:54:37.955037Z",
     "start_time": "2020-07-28T10:54:37.907131Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9974919383733429\n",
      "0.8656716417910447\n",
      "0.9269185949725319\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score, precision_score, recall_score\n",
    "\n",
    "print(precision_score(targets, preds))\n",
    "print(recall_score(targets, preds))\n",
    "print(f1_score(targets, preds))"
   ]
  },
  {
   "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.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}