Sparse_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\luke\\iclouddrive\\documents\\graduate_school\\fall_2018\\ds595\\venv_pc\\lib\\site-packages\\gensim\\utils.py:1212: UserWarning: detected Windows; aliasing chunkize to chunkize_serial\n",
      "  warnings.warn(\"detected Windows; aliasing chunkize to chunkize_serial\")\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "import string\n",
    "import warnings\n",
    "import gensim \n",
    "import h5py\n",
    "import copy\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import log_loss\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from sklearn.preprocessing import normalize\n",
    "\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n",
    "\n",
    "warnings.filterwarnings(action='ignore') \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'CNN': [0.66, 0.718, 0.57], 'PCA_100+XGBoost': [0.693, 0.75, 0.565], 'PCA_50+XGBoost': [0.689, 0.748, 0.565], 'baseline': [0.6943434343434344, 0.7266907065355863, 0.6193564762837815], 'XGBoost_full100': [0.6811111111111111, 0.7329586892768103, 0.9340985078718101], 'XGBoost_full75': [0.684949494949495, 0.734875896713156, 0.9153928981275047], 'XGBoost_full50': [0.6796969696969697, 0.7239762621337456, 0.89394626000627], 'XGBoost_full25': [0.6652525252525252, 0.7003312234871989, 0.8458255921430086], 'XGBoost_full15': [0.6563636363636364, 0.680431395610271, 0.800789537622404], 'XGBoost_full10': [0.6392929292929292, 0.6627128078952527, 0.7652747155022656], 'XGBoost_full9': [0.6360606060606061, 0.647727572689595, 0.7549728959307147], 'XGBoost_full8': [0.6418181818181818, 0.6595427901014278, 0.7427937270292017], 'XGBoost_full7': [0.6421212121212121, 0.660091871881123, 0.743484776909628], 'XGBoost_full6': [0.6285858585858586, 0.6170971192872315, 0.7546221636612626], 'XGBoost_full5': [0.6277777777777778, 0.631068519775399, 0.7225775063675806], 'XGBoost_full4': [0.6156565656565657, 0.6143192525688783, 0.7258691284403056], 'XGBoost_full3': [0.5996969696969697, 0.5666977673192446, 0.7403499154821842], 'XGBoost_full2': [0.6084848484848485, 0.5904007600839616, 0.7070951692816796], 'XGBoost_full1': [0.5719191919191919, 0.5090319922983171, 0.7310596280401725]}\n"
     ]
    }
   ],
   "source": [
    "# Parameterize this ish\n",
    "# Length of vector for each word\n",
    "max_word2vec_components = 256\n",
    "# Length of subset to consider\n",
    "sample_size = 30000\n",
    "# Threshold for sparsifying. Values less than this will be set to 0 in similarity matrix\n",
    "threshold = 0.3\n",
    "# Window size for subsampling sparse similarity matrix\n",
    "window_size = 20\n",
    "# Compression size\n",
    "comp_size = 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the data\n",
    "train_data = pd.read_csv(\"./Data/train.csv\")\n",
    "test_data_ = pd.read_csv(\"./Data/test.csv\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrieve a list of the questions in the training set\n",
    "train_question1s = train_data[\"question1\"].astype(str).tolist()\n",
    "train_question2s = train_data[\"question2\"].astype(str).tolist()\n",
    "\n",
    "# Combine the two for vectorization and dimension reduction\n",
    "train_questions = train_question1s + train_question2s\n",
    "\n",
    "translator = str.maketrans('', '', string.punctuation)\n",
    "data = []\n",
    "\n",
    "# Make each question a list of cleaned words\n",
    "for q in train_questions:\n",
    "    # Remove punctuation\n",
    "    q = q.translate(translator)\n",
    "    # Make everything lowercase\n",
    "    q = q.lower()\n",
    "    # Append it back to the list\n",
    "    data.append(q.split(\" \"))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150383994, 1916334600)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Declare and train the Word2Vec model\n",
    "# Note: Min_count is the minimum number of times a word needs to appear for the model to consider it.\n",
    "#       If this is changed from 1, what we are doing will not work.\n",
    "model = gensim.models.Word2Vec(data, size=max_word2vec_components, window=10, min_count=1, workers=25)\n",
    "model.train(data, total_examples=len(data), epochs=10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the Word2Vec model\n",
    "with open(\"./word2vec_model.p\", \"wb\") as f:\n",
    "    pickle.dump(model, f)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reload the Word2Vec model\n",
    "with open(\"./word2vec_model.p\", \"rb\") as f:\n",
    "    model = pickle.load(f)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "5\n",
      "14\n",
      "211\n",
      "241\n",
      "320\n",
      "1077\n",
      "1614\n",
      "20875\n",
      "33209\n",
      "35101\n",
      "408616\n",
      "422345\n",
      "422345\n"
     ]
    }
   ],
   "source": [
    "# Find the max number of words in all questions \n",
    "data = data\n",
    "\n",
    "_max = 0\n",
    "idx = 0\n",
    "i = 0\n",
    "for q in data:\n",
    "    if len(q) > _max:\n",
    "        idx = i\n",
    "        _max = len(q)\n",
    "    i += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pad every question to be the same length\n",
    "for q in data:\n",
    "    if len(q) < _max:\n",
    "        q += ([''] * (_max - len(q)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separate the \"tokenized\" questions into original two lists\n",
    "q1_data = data[:len(train_question1s)]\n",
    "q2_data = data[len(train_question2s):]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute the similarity scores between each vectorized question \n",
    "similarity_scores = []\n",
    "\n",
    "for i in range(len(q1_data)):\n",
    "    pairwise_similarity = []\n",
    "    \n",
    "    for j in range(_max):\n",
    "        \n",
    "        q1_word = model[q1_data[i][j]].reshape((1, max_word2vec_components))\n",
    "        q2_sent = model[q2_data[i]]\n",
    "        \n",
    "        c_sim = cosine_similarity(q1_word, q2_sent, dense_output=False)\n",
    "        pairwise_similarity.append(c_sim.tolist())\n",
    "\n",
    "    similarity_scores.append(pairwise_similarity)\n",
    "\n",
    "similarity_scores = np.array(similarity_scores)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Save the similarity scores\n",
    "with h5py.File('similarity_scores.h5', 'w') as hf:\n",
    "    hf.create_dataset(\"similarity-scores\",  data=similarity_scores)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load in the similarity scores. This can be skipped if you are running the whole way though\n",
    "with h5py.File('similarity_scores.h5', 'r') as hf:\n",
    "    similarity_scores = hf['similarity-scores'][:]\n",
    "\n",
    "# Show a random image to demonstrate sparsity and where the actual data lives\n",
    "sample_image = similarity_scores[np.random.randint(0, sample_size-1)]\n",
    "plt.imshow(sample_image)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declare dictionary to hold results\n",
    "model_results = {}\n",
    "\n",
    "model_results['CNN'] = [0.660, 0.718, 0.570]\n",
    "model_results['PCA_100+XGBoost'] = [0.693, 0.750, 0.565]\n",
    "model_results['PCA_50+XGBoost'] = [0.689, 0.748, 0.565]\n",
    "model_results['baseline'] = [baseline_acc, baseline_roc_auc, baseline_log_loss]\n",
    "\n",
    "print(model_results)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(30000, 56169)\n"
     ]
    }
   ],
   "source": [
    "# Prepare the data to compute a baseline score\n",
    "similarity_scores = similarity_scores.reshape((sample_size, 237*237))\n",
    "\n",
    "X_train_baseline, X_test_baseline, y_train_baseline, y_test_baseline = train_test_split(similarity_scores, train_data.loc[:sample_size-1]['is_duplicate'], test_size=0.33, random_state=42)\n",
    "\n",
    "similarity_scores = similarity_scores.reshape((sample_size, 237, 237))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingClassifier(criterion='friedman_mse', init=None,\n",
       "              learning_rate=0.1, loss='deviance', max_depth=10,\n",
       "              max_features='log2', max_leaf_nodes=None,\n",
       "              min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "              min_samples_leaf=1, min_samples_split=2,\n",
       "              min_weight_fraction_leaf=0.0, n_estimators=500,\n",
       "              n_iter_no_change=None, presort='auto', random_state=None,\n",
       "              subsample=1.0, tol=0.0001, validation_fraction=0.1,\n",
       "              verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "baseline_model = GradientBoostingClassifier(n_estimators=500, max_features='log2', max_depth=10)\n",
    "baseline_model.fit(X_train_baseline, y_train_baseline)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_hat_baseline = baseline_model.predict(X_test_baseline)\n",
    "y_hat_proba_baseline = baseline_model.predict_proba(X_test_baseline)\n",
    "\n",
    "baseline_acc = accuracy_score(y_test_baseline, y_hat_baseline)\n",
    "baseline_roc_auc = roc_auc_score(y_test_baseline, y_hat_proba_baseline[:, 1])\n",
    "baseline_log_loss = log_loss(y_test_baseline, y_hat_proba_baseline[:, 1])\n",
    "\n",
    "print(baseline_acc)\n",
    "print(baseline_roc_auc)\n",
    "print(baseline_log_loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Copy the similarity scores to a preserve the original data\n",
    "#    This allows us to play with how sparse we want to make the results\n",
    "sparse_results = copy.copy(similarity_scores)\n",
    "sparse_results[sparse_results < threshold] = 0.0\n",
    "\n",
    "sparse_results = sparse_results.reshape((sample_size, 237, 237))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(30000, 2)\n"
     ]
    }
   ],
   "source": [
    "# Since the majority of our data lives in the upper-left quadrant\n",
    "#    Let's readjust the size to speed things up\n",
    "sub_sparse = sparse_results[:, :window_size, :window_size]\n",
    "\n",
    "# Make a random matrix to compress our data\n",
    "A = np.random.normal(loc=0, scale=1, size=(comp_size, window_size*window_size))\n",
    "\n",
    "comp_sub_sparse_data = []\n",
    "\n",
    "for i in range(sub_sparse.shape[0]):\n",
    "    # Bang every entry in our sub-sampled sparse dataset into this vector\n",
    "    comp_vec = np.matmul(A, sub_sparse[i].reshape(window_size*window_size, 1))\n",
    "    comp_sub_sparse_data.append(comp_vec)\n",
    "    \n",
    "# Convert this new data into a numpy array for convenience \n",
    "comp_sub_sparse_data = np.array(comp_sub_sparse_data)\n",
    "comp_sub_sparse_data = comp_sub_sparse_data.reshape((comp_sub_sparse_data.shape[0], comp_sub_sparse_data.shape[1]))\n",
    "print(comp_sub_sparse_data.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Because we only used the first 30,000 questions get their labels\n",
    "labels = train_data.loc[:sample_size-1]['is_duplicate']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(comp_sub_sparse_data, labels, test_size=0.33, random_state=42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingClassifier(criterion='friedman_mse', init=None,\n",
       "              learning_rate=0.1, loss='deviance', max_depth=10,\n",
       "              max_features='log2', max_leaf_nodes=None,\n",
       "              min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "              min_samples_leaf=1, min_samples_split=2,\n",
       "              min_weight_fraction_leaf=0.0, n_estimators=500,\n",
       "              n_iter_no_change=None, presort='auto', random_state=None,\n",
       "              subsample=1.0, tol=0.0001, validation_fraction=0.1,\n",
       "              verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Build a generic XGBoost classifier\n",
    "xgb_classifier_full = GradientBoostingClassifier(n_estimators=500, max_features='log2', max_depth=10)\n",
    "xgb_classifier_full.fit(X_train, y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5719191919191919\n",
      "0.5090319922983171\n",
      "0.7310596280401725\n"
     ]
    }
   ],
   "source": [
    "# Score it and save the results\n",
    "y_hat_proba_xgb = xgb_classifier_full.predict_proba(X_test)\n",
    "y_hat_xgb = xgb_classifier_full.predict(X_test)\n",
    "\n",
    "xgb_acc = accuracy_score(y_test, y_hat_xgb)\n",
    "xgb_roc_auc = roc_auc_score(y_test, y_hat_proba_xgb[:, 1])\n",
    "xgb_log_loss = log_loss(y_test, y_hat_proba_xgb[:, 1])\n",
    "\n",
    "model_results[('XGBoost_full' + str(comp_size))] = [xgb_acc, xgb_roc_auc, xgb_log_loss]\n",
    "\n",
    "print(xgb_acc)\n",
    "print(xgb_roc_auc)\n",
    "print(xgb_log_loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "            max_depth=10, max_features='sqrt', max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, n_estimators=500, n_jobs=-1,\n",
       "            oob_score=False, random_state=None, verbose=0,\n",
       "            warm_start=False)"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Build a generic Random Forest Classifier\n",
    "rf_classifier_full = RandomForestClassifier(n_estimators=500, max_depth=10, max_features='sqrt', n_jobs=-1)\n",
    "rf_classifier_full.fit(X_train, y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6731313131313131\n",
      "0.7398514521097166\n",
      "11.289708777119738\n"
     ]
    }
   ],
   "source": [
    "# Score it and save the results\n",
    "y_hat_proba_rf = rf_classifier_full.predict_proba(X_test)\n",
    "y_hat_rf = rf_classifier_full.predict(X_test)\n",
    "\n",
    "rf_acc = accuracy_score(y_test, y_hat_rf)\n",
    "rf_roc_auc = roc_auc_score(y_test, y_hat_proba_rf[:, 1])\n",
    "rf_log_loss = log_loss(y_test, y_hat_proba_rf[:, 1])\n",
    "\n",
    "model_results['RandomForest_full'] = [rf_acc, rf_roc_auc, rf_log_loss]\n",
    "\n",
    "print(rf_acc)\n",
    "print(rf_roc_auc)\n",
    "print(rf_log_loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "QuadraticDiscriminantAnalysis(priors=None, reg_param=0.0,\n",
       "               store_covariance=False, store_covariances=None, tol=0.0001)"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Build a generic QDA model\n",
    "qda_classifier_full = QuadraticDiscriminantAnalysis()\n",
    "qda_classifier_full.fit(X_train, y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5667676767676768\n",
      "0.6845759605439403\n",
      "14.963593552130112\n"
     ]
    }
   ],
   "source": [
    "# Score it and save the results\n",
    "y_hat_proba_qda = qda_classifier_full.predict_proba(X_test)\n",
    "y_hat_qda = qda_classifier_full.predict(X_test)\n",
    "\n",
    "qda_acc = accuracy_score(y_test, y_hat_qda)\n",
    "qda_roc_auc = roc_auc_score(y_test, y_hat_proba_qda[:, 1])\n",
    "qda_log_loss = log_loss(y_test, y_hat_proba_qda[:, 1])\n",
    "\n",
    "model_results['QDA_full'] = [qda_acc, qda_roc_auc, qda_log_loss]\n",
    "\n",
    "print(qda_acc)\n",
    "print(qda_roc_auc)\n",
    "print(qda_log_loss)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With L2 Normalization\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's try with some normalized data\n",
    "# Normalize the Data with L2\n",
    "X_train_l2 = normalize(X_train, norm='l2')\n",
    "X_test_l2 = normalize(X_test, norm='l2')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingClassifier(criterion='friedman_mse', init=None,\n",
       "              learning_rate=0.1, loss='deviance', max_depth=10,\n",
       "              max_features='log2', max_leaf_nodes=None,\n",
       "              min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "              min_samples_leaf=1, min_samples_split=2,\n",
       "              min_weight_fraction_leaf=0.0, n_estimators=500,\n",
       "              n_iter_no_change=None, presort='auto', random_state=None,\n",
       "              subsample=1.0, tol=0.0001, validation_fraction=0.1,\n",
       "              verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's try the same XGBoost model from above with the L2-normed data\n",
    "xgb_classifier_l2 = GradientBoostingClassifier(n_estimators=500, max_features='log2', max_depth=10)\n",
    "xgb_classifier_l2.fit(X_train_l2, y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6864646464646464\n",
      "0.7444946332817566\n",
      "10.82920548898185\n"
     ]
    }
   ],
   "source": [
    "# Score it and save the results\n",
    "y_hat_proba_xgb_l2 = xgb_classifier_l2.predict_proba(X_test_l2)\n",
    "y_hat_xgb_l2 = xgb_classifier_l2.predict(X_test_l2)\n",
    "\n",
    "xgb_acc_l2 = accuracy_score(y_test, y_hat_xgb_l2)\n",
    "xgb_roc_auc_l2 = roc_auc_score(y_test, y_hat_proba_xgb_l2[:, 1])\n",
    "xgb_log_loss_l2 = log_loss(y_test, y_hat_proba_xgb_l2[:, 1])\n",
    "\n",
    "model_results['XGBoost_l2'] = [xgb_acc_l2, xgb_roc_auc_l2, xgb_log_loss_l2]\n",
    "\n",
    "print(xgb_acc_l2)\n",
    "print(xgb_roc_auc_l2)\n",
    "print(xgb_log_loss_l2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normalize the Data with L1\n",
    "X_train_l1 = normalize(X_train, norm='l1')\n",
    "X_test_l1 = normalize(X_test, norm='l1')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingClassifier(criterion='friedman_mse', init=None,\n",
       "              learning_rate=0.1, loss='deviance', max_depth=10,\n",
       "              max_features='log2', max_leaf_nodes=None,\n",
       "              min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "              min_samples_leaf=1, min_samples_split=2,\n",
       "              min_weight_fraction_leaf=0.0, n_estimators=500,\n",
       "              n_iter_no_change=None, presort='auto', random_state=None,\n",
       "              subsample=1.0, tol=0.0001, validation_fraction=0.1,\n",
       "              verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's try the same XGBoost model from above with the L1-normed data\n",
    "xgb_classifier_l1 = GradientBoostingClassifier(n_estimators=500, max_features='log2', max_depth=10)\n",
    "xgb_classifier_l1.fit(X_train_l1, y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6846464646464646\n",
      "0.7383700754536705\n",
      "10.892004314221747\n"
     ]
    }
   ],
   "source": [
    "# Score it and save the results\n",
    "y_hat_proba_xgb_l1 = xgb_classifier_l1.predict_proba(X_test_l1)\n",
    "y_hat_xgb_l1 = xgb_classifier_l1.predict(X_test_l1)\n",
    "\n",
    "xgb_acc_l1 = accuracy_score(y_test, y_hat_xgb_l1)\n",
    "xgb_roc_auc_l1 = roc_auc_score(y_test, y_hat_proba_xgb_l1[:, 1])\n",
    "xgb_log_loss_l1 = log_loss(y_test, y_hat_proba_xgb_l1[:, 1])\n",
    "\n",
    "model_results['XGBoost_l1'] = [xgb_acc_l1, xgb_roc_auc_l1, xgb_log_loss_l1]\n",
    "\n",
    "print(xgb_acc_l1)\n",
    "print(xgb_roc_auc_l1)\n",
    "print(xgb_log_loss_l1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normalize the Data with MAX\n",
    "X_train_max = normalize(X_train, norm='max')\n",
    "X_test_max = normalize(X_test, norm='max')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingClassifier(criterion='friedman_mse', init=None,\n",
       "              learning_rate=0.1, loss='deviance', max_depth=10,\n",
       "              max_features='log2', max_leaf_nodes=None,\n",
       "              min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "              min_samples_leaf=1, min_samples_split=2,\n",
       "              min_weight_fraction_leaf=0.0, n_estimators=500,\n",
       "              n_iter_no_change=None, presort='auto', random_state=None,\n",
       "              subsample=1.0, tol=0.0001, validation_fraction=0.1,\n",
       "              verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's try the same XGBoost model from above with the MAX-normed data\n",
    "xgb_classifier_max = GradientBoostingClassifier(n_estimators=500, max_features='log2', max_depth=10)\n",
    "xgb_classifier_max.fit(X_train_max, y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Score it and save the results\n",
    "y_hat_proba_xgb_max = xgb_classifier_max.predict_proba(X_test_max)\n",
    "y_hat_xgb_max = xgb_classifier_max.predict(X_test_max)\n",
    "\n",
    "xgb_acc_max = accuracy_score(y_test, y_hat_xgb_max)\n",
    "xgb_roc_auc_max = roc_auc_score(y_test, y_hat_proba_xgb_max[:, 1])\n",
    "xgb_log_loss_max = log_loss(y_test, y_hat_proba_xgb_max[:, 1])\n",
    "\n",
    "model_results['XGBoost_max'] = [xgb_acc_max, xgb_roc_auc_max, xgb_log_loss_max]\n",
    "\n",
    "print(xgb_acc_max)\n",
    "print(xgb_roc_auc_max)\n",
    "print(xgb_log_loss_max)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "# Plot the decomposition of random compression\n",
    "comp_dims = []\n",
    "comp_accs = []\n",
    "comp_aucs = []\n",
    "comp_llss = []\n",
    "\n",
    "for k in model_results.keys():\n",
    "    if \"XGBoost_full\" in k:\n",
    "        comp_dims.append(int(k.split('ll')[1]))\n",
    "        comp_accs.append(model_results[k][0])\n",
    "        comp_aucs.append(model_results[k][1])\n",
    "        comp_llss.append(model_results[k][2])\n",
    "\n",
    "plt.plot(comp_dims, comp_accs)\n",
    "plt.title(\"Compression Accuracy Decomposition\")\n",
    "plt.xlabel(\"Dimension\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.savefig('./CompressionAccuracies.png', dpi=700)\n",
    "plt.show()\n",
    "plt.close()\n",
    "\n",
    "plt.plot(comp_dims, comp_aucs)\n",
    "plt.title(\"Compression AUC ROC Decomposition\")\n",
    "plt.xlabel(\"Dimension\")\n",
    "plt.ylabel(\"AUC ROC\")\n",
    "plt.savefig('./CompressionAUCs.png', dpi=700)\n",
    "plt.show()\n",
    "plt.close()\n",
    "\n",
    "plt.plot(comp_dims, comp_llss)\n",
    "plt.title(\"Compression Log-Loss Decomposition\")\n",
    "plt.xlabel(\"Dimension\")\n",
    "plt.ylabel(\"Log-Loss\")\n",
    "plt.savefig('./CompressionLLS.png', dpi=700)\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x2011671fda0>"
      ]
     },
     "execution_count": 119,
     "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": [
    "# Plot the data when compressed to 2 dimensions\n",
    "plt.scatter(comp_sub_sparse_data[:, 0], comp_sub_sparse_data[:, 1], c=labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrieve the metrics from the dictionary\n",
    "accs = []\n",
    "aucs = []\n",
    "llss = []\n",
    "\n",
    "for mod in model_results.keys():\n",
    "    accs.append(model_results[mod][0])\n",
    "    aucs.append(model_results[mod][1])\n",
    "    llss.append(model_results[mod][2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the accuracies\n",
    "plt.bar(model_results.keys(), accs)\n",
    "plt.xticks(rotation=45)\n",
    "plt.tight_layout()\n",
    "plt.savefig('./Accuracies.png', dpi=700)\n",
    "plt.show()\n",
    "plt.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the AUC-ROC's\n",
    "plt.bar(model_results.keys(), aucs)\n",
    "plt.xticks(rotation=45)\n",
    "plt.tight_layout()\n",
    "plt.savefig('./ROC_AUC.png', dpi=700)\n",
    "plt.show()\n",
    "plt.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the Log-loss since the Kaggle competition used it.\n",
    "plt.bar(model_results.keys(), llss)\n",
    "plt.xticks(rotation=45)\n",
    "plt.tight_layout()\n",
    "plt.savefig('./Log_Loss.png', dpi=700)\n",
    "plt.show()\n",
    "plt.close()\n"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}