KDDCup99 DAGMM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Autoencoding Gaussian Mixture Model for Unsupervised Anomaly Detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\VIPLab\\AppData\\Local\\conda\\conda\\envs\\pytorch\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "import pandas as pd\n",
    "import torch\n",
    "from data_loader import *\n",
    "from main import *\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## KDD Cup 1999 Data (10% subset)\n",
    "This is the data set used for The Third International Knowledge Discovery and Data Mining Tools Competition, which was held in conjunction with KDD-99 The Fifth International Conference on Knowledge Discovery and Data Mining. The competition task was to build a network intrusion detector, a predictive model capable of distinguishing between \"bad\" connections, called intrusions or attacks, and \"good\" normal connections. This database contains a standard set of data to be audited, which includes a wide variety of intrusions simulated in a military network environment. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"kddcup.data_10_percent_corrected\", header=None,names=['duration', 'protocol_type', 'service', 'flag', 'src_bytes', 'dst_bytes', 'land', 'wrong_fragment', 'urgent', 'hot', 'num_failed_logins', 'logged_in', 'num_compromised', 'root_shell', 'su_attempted', 'num_root', 'num_file_creations', 'num_shells', 'num_access_files', 'num_outbound_cmds', 'is_host_login', 'is_guest_login', 'count', 'srv_count', 'serror_rate', 'srv_serror_rate', 'rerror_rate', 'srv_rerror_rate', 'same_srv_rate', 'diff_srv_rate', 'srv_diff_host_rate', 'dst_host_count', 'dst_host_srv_count', 'dst_host_same_srv_rate', 'dst_host_diff_srv_rate', 'dst_host_same_src_port_rate', 'dst_host_srv_diff_host_rate', 'dst_host_serror_rate', 'dst_host_srv_serror_rate', 'dst_host_rerror_rate', 'dst_host_srv_rerror_rate', 'type'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pre-processing\n",
    "Following the paper, since the \"normal\" only comprises of approximately 20% of the entries, the \"normal\" data were considered as anomalies instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[data[\"type\"] != \"normal.\", 'type'] = 0\n",
    "data.loc[data[\"type\"] == \"normal.\", 'type'] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, the categorical variables are converted to a one hot encoding representation. My implementation is a bit different from the original paper in this aspect. Since I am only using the 10% subset to generate the columns, I get 118 features instead of 120 as reported in the paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "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>icmp</th>\n",
       "      <th>tcp</th>\n",
       "      <th>udp</th>\n",
       "      <th>IRC</th>\n",
       "      <th>X11</th>\n",
       "      <th>Z39_50</th>\n",
       "      <th>auth</th>\n",
       "      <th>bgp</th>\n",
       "      <th>courier</th>\n",
       "      <th>csnet_ns</th>\n",
       "      <th>...</th>\n",
       "      <th>dst_host_srv_count</th>\n",
       "      <th>dst_host_same_srv_rate</th>\n",
       "      <th>dst_host_diff_srv_rate</th>\n",
       "      <th>dst_host_same_src_port_rate</th>\n",
       "      <th>dst_host_srv_diff_host_rate</th>\n",
       "      <th>dst_host_serror_rate</th>\n",
       "      <th>dst_host_srv_serror_rate</th>\n",
       "      <th>dst_host_rerror_rate</th>\n",
       "      <th>dst_host_srv_rerror_rate</th>\n",
       "      <th>type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>9</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>19</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.05</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>29</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.03</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>39</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.03</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>49</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.02</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 119 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   icmp  tcp  udp  IRC  X11  Z39_50  auth  bgp  courier  csnet_ns  ...   \\\n",
       "0     0    1    0    0    0       0     0    0        0         0  ...    \n",
       "1     0    1    0    0    0       0     0    0        0         0  ...    \n",
       "2     0    1    0    0    0       0     0    0        0         0  ...    \n",
       "3     0    1    0    0    0       0     0    0        0         0  ...    \n",
       "4     0    1    0    0    0       0     0    0        0         0  ...    \n",
       "\n",
       "   dst_host_srv_count  dst_host_same_srv_rate  dst_host_diff_srv_rate  \\\n",
       "0                   9                     1.0                     0.0   \n",
       "1                  19                     1.0                     0.0   \n",
       "2                  29                     1.0                     0.0   \n",
       "3                  39                     1.0                     0.0   \n",
       "4                  49                     1.0                     0.0   \n",
       "\n",
       "   dst_host_same_src_port_rate  dst_host_srv_diff_host_rate  \\\n",
       "0                         0.11                          0.0   \n",
       "1                         0.05                          0.0   \n",
       "2                         0.03                          0.0   \n",
       "3                         0.03                          0.0   \n",
       "4                         0.02                          0.0   \n",
       "\n",
       "   dst_host_serror_rate  dst_host_srv_serror_rate  dst_host_rerror_rate  \\\n",
       "0                   0.0                       0.0                   0.0   \n",
       "1                   0.0                       0.0                   0.0   \n",
       "2                   0.0                       0.0                   0.0   \n",
       "3                   0.0                       0.0                   0.0   \n",
       "4                   0.0                       0.0                   0.0   \n",
       "\n",
       "   dst_host_srv_rerror_rate  type  \n",
       "0                       0.0     1  \n",
       "1                       0.0     1  \n",
       "2                       0.0     1  \n",
       "3                       0.0     1  \n",
       "4                       0.0     1  \n",
       "\n",
       "[5 rows x 119 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_hot_protocol = pd.get_dummies(data[\"protocol_type\"])\n",
    "one_hot_service = pd.get_dummies(data[\"service\"])\n",
    "one_hot_flag = pd.get_dummies(data[\"flag\"])\n",
    "\n",
    "data = data.drop(\"protocol_type\",axis=1)\n",
    "data = data.drop(\"service\",axis=1)\n",
    "data = data.drop(\"flag\",axis=1)\n",
    "    \n",
    "data = pd.concat([one_hot_protocol, one_hot_service,one_hot_flag, data],axis=1)\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    396743\n",
      "1     97278\n",
      "Name: type, dtype: int64\n",
      "Anomaly Percentage 0.19691065764410826\n"
     ]
    }
   ],
   "source": [
    "proportions = data[\"type\"].value_counts()\n",
    "print(proportions)\n",
    "print(\"Anomaly Percentage\",proportions[1] / proportions.sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normalize all the numeric variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "cols_to_norm = [\"duration\", \"src_bytes\", \"dst_bytes\", \"wrong_fragment\", \"urgent\", \n",
    "            \"hot\", \"num_failed_logins\", \"num_compromised\", \"num_root\", \n",
    "            \"num_file_creations\", \"num_shells\", \"num_access_files\", \"count\", \"srv_count\", \n",
    "            \"serror_rate\", \"srv_serror_rate\", \"rerror_rate\", \"srv_rerror_rate\", \"same_srv_rate\", \n",
    "            \"diff_srv_rate\", \"srv_diff_host_rate\", \"dst_host_count\", \"dst_host_srv_count\", \"dst_host_same_srv_rate\", \n",
    "            \"dst_host_diff_srv_rate\", \"dst_host_same_src_port_rate\", \"dst_host_srv_diff_host_rate\", \n",
    "            \"dst_host_serror_rate\", \"dst_host_srv_serror_rate\", \"dst_host_rerror_rate\", \"dst_host_srv_rerror_rate\" ]\n",
    "\n",
    "# data.loc[:, cols_to_norm] = (data[cols_to_norm] - data[cols_to_norm].mean()) / data[cols_to_norm].std()\n",
    "min_cols = data.loc[data[\"type\"]==0 , cols_to_norm].min()\n",
    "max_cols = data.loc[data[\"type\"]==0 , cols_to_norm].max()\n",
    "\n",
    "data.loc[:, cols_to_norm] = (data[cols_to_norm] - min_cols) / (max_cols - min_cols)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I saved the preprocessed data into a numpy file format and load it using the pytorch data loader."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.savez_compressed(\"kdd_cup\",kdd=data.as_matrix())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I initially implemented this to be ran in the command line and use argparse to get the hyperparameters. To make it runnable in a jupyter notebook, I had to create a dummy class for the hyperparameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class hyperparams():\n",
    "    def __init__(self, config):\n",
    "        self.__dict__.update(**config)\n",
    "defaults = {\n",
    "    'lr' : 1e-4,\n",
    "    'num_epochs' : 200,\n",
    "    'batch_size' : 1024,\n",
    "    'gmm_k' : 4,\n",
    "    'lambda_energy' : 0.1,\n",
    "    'lambda_cov_diag' : 0.005,\n",
    "    'pretrained_model' : None,\n",
    "    'mode' : 'train',\n",
    "    'use_tensorboard' : False,\n",
    "    'data_path' : 'kdd_cup.npz',\n",
    "\n",
    "    'log_path' : './dagmm/logs',\n",
    "    'model_save_path' : './dagmm/models',\n",
    "    'sample_path' : './dagmm/samples',\n",
    "    'test_sample_path' : './dagmm/test_samples',\n",
    "    'result_path' : './dagmm/results',\n",
    "\n",
    "    'log_step' : 194//4,\n",
    "    'sample_step' : 194,\n",
    "    'model_save_step' : 194,\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elapsed 0:28:22.371865/0:00:00.131633 -- 0:00:00.131633 , Epoch [200/200], Iter [192/194], lr 0.0001, total_loss: 0.1894, sample_energy: 0.5388, recon_error: 0.0788, cov_diag: 11.3455\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x28bd6a0c160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "phi tensor([ 0.0042,  0.9909,  0.0032,  0.0017], device='cuda:0') mu tensor([[ 0.2632,  1.0881,  0.1980],\n",
      "        [-1.6156,  0.8422, -0.4742],\n",
      "        [-0.1509,  0.9353,  0.1885],\n",
      "        [ 0.2075,  0.8453,  0.2090]], device='cuda:0') cov tensor([[[ 6.7847, -1.0272,  2.1146],\n",
      "         [-1.0272,  2.6332, -0.5521],\n",
      "         [ 2.1146, -0.5521,  0.7540]],\n",
      "\n",
      "        [[ 6.0255, -0.7950,  2.0536],\n",
      "         [-0.7950,  0.2630, -0.2839],\n",
      "         [ 2.0536, -0.2839,  0.7041]],\n",
      "\n",
      "        [[ 7.2182, -0.9259,  1.9753],\n",
      "         [-0.9259,  1.7871, -0.4390],\n",
      "         [ 1.9753, -0.4390,  0.7156]],\n",
      "\n",
      "        [[ 7.2324, -1.0829,  2.2385],\n",
      "         [-1.0829,  1.6545, -0.4776],\n",
      "         [ 2.2385, -0.4776,  0.7902]]], device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 194/194 [00:08<00:00, 23.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "======================TEST MODE======================\n",
      "N: 198371\n",
      "phi :\n",
      " tensor([ 0.0007,  0.9984,  0.0006,  0.0003], device='cuda:0')\n",
      "mu :\n",
      " tensor([[-0.2610,  2.6686, -0.1194],\n",
      "        [-1.4987,  0.8442, -0.4426],\n",
      "        [-1.0019,  1.8008, -0.0609],\n",
      "        [-0.3958,  2.1473, -0.1113]], device='cuda:0')\n",
      "cov :\n",
      " tensor([[[ 4.6235,  0.3735,  1.3941],\n",
      "         [ 0.3735,  5.3684, -0.3503],\n",
      "         [ 1.3941, -0.3503,  0.5130]],\n",
      "\n",
      "        [[ 6.2791, -0.7967,  2.1476],\n",
      "         [-0.7967,  0.3265, -0.2902],\n",
      "         [ 2.1476, -0.2902,  0.7400]],\n",
      "\n",
      "        [[ 5.2532,  0.5667,  1.2209],\n",
      "         [ 0.5667,  3.7280, -0.3171],\n",
      "         [ 1.2209, -0.3171,  0.5404]],\n",
      "\n",
      "        [[ 5.4533,  0.1742,  1.6589],\n",
      "         [ 0.1742,  4.7808, -0.3665],\n",
      "         [ 1.6589, -0.3665,  0.6084]]], device='cuda:0')\n",
      "Threshold : 4.2397990226745605\n",
      "Accuracy : 0.9746, Precision : 0.9683, Recall : 0.9540, F-score : 0.9611\n"
     ]
    }
   ],
   "source": [
    "solver = main(hyperparams(defaults))\n",
    "accuracy, precision, recall, f_score = solver.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### I copy pasted the testing code here in the notebook so we could play around the results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Incrementally compute for the GMM parameters across all training data for a better estimate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N: 198371\n",
      "phi :\n",
      " tensor([ 0.0007,  0.9984,  0.0006,  0.0003], device='cuda:0')\n",
      "mu :\n",
      " tensor([[-0.2610,  2.6686, -0.1194],\n",
      "        [-1.4987,  0.8442, -0.4426],\n",
      "        [-1.0019,  1.8008, -0.0609],\n",
      "        [-0.3958,  2.1473, -0.1113]], device='cuda:0')\n",
      "cov :\n",
      " tensor([[[ 4.6220,  0.3708,  1.3943],\n",
      "         [ 0.3708,  5.3609, -0.3502],\n",
      "         [ 1.3943, -0.3502,  0.5129]],\n",
      "\n",
      "        [[ 6.2786, -0.7967,  2.1474],\n",
      "         [-0.7967,  0.3265, -0.2902],\n",
      "         [ 2.1474, -0.2902,  0.7399]],\n",
      "\n",
      "        [[ 5.2330,  0.5535,  1.2254],\n",
      "         [ 0.5535,  3.7158, -0.3141],\n",
      "         [ 1.2254, -0.3141,  0.5394]],\n",
      "\n",
      "        [[ 5.4512,  0.1713,  1.6592],\n",
      "         [ 0.1713,  4.7742, -0.3663],\n",
      "         [ 1.6592, -0.3663,  0.6083]]], device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "solver.data_loader.dataset.mode=\"train\"\n",
    "solver.dagmm.eval()\n",
    "N = 0\n",
    "mu_sum = 0\n",
    "cov_sum = 0\n",
    "gamma_sum = 0\n",
    "\n",
    "for it, (input_data, labels) in enumerate(solver.data_loader):\n",
    "    input_data = solver.to_var(input_data)\n",
    "    enc, dec, z, gamma = solver.dagmm(input_data)\n",
    "    phi, mu, cov = solver.dagmm.compute_gmm_params(z, gamma)\n",
    "    \n",
    "    batch_gamma_sum = torch.sum(gamma, dim=0)\n",
    "    \n",
    "    gamma_sum += batch_gamma_sum\n",
    "    mu_sum += mu * batch_gamma_sum.unsqueeze(-1) # keep sums of the numerator only\n",
    "    cov_sum += cov * batch_gamma_sum.unsqueeze(-1).unsqueeze(-1) # keep sums of the numerator only\n",
    "    \n",
    "    N += input_data.size(0)\n",
    "    \n",
    "train_phi = gamma_sum / N\n",
    "train_mu = mu_sum / gamma_sum.unsqueeze(-1)\n",
    "train_cov = cov_sum / gamma_sum.unsqueeze(-1).unsqueeze(-1)\n",
    "\n",
    "print(\"N:\",N)\n",
    "print(\"phi :\\n\",train_phi)\n",
    "print(\"mu :\\n\",train_mu)\n",
    "print(\"cov :\\n\",train_cov)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_energy = []\n",
    "train_labels = []\n",
    "train_z = []\n",
    "for it, (input_data, labels) in enumerate(solver.data_loader):\n",
    "    input_data = solver.to_var(input_data)\n",
    "    enc, dec, z, gamma = solver.dagmm(input_data)\n",
    "    sample_energy, cov_diag = solver.dagmm.compute_energy(z, phi=train_phi, mu=train_mu, cov=train_cov, size_average=False)\n",
    "    \n",
    "    train_energy.append(sample_energy.data.cpu().numpy())\n",
    "    train_z.append(z.data.cpu().numpy())\n",
    "    train_labels.append(labels.numpy())\n",
    "\n",
    "\n",
    "train_energy = np.concatenate(train_energy,axis=0)\n",
    "train_z = np.concatenate(train_z,axis=0)\n",
    "train_labels = np.concatenate(train_labels,axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute the energy of every sample in the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "solver.data_loader.dataset.mode=\"test\"\n",
    "test_energy = []\n",
    "test_labels = []\n",
    "test_z = []\n",
    "for it, (input_data, labels) in enumerate(solver.data_loader):\n",
    "    input_data = solver.to_var(input_data)\n",
    "    enc, dec, z, gamma = solver.dagmm(input_data)\n",
    "    sample_energy, cov_diag = solver.dagmm.compute_energy(z, size_average=False)\n",
    "    test_energy.append(sample_energy.data.cpu().numpy())\n",
    "    test_z.append(z.data.cpu().numpy())\n",
    "    test_labels.append(labels.numpy())\n",
    "\n",
    "\n",
    "test_energy = np.concatenate(test_energy,axis=0)\n",
    "test_z = np.concatenate(test_z,axis=0)\n",
    "test_labels = np.concatenate(test_labels,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "combined_energy = np.concatenate([train_energy, test_energy], axis=0)\n",
    "combined_z = np.concatenate([train_z, test_z], axis=0)\n",
    "combined_labels = np.concatenate([train_labels, test_labels], axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute for the threshold energy. Following the paper I just get the highest 20% and treat it as an anomaly. That corresponds to setting the threshold at the 80th percentile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Threshold : 4.774040222167969\n"
     ]
    }
   ],
   "source": [
    "thresh = np.percentile(combined_energy, 100 - 20)\n",
    "print(\"Threshold :\", thresh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = (test_energy>thresh).astype(int)\n",
    "gt = test_labels.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_fscore_support as prf, accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy = accuracy_score(gt,pred)\n",
    "precision, recall, f_score, support = prf(gt, pred, average='binary')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy : 0.9743, Precision : 0.9677, Recall : 0.9538, F-score : 0.9607\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy : {:0.4f}, Precision : {:0.4f}, Recall : {:0.4f}, F-score : {:0.4f}\".format(accuracy,precision, recall, f_score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing the z space\n",
    "It's a little different from the paper's figure but I assume that's because of the small changes in my implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"639.4\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.scatter(test_z[:,1],test_z[:,0], test_z[:,2], c=test_labels.astype(int))\n",
    "ax.set_xlabel('Encoded')\n",
    "ax.set_ylabel('Euclidean')\n",
    "ax.set_zlabel('Cosine')\n",
    "plt.show()"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}