Session 4 - Instance and Inductive Models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Instance and Inductive Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Classification Pipeline](figures/classification_pipeline.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline \n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd \n",
    "import seaborn as sns \n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "sns.set_context('notebook')\n",
    "sns.set_style('whitegrid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classification Metrics I"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Classification Metrics](figures/classification_metrics.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Binary Classification\n",
    "\n",
    "\n",
    "How well did predicted values match actual labeled values?\n",
    "\n",
    "In a 2-class problem, there are two ways to be “right”:\n",
    " - Classifier correctly identifies cases (aka “True Positives”)\n",
    " - Classifier correctly identifies non-cases (aka “True Negatives”)\n",
    "\n",
    "...and two ways to be “wrong”:\n",
    " - Classifier incorrectly identifies a non-case as a case (aka “False Positive” or “Type I Error”)\n",
    " - Classifier incorrectly identifies a case as a non-case (aka “False Negative” or “Type II Error”)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Multi-Class Classification\n",
    "\n",
    "\n",
    " - How correct were predictions on a per-class basis? How correct overall?\n",
    "\n",
    " - Are certain classes harder to predict?\n",
    "\n",
    " - Do we care more about accurately predicting some classes than others?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Precision and Recall\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "precision = true positives / (true positives + false positives)\n",
    "\n",
    "recall = true positives / (false negatives + true positives)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Precision and Recall](figures/precision_recall.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### F1 and Accuracy\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "accuracy = true positives + true negatives / total\n",
    "\n",
    "F1 score = 2 * ((precision * recall) / (precision + recall))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### ROC-AUC Curves\n",
    "\n",
    "A ROCAUC (Receiver Operating Characteristic/Area Under the Curve) allows the user to weigh the tradeoff between the classifier’s sensitivity and specificity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The Receiver Operating Characteristic (ROC) is a measure of a classifier’s predictive quality that compares and visualizes the tradeoff between the model’s sensitivity and specificity. When plotted, a ROC curve displays the true positive rate on the Y axis and the false positive rate on the X axis on both a global average and per-class basis. The ideal point is therefore the top-left corner of the plot: false positives are zero and true positives are one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This leads to another metric, area under the curve (AUC), which is a computation of the relationship between false positives and true positives. The higher the AUC, the better the model generally is. However, it is also important to inspect the “steepness” of the curve, as this describes the maximization of the true positive rate while minimizing the false positive rate."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "```python\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "\n",
    "fpr, tpr, thresholds = roc_curve(y,yhat)\n",
    "roc_auc = auc(fpr, tpr)```\n",
    "\n",
    "\n",
    "Visualize tradeoff between classifier's sensitivity (how well it finds true positives) and specificity (how well it avoids false positives)\n",
    " - straight horizontal line -> perfect classifier\n",
    " - pulling a lot toward the upper left corner -> good accuracy\n",
    " - exactly aligned with the diagonal -> coin toss\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:11: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  # This is added back by InteractiveShellApp.init_path()\n",
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:12: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  if sys.path[0] == '':\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "data = pd.read_csv('data/occupancy/occupancy.csv')\n",
    "\n",
    "\n",
    "# Specify the features of interest and the classes of the target\n",
    "features = [\"temperature\", \"relative humidity\", \"light\", \"C02\", \"humidity\"]\n",
    "classes = [\"unoccupied\", \"occupied\"]\n",
    "\n",
    "# Extract the numpy arrays from the data frame\n",
    "X = data[features].as_matrix()\n",
    "y = data.occupancy.as_matrix()\n",
    "\n",
    "# Create the train and test data\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from yellowbrick.classifier import ROCAUC\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "# Instantiate the visualizer with the classification model\n",
    "visualizer = ROCAUC(LogisticRegression(), classes=classes)\n",
    "\n",
    "visualizer.fit(X_train, y_train)  # Fit the training data to the visualizer\n",
    "visualizer.score(X_test, y_test)  # Evaluate the model on the test data\n",
    "g = visualizer.poof()             # Draw/show/poof the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "ROC curves are typically used in binary classification, and in fact the Scikit-Learn `roc_curve` metric is only able to perform metrics for binary classifiers. \n",
    "\n",
    "Yellowbrick’s `ROCAUC` Visualizer does allow for plotting multiclass classification curves by binarizing the output (per-class) or to use one-vs-rest (micro score) or one-vs-all (macro score) strategies of classification.\n",
    "\n",
    "\n",
    "(_note: not in master yet, but here's a preview_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# Load multi-class classification dataset\n",
    "game = pd.read_csv('data/game/game.csv')\n",
    "\n",
    "classes = [\"win\", \"loss\", \"draw\"]\n",
    "\n",
    "# Encode the non-numeric columns\n",
    "game.replace({'loss':-1, 'draw':0, 'win':1, 'x':2, 'o':3, 'b':4}, inplace=True)\n",
    "\n",
    "# Extract the numpy arrays from the data frame\n",
    "X = game.iloc[:, game.columns != 'outcome']\n",
    "y = game['outcome']\n",
    "\n",
    "# Create the train and test data\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python\n",
    "from sklearn.linear_model import RidgeClassifier\n",
    "\n",
    "visualizer = ROCAUC(RidgeClassifier(), classes=classes)\n",
    "\n",
    "visualizer.fit(X_train, y_train)  # Fit the training data to the visualizer\n",
    "visualizer.score(X_test, y_test)  # Evaluate the model on the test data\n",
    "g = visualizer.poof()             # Draw/show/poof the data\n",
    "```\n",
    "\n",
    "![Multi-class ROCAUC](figures/multi_class_rocauc.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Confusion Matrix\n",
    "\n",
    "\n",
    "```python\n",
    "from sklearn.metrics import confusion_matrix\n",
    "```\n",
    "\n",
    " - takes as an argument actual values and predicted values generated by the fitted model\n",
    " - outputs a confusion matrix\n",
    "\n",
    "![Confusion Matrix](figures/confusion_matrix.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The ConfusionMatrix visualizer is a ScoreVisualizer that takes a fitted scikit-learn classifier and a set of test X and y values and returns a report showing how each of the test values predicted classes compare to their actual classes. Data scientists use confusion matrices to understand which classes are most easily confused. These provide similar information as what is available in a ClassificationReport, but rather than top-level scores, they provide deeper insight into the classification of individual data points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "\n",
    "game = pd.read_csv('data/game/game.csv')\n",
    "\n",
    "game.replace({'loss':-1, 'draw':0, 'win':1, 'x':2, 'o':3, 'b':4}, inplace=True)\n",
    "\n",
    "X = game.iloc[:, game.columns != 'outcome']\n",
    "y = game['outcome']\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size =0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from yellowbrick.classifier import ConfusionMatrix\n",
    "\n",
    "\n",
    "model = LogisticRegression()\n",
    "\n",
    "cm = ConfusionMatrix(model)\n",
    "cm.fit(X_train, y_train)\n",
    "cm.score(X_test, y_test)\n",
    "cm.poof()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Classification Report\n",
    "\n",
    "The classification report visualizer displays the precision, recall, F1, and support scores for the model. In order to support easier interpretation and problem detection, the report integrates numerical scores with a color-coded heatmap. All heatmaps are in the range `(0.0, 1.0)` to facilitate easy comparison of classification models across different classification reports.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "```python\n",
    "from sklearn.metrics import classification_report as cr\n",
    "\n",
    "print(cr(y, yhat, target_names=target_names))\n",
    "```\n",
    "\n",
    "\n",
    " - includes same basic info as confusion matrix\n",
    " - 3 different evaluation metrics: precision, recall, F1 score\n",
    " - includes class labels for interpretability\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:9: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  if __name__ == '__main__':\n",
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:10: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  # Remove the CWD from sys.path while we load stuff.\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv('data/occupancy/occupancy.csv')\n",
    "\n",
    "\n",
    "# Specify the features of interest and the classes of the target\n",
    "features = [\"temperature\", \"relative humidity\", \"light\", \"C02\", \"humidity\"]\n",
    "classes = [\"unoccupied\", \"occupied\"]\n",
    "\n",
    "# Extract the numpy arrays from the data frame\n",
    "X = data[features].as_matrix()\n",
    "y = data.occupancy.as_matrix()\n",
    "\n",
    "# Create the train and test data\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.naive_bayes import GaussianNB\n",
    "from yellowbrick.classifier import ClassificationReport\n",
    "\n",
    "\n",
    "bayes = GaussianNB()\n",
    "visualizer = ClassificationReport(bayes, classes=classes, support=True)\n",
    "\n",
    "visualizer.fit(X_train, y_train)\n",
    "visualizer.score(X_test, y_test)  \n",
    "g = visualizer.poof() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Nearest Neighbors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Find a predefined (k) samples closest in distance to the input point and predict the label from those. \n",
    "\n",
    "Distance == similarity in this case, and can be any metric measure. Euclidean distance is most common.\n",
    "\n",
    "Non-generalizing: must “remember” all training data.\n",
    "\n",
    "![k-Nearest Neighbors](figures/knn.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In Scikit-Learn the neighbors package provides both supervised and unsupervised nearest neighbors methods - these are simple and effective!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Unsupervised Nearest Neighbors\n",
    "\n",
    "![k-Nearest Neighbors](figures/knn_houses_1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12.20655562, 42.05948169],\n",
       "       [10.77032961, 32.80243893],\n",
       "       [12.04159458, 44.77722635],\n",
       "       [28.28427125, 14.14213562],\n",
       "       [35.35533906,  7.07106781],\n",
       "       [46.69047012, 41.23105626]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics.pairwise import euclidean_distances\n",
    "\n",
    "X = [[3,20],[20,14],[18,1],[30,30],[35,35],[56,2]]\n",
    "y = [[10,10],[40,40]]\n",
    "\n",
    "euclidean_distances(X,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![k-Nearest Neighbors](figures/knn_houses_2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Pros and Cons of KNN\n",
    "\n",
    "#### Pros \n",
    "\n",
    " - Works well with distance-sensitive data\n",
    " - Simple and effective for a wide array of tasks\n",
    " - Non parametric - works well with irregular decision boundaries.\n",
    " - Often a first approach\n",
    " - No worse than 2x Bayes error rate as data → ∞\n",
    "\n",
    "#### Cons\n",
    "\n",
    " - kNN can be very arbitrary and requires hand-holding to model.\n",
    " - How do you choose k?\n",
    " - What is the definition of neighbor/similarity?\n",
    " - Suffers from the curse of dimensionality.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Choosing K\n",
    "\n",
    "K is an arbitrary number between 1 and the number of instances in the data set. Three options for choosing:\n",
    "\n",
    "1. Guess\n",
    "2. Heuristic\n",
    "3. Optimization\n",
    "\n",
    "Tips:\n",
    " - Avoid an even k with only 2 classes (tie break)\n",
    " - Choose k >= # classes + 1\n",
    " - Choose as low a k as possible \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Use coprime class and k\n",
    "\n",
    "Coprime numbers don’t share common divisors except for 1. So 4 and 9 are coprime but not 3 and 9. \n",
    "\n",
    "![Coprime class and k](figures/knn_classes_coprime.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Use number of classes + 1\n",
    "\n",
    "With k < # of classes, there is no chance that all classes will be represented - but we still want to prevent ties.\n",
    "\n",
    "![Classes plus 1](figures/knn_classes_plus_1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Optimization\n",
    "\n",
    "- Many people assert k should be chosen via domain knowledge - as K increases, the complexity increases and slows down performance.\n",
    " - Minimize error by trying different values of k = Hill Climbing problem. Algorithms: Genetic parameter optimization and simulated annealing. \n",
    " - Iterate 2x through 1% of the data with a variety of K and compute error curve for minimization.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Decision Trees"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    " - Another example of non-parametric inductive learning - but one that generalizes better.\n",
    " - Creates a graphical model of rules that partitions the data until a decision is reached at one of the leaf nodes. \n",
    " - Complexity is related to the amount of data and the partitioning method.\n",
    " \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Decision Tree Example with Iris Dataset](figures/decision_tree_iris.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In Scikit-Learn the tree package provides classifiers and regressors based on a decision tree model. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Decision Tree Algorithm\n",
    "\n",
    "Partition data as follows:\n",
    " - Start with whole training data\n",
    " - Select attribute along dimension that gives “best” split\n",
    " - Create child nodes based on split\n",
    " - Recurse on each child using child data until stop\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "What is the “best” split?\n",
    "\n",
    "![Best split](figures/decision_tree_best_split.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Split Metrics\n",
    "\n",
    "**Gini Impurity (used by CART)**    \n",
    "Measures how often randomly chosen elements would be incorrectly labeled according to distribution in partition. Zero value means all cases fall into single target\n",
    "\n",
    "**Information Gain (ID3 and C5)**    \n",
    "Uses entropy - the amount of information contained in every partition that represents some part of data.\n",
    "\n",
    "**Variance Reduction (CART)**    \n",
    "Maximally select the split where the most variance would be reduced, used for continuous values of data.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "For a set of items where i ∈ {1,2, …, m} and 𝑓i  is the proportion of items in the split labeled i, the Gini Impurity is computed as follows:\n",
    "\n",
    "\n",
    "![Gini](figures/gini.png)\n",
    "\n",
    "\n",
    "Essentially the sum of the probability of an item being chosen times the probability of a mistake being made."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Decision tree in process](figures/decision_tree_process.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Pros and Cons of Decision Trees\n",
    "\n",
    "#### Pros\n",
    "\n",
    " - Simple to understand; no representational mysticism. Trees can be drawn out.\n",
    " - No need to normalize or standardize (need to deal with missing values).\n",
    " - Low cost\n",
    " - Handle multi-output\n",
    " - Validate with Statistics!\n",
    " - Handles wrong assumptions.\n",
    "\n",
    "#### Cons\n",
    "\n",
    " - Prone to overfit (deep trees don’t generalize)\n",
    " - Minor variations in data cause big changes in tree structure (unstable)... fix with ensemble methods.\n",
    " - Create biases if some classes dominate\n",
    " - Some functions are impossible to model\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Tips for Avoiding Overfit\n",
    "\n",
    "Ratio of samples to number of features is important, trees in high dimensional space are very likely to overfit.\n",
    "\n",
    "Balance your dataset before training to prevent the tree from creating a tree biased toward the classes that are dominant.\n",
    "\n",
    "Remember that the number of samples required to populate the tree doubles for each additional level the tree grows to. Use max_depth to control the size of the tree to prevent overfitting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Tips for Tuning\n",
    "\n",
    "Visualise your tree as you are training by using the export function. Use max_depth=3 as an initial tree depth to get a feel for how the tree is fitting to your data, and then increase the depth.\n",
    "\n",
    "Perform dimensionality reduction to give tree a better chance of finding features that are discriminative (PCA, ICA, Feature Selection)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Or, just use a Random Forest...\n",
    "\n",
    "\n",
    "```python\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "splits = train_test_split(digits.data, digits.target, test_size=0.2)\n",
    "X_train, X_test, y_train, y_test = splits\n",
    "\n",
    "model = RandomForestClassifier()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "expected = y_test\n",
    "predicted = model.predict(X_test)\n",
    "\n",
    "print(classification_report(expected, predicted))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Decision Stumps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ensembles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Random Forest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Random forests are an ensemble learning method that are effective at correcting for decision trees' habit of overfitting to their training set.\n",
    "\n",
    "\n",
    "The model creates a number of decision trees using the CART algorithm, each on a different subset of the data. The general approach to creating the ensemble is bootstrap aggregation of the decision trees (also known as 'bagging')."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Random Forest](figures/random_forest.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Strategy: \n",
    "\n",
    "Construct many decision trees at training time and output...\n",
    "\n",
    "*(Classification)*    \n",
    "...the mode of the classes of the individual trees.\n",
    "\n",
    "*(Regression)*    \n",
    "... the mean prediction of the individual trees. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_diabetes\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "diabetes = load_diabetes()\n",
    "\n",
    "splits = train_test_split(diabetes.data, diabetes.target, test_size=0.2)\n",
    "X_train, X_test, y_train, y_test = splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestRegressor\n",
    "\n",
    "model = RandomForestRegressor()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "expected = y_test\n",
    "predicted = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import requests\n",
    "import pandas as pd\n",
    "\n",
    "HABERMAN_SURVIVAL_URL = \"https://bit.ly/1IPs7Vo\"\n",
    "response = requests.get(HABERMAN_SURVIVAL_URL)\n",
    "outpath = os.path.abspath(\"haberman.txt\")\n",
    "with open(outpath, 'wb') as f:\n",
    "    f.write(response.content)\n",
    "\n",
    "df = pd.read_csv(\"haberman.txt\", header=None, names=[\"age_at_op\",\"op_yr\",\"nr_nodes\",\"survival\"])\n",
    "X = df[[\"age_at_op\",\"op_yr\",\"nr_nodes\"]]\n",
    "y = df[[\"survival\"]]\n",
    "\n",
    "splits = train_test_split(X, y.values.ravel(), test_size=0.2)\n",
    "X_train, X_test, y_train, y_test = splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "model = RandomForestClassifier()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "expected = y_test\n",
    "predicted = model.predict(X_test)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}