ch_11/2-unsupervised_anomaly_detection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unsupervised anomaly detection\n",
    "After our initial EDA, we have decided to pursue some unsupervised anomaly detection with a feature for the number of usernames with a failed login attempt in a given minute.\n",
    "\n",
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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>source_ip</th>\n",
       "      <th>username</th>\n",
       "      <th>success</th>\n",
       "      <th>failure_reason</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>datetime</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-01-01 00:05:32.988414</th>\n",
       "      <td>223.178.55.3</td>\n",
       "      <td>djones</td>\n",
       "      <td>1</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-01-01 00:08:00.343636</th>\n",
       "      <td>223.178.55.3</td>\n",
       "      <td>djones</td>\n",
       "      <td>0</td>\n",
       "      <td>error_wrong_password</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-01-01 00:08:01.343636</th>\n",
       "      <td>223.178.55.3</td>\n",
       "      <td>djones</td>\n",
       "      <td>1</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-01-01 01:06:59.640823</th>\n",
       "      <td>208.101.11.88</td>\n",
       "      <td>wbrown</td>\n",
       "      <td>1</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-01-01 02:40:47.769630</th>\n",
       "      <td>11.76.99.35</td>\n",
       "      <td>tkim</td>\n",
       "      <td>1</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                source_ip username  success  \\\n",
       "datetime                                                      \n",
       "2018-01-01 00:05:32.988414   223.178.55.3   djones        1   \n",
       "2018-01-01 00:08:00.343636   223.178.55.3   djones        0   \n",
       "2018-01-01 00:08:01.343636   223.178.55.3   djones        1   \n",
       "2018-01-01 01:06:59.640823  208.101.11.88   wbrown        1   \n",
       "2018-01-01 02:40:47.769630    11.76.99.35     tkim        1   \n",
       "\n",
       "                                  failure_reason  \n",
       "datetime                                          \n",
       "2018-01-01 00:05:32.988414                  None  \n",
       "2018-01-01 00:08:00.343636  error_wrong_password  \n",
       "2018-01-01 00:08:01.343636                  None  \n",
       "2018-01-01 01:06:59.640823                  None  \n",
       "2018-01-01 02:40:47.769630                  None  "
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import sqlite3\n",
    "\n",
    "with sqlite3.connect('logs/logs.db') as conn:\n",
    "    logs_2018 = pd.read_sql(\n",
    "        'SELECT * FROM logs WHERE datetime BETWEEN \"2018-01-01\" AND \"2019-01-01\";', \n",
    "        conn, parse_dates=['datetime'], index_col='datetime'\n",
    "    )\n",
    "logs_2018.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepping our data\n",
    "We need a function to transform our log data into our X for the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_X(log, day):\n",
    "    \"\"\"\n",
    "    Get data we can use for the X\n",
    "    \n",
    "    Parameters:\n",
    "        - log: The logs dataframe\n",
    "        - day: A day or single value we can use as a datetime index slice\n",
    "    \n",
    "    Returns: \n",
    "        A `pandas.DataFrame` object\n",
    "    \"\"\"\n",
    "    return pd.get_dummies(log.loc[day].assign(\n",
    "        failures=lambda x: 1 - x.success\n",
    "    ).query('failures > 0').resample('1min').agg(\n",
    "        {'username': 'nunique', 'failures': 'sum'}\n",
    "    ).dropna().rename(\n",
    "        columns={'username': 'usernames_with_failures'}\n",
    "    ).assign(\n",
    "        day_of_week=lambda x: x.index.dayofweek, \n",
    "        hour=lambda x: x.index.hour\n",
    "    ).drop(columns=['failures']), columns=['day_of_week', 'hour'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will work with January 2018:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['usernames_with_failures', 'day_of_week_0', 'day_of_week_1',\n",
       "       'day_of_week_2', 'day_of_week_3', 'day_of_week_4', 'day_of_week_5',\n",
       "       'day_of_week_6', 'hour_0', 'hour_1', 'hour_2', 'hour_3', 'hour_4',\n",
       "       'hour_5', 'hour_6', 'hour_7', 'hour_8', 'hour_9', 'hour_10', 'hour_11',\n",
       "       'hour_12', 'hour_13', 'hour_14', 'hour_15', 'hour_16', 'hour_17',\n",
       "       'hour_18', 'hour_19', 'hour_20', 'hour_21', 'hour_22', 'hour_23'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = get_X(logs_2018, '2018-01')\n",
    "X.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Isolation Forest\n",
    "with estimated 5% contamination:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import IsolationForest\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "iso_forest_pipeline = Pipeline([\n",
    "    ('scale', StandardScaler()),\n",
    "    ('iforest', IsolationForest(\n",
    "        random_state=0, contamination=0.05\n",
    "    ))\n",
    "]).fit(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how many outliers versus inliers we got. Outliers will be marked as -1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inlier     42556\n",
       "outlier     2001\n",
       "dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isolation_forest_preds = iso_forest_pipeline.predict(X)\n",
    "pd.Series(np.where(\n",
    "    isolation_forest_preds == -1, 'outlier', 'inlier'\n",
    ")).value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Local Outlier Factor\n",
    "Since we have no labeled data, we can't use grid search to tune our hyperparameters (we can't calculate performance metrics). Therefore, we will accept the default parameters for LOF, which will use 20 neighbors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import LocalOutlierFactor\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "lof_pipeline = Pipeline([\n",
    "    ('scale', StandardScaler()),\n",
    "    ('lof', LocalOutlierFactor())\n",
    "]).fit(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This model comes up with a negative outlier factor, which doesn't tell us outlier/inlier on its own:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.33898756e+10, -1.00000000e+00, -1.00000000e+00, ...,\n",
       "       -1.00000000e+00, -1.00000000e+00, -1.11582297e+10])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lof_preds = lof_pipeline.named_steps['lof'].negative_outlier_factor_ \n",
    "lof_preds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For that, we need to compare it to the offset. Values less than the offset are outliers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inlier     44248\n",
       "outlier      309\n",
       "dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(np.where(\n",
    "    lof_preds < lof_pipeline.named_steps['lof'].offset_, 'outlier', 'inlier'\n",
    ")).value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check agreement between unsupervised methods\n",
    "While we can't compare their performance without labeled data, we can see if they are generally in agreement (there is a low level of agreement):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25862517997335677"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import cohen_kappa_score\n",
    "\n",
    "is_lof_outlier = np.where(\n",
    "    lof_preds < lof_pipeline.named_steps['lof'].offset_, \n",
    "    'outlier', 'inlier'\n",
    ")\n",
    "is_iso_outlier = np.where(\n",
    "    isolation_forest_preds == -1, 'outlier', 'inlier'\n",
    ")\n",
    "\n",
    "cohen_kappa_score(is_lof_outlier, is_iso_outlier)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluating the models\n",
    "We have been given the labeled data. Now we can truly compare these models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7, 6)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with sqlite3.connect('logs/logs.db') as conn:\n",
    "    hackers_jan_2018 = pd.read_sql(\n",
    "        \"\"\"\n",
    "        SELECT * \n",
    "        FROM attacks \n",
    "        WHERE start BETWEEN \"2018-01-01\" AND \"2018-02-01\";\n",
    "        \"\"\", conn, parse_dates=['start', 'end']\n",
    "    ).assign(\n",
    "        duration=lambda x: x.end - x.start,\n",
    "        start_floor=lambda x: x.start.dt.floor('min'),\n",
    "        end_ceil=lambda x: x.end.dt.ceil('min')\n",
    "    )\n",
    "hackers_jan_2018.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note this only has an IP address for one of the IP addresses involved in each attack, so it's a good thing we aren't relying on that anymore. Also note that, while the attacks are quick in duration, our minutely data means we will trigger many alerts per attack:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>start</th>\n",
       "      <th>end</th>\n",
       "      <th>source_ip</th>\n",
       "      <th>duration</th>\n",
       "      <th>start_floor</th>\n",
       "      <th>end_ceil</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2018-01-02 02:31:43.326264</td>\n",
       "      <td>2018-01-02 02:35:16.326264</td>\n",
       "      <td>102.139.159.128</td>\n",
       "      <td>0 days 00:03:33</td>\n",
       "      <td>2018-01-02 02:31:00</td>\n",
       "      <td>2018-01-02 02:36:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2018-01-02 20:14:02.279476</td>\n",
       "      <td>2018-01-02 20:14:28.279476</td>\n",
       "      <td>119.218.239.234</td>\n",
       "      <td>0 days 00:00:26</td>\n",
       "      <td>2018-01-02 20:14:00</td>\n",
       "      <td>2018-01-02 20:15:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2018-01-03 01:25:48.667114</td>\n",
       "      <td>2018-01-03 01:29:13.667114</td>\n",
       "      <td>151.93.164.203</td>\n",
       "      <td>0 days 00:03:25</td>\n",
       "      <td>2018-01-03 01:25:00</td>\n",
       "      <td>2018-01-03 01:30:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2018-01-08 21:41:43.985324</td>\n",
       "      <td>2018-01-08 21:45:56.985324</td>\n",
       "      <td>226.98.192.152</td>\n",
       "      <td>0 days 00:04:13</td>\n",
       "      <td>2018-01-08 21:41:00</td>\n",
       "      <td>2018-01-08 21:46:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2018-01-11 17:38:30.974748</td>\n",
       "      <td>2018-01-11 17:42:33.974748</td>\n",
       "      <td>23.81.78.129</td>\n",
       "      <td>0 days 00:04:03</td>\n",
       "      <td>2018-01-11 17:38:00</td>\n",
       "      <td>2018-01-11 17:43:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2018-01-12 03:32:20.284167</td>\n",
       "      <td>2018-01-12 03:36:29.284167</td>\n",
       "      <td>74.90.28.4</td>\n",
       "      <td>0 days 00:04:09</td>\n",
       "      <td>2018-01-12 03:32:00</td>\n",
       "      <td>2018-01-12 03:37:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>2018-01-31 07:39:17.514901</td>\n",
       "      <td>2018-01-31 07:43:29.514901</td>\n",
       "      <td>236.174.156.247</td>\n",
       "      <td>0 days 00:04:12</td>\n",
       "      <td>2018-01-31 07:39:00</td>\n",
       "      <td>2018-01-31 07:44:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       start                        end        source_ip  \\\n",
       "0 2018-01-02 02:31:43.326264 2018-01-02 02:35:16.326264  102.139.159.128   \n",
       "1 2018-01-02 20:14:02.279476 2018-01-02 20:14:28.279476  119.218.239.234   \n",
       "2 2018-01-03 01:25:48.667114 2018-01-03 01:29:13.667114   151.93.164.203   \n",
       "3 2018-01-08 21:41:43.985324 2018-01-08 21:45:56.985324   226.98.192.152   \n",
       "4 2018-01-11 17:38:30.974748 2018-01-11 17:42:33.974748     23.81.78.129   \n",
       "5 2018-01-12 03:32:20.284167 2018-01-12 03:36:29.284167       74.90.28.4   \n",
       "6 2018-01-31 07:39:17.514901 2018-01-31 07:43:29.514901  236.174.156.247   \n",
       "\n",
       "         duration         start_floor            end_ceil  \n",
       "0 0 days 00:03:33 2018-01-02 02:31:00 2018-01-02 02:36:00  \n",
       "1 0 days 00:00:26 2018-01-02 20:14:00 2018-01-02 20:15:00  \n",
       "2 0 days 00:03:25 2018-01-03 01:25:00 2018-01-03 01:30:00  \n",
       "3 0 days 00:04:13 2018-01-08 21:41:00 2018-01-08 21:46:00  \n",
       "4 0 days 00:04:03 2018-01-11 17:38:00 2018-01-11 17:43:00  \n",
       "5 0 days 00:04:09 2018-01-12 03:32:00 2018-01-12 03:37:00  \n",
       "6 0 days 00:04:12 2018-01-31 07:39:00 2018-01-31 07:44:00  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hackers_jan_2018"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to mark each minute that had an attack, so we can use the `start_floor` and `end_ceil` columns to create a range of datetimes. Then, we can check if the data we marked as outliers falls within that range:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_y(datetimes, hackers, resolution='1min'):\n",
    "    \"\"\"\n",
    "    Get data we can use for the y (whether or not a hacker attempted a log in during that time).\n",
    "    \n",
    "    Parameters:\n",
    "        - datetimes: The datetimes to check for hackers\n",
    "        - hackers: The dataframe indicating when the attacks started and stopped\n",
    "        - resolution: The granularity of the datetime. Default is 1 minute.\n",
    "        \n",
    "    Returns:\n",
    "        `pandas.Series` of Booleans.\n",
    "    \"\"\"\n",
    "    date_ranges = hackers.apply(\n",
    "        lambda x: pd.date_range(x.start_floor, x.end_ceil, freq=resolution), \n",
    "        axis=1\n",
    "    )\n",
    "    dates = pd.Series(dtype='object')\n",
    "    for date_range in date_ranges:\n",
    "        dates = pd.concat([dates, date_range.to_series()])\n",
    "    return datetimes.isin(dates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's grab our labeled `y` data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "is_hacker = get_y(X.reset_index().datetime, hackers_jan_2018)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will create partials for the performance metrics functions for less typing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "from sklearn.metrics import classification_report\n",
    "from ml_utils.classification import confusion_matrix_visual\n",
    "\n",
    "report = partial(classification_report, is_hacker)\n",
    "conf_matrix = partial(\n",
    "    confusion_matrix_visual, is_hacker, class_labels=[False, True]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Isolation forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "       False       1.00      0.96      0.98     44519\n",
      "        True       0.02      0.82      0.03        38\n",
      "\n",
      "    accuracy                           0.96     44557\n",
      "   macro avg       0.51      0.89      0.50     44557\n",
      "weighted avg       1.00      0.96      0.98     44557\n",
      "\n"
     ]
    }
   ],
   "source": [
    "iso_forest_predicts_hacker = isolation_forest_preds == - 1\n",
    "\n",
    "print(report(iso_forest_predicts_hacker))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Local Outlier Factor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "       False       1.00      0.99      1.00     44519\n",
      "        True       0.03      0.26      0.06        38\n",
      "\n",
      "    accuracy                           0.99     44557\n",
      "   macro avg       0.52      0.63      0.53     44557\n",
      "weighted avg       1.00      0.99      1.00     44557\n",
      "\n"
     ]
    }
   ],
   "source": [
    "lof_predicts_hacker = lof_preds < lof_pipeline.named_steps['lof'].offset_\n",
    "\n",
    "print(report(lof_predicts_hacker))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comparing confusion matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Local Outlier Factor'}, xlabel='Actual', ylabel='Model Prediction'>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(15, 5))\n",
    "conf_matrix(iso_forest_predicts_hacker, ax=axes[0], title='Isolation Forest')\n",
    "conf_matrix(lof_predicts_hacker, ax=axes[1], title='Local Outlier Factor')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div style=\"overflow: hidden; margin-bottom: 10px;\">\n",
    "    <div style=\"float: left;\">\n",
    "        <a href=\"./1-EDA_unlabeled_data.ipynb\">\n",
    "            <button>&#8592; Previous Notebook</button>\n",
    "        </a>\n",
    "    </div>\n",
    "    <div style=\"float: right;\">\n",
    "        <a href=\"./3-EDA_labeled_data.ipynb\">\n",
    "            <button>Next Notebook &#8594;</button>\n",
    "        </a>\n",
    "    </div>\n",
    "</div>\n",
    "<hr>"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}