student_intervention.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project 2: Supervised Learning\n",
    "### Building a Student Intervention System"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Classification vs Regression\n",
    "\n",
    "Your goal is to identify students who might need early intervention - which type of supervised machine learning problem is this, classification or regression? Why?\n",
    "\n",
    "##### This is a classification problem becasuse we are trying to predict if student will drop out or not based on avialble data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Exploring the Data\n",
    "\n",
    "Let's go ahead and read in the student dataset first.\n",
    "\n",
    "_To execute a code cell, click inside it and press **Shift+Enter**._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Import libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as pl\n",
    "%matplotlib inline "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student data read successfully!\n"
     ]
    }
   ],
   "source": [
    "# Read student data\n",
    "student_data = pd.read_csv(\"student-data.csv\")\n",
    "print \"Student data read successfully!\"\n",
    "# Note: The last column 'passed' is the target/label, all other are feature columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Now, can you find out the following facts about the dataset?\n",
    "- Total number of students\n",
    "- Number of students who passed\n",
    "- Number of students who failed\n",
    "- Graduation rate of the class (%age)\n",
    "- Number of features\n",
    "\n",
    "_Use the code block below to compute these values. Instructions/steps are marked using **TODO**s._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of students: 395\n",
      "Number of students who passed: 265\n",
      "Number of students who failed: 130\n",
      "Number of features: 30\n",
      "Graduation rate of the class: 67.09%\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# TODO: Compute desired values - replace each '?' with an appropriate expression/function call\n",
    "n_students = student_data.shape[0]\n",
    "n_features = student_data.shape[1] - 1 \n",
    "n_passed = len(student_data[student_data.passed == \"yes\"])\n",
    "n_failed = len(student_data[student_data.passed == \"no\"])\n",
    "grad_rate = float(n_passed) / n_students * 100 \n",
    "print \"Total number of students: {}\".format(n_students)\n",
    "print \"Number of students who passed: {}\".format(n_passed)\n",
    "print \"Number of students who failed: {}\".format(n_failed)\n",
    "print \"Number of features: {}\".format(n_features)\n",
    "print \"Graduation rate of the class: {:.2f}%\".format(grad_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Preparing the Data\n",
    "In this section, we will prepare the data for modeling, training and testing.\n",
    "\n",
    "### Identify feature and target columns\n",
    "It is often the case that the data you obtain contains non-numeric features. This can be a problem, as most machine learning algorithms expect numeric data to perform computations with.\n",
    "\n",
    "Let's first separate our data into feature and target columns, and see if any features are non-numeric.<br/>\n",
    "**Note**: For this dataset, the last column (`'passed'`) is the target or label we are trying to predict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature column(s):-\n",
      "['school', 'sex', 'age', 'address', 'famsize', 'Pstatus', 'Medu', 'Fedu', 'Mjob', 'Fjob', 'reason', 'guardian', 'traveltime', 'studytime', 'failures', 'schoolsup', 'famsup', 'paid', 'activities', 'nursery', 'higher', 'internet', 'romantic', 'famrel', 'freetime', 'goout', 'Dalc', 'Walc', 'health', 'absences']\n",
      "Target column: passed\n",
      "\n",
      "Feature values:-\n",
      "  school sex  age address famsize Pstatus  Medu  Fedu     Mjob      Fjob  \\\n",
      "0     GP   F   18       U     GT3       A     4     4  at_home   teacher   \n",
      "1     GP   F   17       U     GT3       T     1     1  at_home     other   \n",
      "2     GP   F   15       U     LE3       T     1     1  at_home     other   \n",
      "3     GP   F   15       U     GT3       T     4     2   health  services   \n",
      "4     GP   F   16       U     GT3       T     3     3    other     other   \n",
      "\n",
      "    ...    higher internet  romantic  famrel  freetime goout Dalc Walc health  \\\n",
      "0   ...       yes       no        no       4         3     4    1    1      3   \n",
      "1   ...       yes      yes        no       5         3     3    1    1      3   \n",
      "2   ...       yes      yes        no       4         3     2    2    3      3   \n",
      "3   ...       yes      yes       yes       3         2     2    1    1      5   \n",
      "4   ...       yes       no        no       4         3     2    1    2      5   \n",
      "\n",
      "  absences  \n",
      "0        6  \n",
      "1        4  \n",
      "2       10  \n",
      "3        2  \n",
      "4        4  \n",
      "\n",
      "[5 rows x 30 columns]\n",
      "0     no\n",
      "1     no\n",
      "2    yes\n",
      "3    yes\n",
      "4    yes\n",
      "Name: passed, dtype: object\n"
     ]
    }
   ],
   "source": [
    "# Extract feature (X) and target (y) columns\n",
    "feature_cols = list(student_data.columns[:-1])  # all columns but last are features\n",
    "target_col = student_data.columns[-1]  # last column is the target/label\n",
    "print \"Feature column(s):-\\n{}\".format(feature_cols)\n",
    "print \"Target column: {}\".format(target_col)\n",
    "\n",
    "X_all = student_data[feature_cols]  # feature values for all students\n",
    "y_all = student_data[target_col]  # corresponding targets/labels\n",
    "print \"\\nFeature values:-\"\n",
    "print X_all.head()  # print the first 5 rows\n",
    "print y_all.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preprocess feature columns\n",
    "\n",
    "As you can see, there are several non-numeric columns that need to be converted! Many of them are simply `yes`/`no`, e.g. `internet`. These can be reasonably converted into `1`/`0` (binary) values.\n",
    "\n",
    "Other columns, like `Mjob` and `Fjob`, have more than two values, and are known as _categorical variables_. The recommended way to handle such a column is to create as many columns as possible values (e.g. `Fjob_teacher`, `Fjob_other`, `Fjob_services`, etc.), and assign a `1` to one of them and `0` to all others.\n",
    "\n",
    "These generated columns are sometimes called _dummy variables_, and we will use the [`pandas.get_dummies()`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.get_dummies.html?highlight=get_dummies#pandas.get_dummies) function to perform this transformation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processed feature columns (48):-\n",
      "['school_GP', 'school_MS', 'sex_F', 'sex_M', 'age', 'address_R', 'address_U', 'famsize_GT3', 'famsize_LE3', 'Pstatus_A', 'Pstatus_T', 'Medu', 'Fedu', 'Mjob_at_home', 'Mjob_health', 'Mjob_other', 'Mjob_services', 'Mjob_teacher', 'Fjob_at_home', 'Fjob_health', 'Fjob_other', 'Fjob_services', 'Fjob_teacher', 'reason_course', 'reason_home', 'reason_other', 'reason_reputation', 'guardian_father', 'guardian_mother', 'guardian_other', 'traveltime', 'studytime', 'failures', 'schoolsup', 'famsup', 'paid', 'activities', 'nursery', 'higher', 'internet', 'romantic', 'famrel', 'freetime', 'goout', 'Dalc', 'Walc', 'health', 'absences']\n"
     ]
    }
   ],
   "source": [
    "# Preprocess feature columns\n",
    "def preprocess_features(X):\n",
    "    outX = pd.DataFrame(index=X.index)  # output dataframe, initially empty\n",
    "\n",
    "    # Check each column\n",
    "    for col, col_data in X.iteritems():\n",
    "        # If data type is non-numeric, try to replace all yes/no values with 1/0\n",
    "        if col_data.dtype == object:\n",
    "            col_data = col_data.replace(['yes', 'no'], [1, 0])\n",
    "        # Note: This should change the data type for yes/no columns to int\n",
    "\n",
    "        # If still non-numeric, convert to one or more dummy variables\n",
    "        if col_data.dtype == object:\n",
    "            col_data = pd.get_dummies(col_data, prefix=col)  # e.g. 'school' => 'school_GP', 'school_MS'\n",
    "\n",
    "        outX = outX.join(col_data)  # collect column(s) in output dataframe\n",
    "\n",
    "    return outX\n",
    "\n",
    "X_all = preprocess_features(X_all)\n",
    "y_all = y_all.replace(['yes', 'no'], [1, 0])\n",
    "print \"Processed feature columns ({}):-\\n{}\".format(len(X_all.columns), list(X_all.columns))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Split data into training and test sets\n",
    "\n",
    "So far, we have converted all _categorical_ features into numeric values. In this next step, we split the data (both features and corresponding labels) into training and test sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set: 300 samples\n",
      "Test set: 95 samples\n"
     ]
    }
   ],
   "source": [
    "from sklearn.cross_validation import train_test_split\n",
    "# First, decide how many training vs test samples you want\n",
    "num_all = student_data.shape[0]  # same as len(student_data)\n",
    "num_train = 300  # about 75% of the data\n",
    "num_test = num_all - num_train\n",
    "\n",
    "\n",
    "# TODO: Then, select features (X) and corresponding labels (y) for the training and test sets\n",
    "# Note: Shuffle the data or randomly select samples to avoid any bias due to ordering in the dataset\n",
    "# I am using treain_test_split which  wraps input validation and next(iter(ShuffleSplit(n_samples))) and application to input data into a single call for splitting (and optionally subsampling) data in a oneliner.\n",
    "\n",
    "\n",
    "X_train , X_test,  y_train , y_test = train_test_split(X_all, y_all, test_size = num_test, random_state=0 )\n",
    "\n",
    "print \"Training set: {} samples\".format(X_train.shape[0])\n",
    "print \"Test set: {} samples\".format(X_test.shape[0])\n",
    "# Note: If you need a validation set, extract it from within training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def learning_curve_graph(sizes, train_err, test_err):\n",
    "    '''Plot training and test error as a function of the training size.'''\n",
    "\n",
    "    pl.figure()\n",
    "    pl.title('Performance vs Training Size')\n",
    "    pl.plot(sizes, test_err, lw=2, label = 'test error' )\n",
    "    pl.plot(sizes, train_err, lw=2, label = 'training error')\n",
    "    #pl.ylim (0,1)\n",
    "    pl.legend(loc='best')\n",
    "    pl.xlabel('Training Size')\n",
    "    pl.ylabel('Error')\n",
    "    pl.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Train a model\n",
    "import time\n",
    "\n",
    "def train_classifier(clf, X_train, y_train):\n",
    "    print \"Training {}...\".format(clf.__class__.__name__)\n",
    "    start = time.time()\n",
    "    clf.fit(X_train, y_train)\n",
    "    end = time.time()\n",
    "    print \"Done!\\nTraining time (secs): {:.3f}\".format(end - start)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choosing Claisfier\n",
    "\n",
    "In order to choose a clasifer for this problem I used the map of Sklearn classifiers. I test each clasifier to see accurencie. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5-fold cross validation:\n",
      "\n",
      "F1 Messure: 0.71 (+/- 0.05) [DecisionTreeClassifier]\n",
      "F1 Messure: 0.77 (+/- 0.04) [KNeighborsClassifier]\n",
      "F1 Messure: 0.81 (+/- 0.04) [SVC]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn import cross_validation\n",
    "import numpy as np\n",
    "\n",
    "np.random.seed(123)\n",
    "\n",
    "clf1 = DecisionTreeClassifier()\n",
    "clf2 = KNeighborsClassifier()\n",
    "clf3 = SVC()\n",
    "\n",
    "print('5-fold cross validation:\\n')\n",
    "\n",
    "for clf, label in zip([clf1, clf2, clf3], ['DecisionTreeClassifier', 'KNeighborsClassifier', 'SVC']):\n",
    "\n",
    "    scores = cross_validation.cross_val_score(clf, X_train, y_train, cv=5, scoring='f1')\n",
    "    print(\"F1 Messure: %0.2f (+/- %0.2f) [%s]\" % (scores.mean(), scores.std(), label))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  Questions about \n",
    "- What is both the theoretical space complexity to represent the model and the time for the algorithm to make a prediction? \n",
    "You can either provide the big-O notation, or list several the of major features that may affect the algorithm and state if the largest driving factor is constant, linear, logrithmic, polynomical, etc in nature. \n",
    "<p> <b> \n",
    "Due to small dataset the prediction and training  times of the model are negleble.\n",
    "Driving factor of comuputionn is liner in nature, meaning is we increase number of samples, the time it will take to execute will increase. As such driving factor is Liner.\n",
    "https://en.wikipedia.org/wiki/Time_complexity#Polynomial_time\n",
    "</b>\n",
    "<p>\n",
    "- What are the general applications of this model?\n",
    "<p><b> Decision Tree Classifier applies a straitforward idea to solve the classification problem. it poses a series of carefully crafted questions about the attributes of the test record. Each time time it receive an answer, a follow-up question is asked until a conclusion about the calss label of the record is reached.</b>\n",
    "</p>\n",
    "- What are its strengths and weaknesses? \n",
    "<p><B>Advantages: Decision trees are simple to use, easy to understand.  <br>\n",
    "Disadvantages:  Even a small change in input data can at times, cause large changes in the tree. <br>\n",
    "Decision trees are also prone to errors in classification, owing to differences in perceptions and the limitations of applying statistical tools.</p> </b> <br>\n",
    "<p>\n",
    "- Given what you know about the data so far, why did you choose this model to apply?  <br><B>Predictive Power, Relative Simplicity<b> <p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuning \n",
    "After obtaining accurecny of each model, I will use grid search to search parameter space to find the best parmeters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for training set: 0.829493087558\n"
     ]
    }
   ],
   "source": [
    "# Predict on training set and compute F1 score\n",
    "from sklearn.metrics import f1_score\n",
    "\n",
    "def predict_labels(clf, features, target):\n",
    "    print \"Predicting labels using {}...\".format(clf.__class__.__name__)\n",
    "    start = time.time()\n",
    "    y_pred = clf.predict(features)\n",
    "    end = time.time()\n",
    "    print \"Done!\\nPrediction time (secs): {:.3f}\".format(end - start)\n",
    "    return f1_score(target.values, y_pred, pos_label=1)\n",
    "\n",
    "train_f1_score = predict_labels(clf, X_train, y_train)\n",
    "print \"F1 score for training set: {}\".format(train_f1_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Train and predict using different training set sizes\n",
    "def train_predict(clf, X_train, y_train, X_test, y_test):\n",
    "    print \"------------------------------------------\"\n",
    "    print \"Training set size: {}\".format(len(X_train))\n",
    "    train_classifier(clf, X_train, y_train)\n",
    "    print \"F1 score for training set: {}\".format(predict_labels(clf, X_train, y_train))\n",
    "    print \"F1 score for test set: {}\".format(predict_labels(clf, X_test, y_test))\n",
    "    return predict_labels(clf, X_train, y_train), predict_labels(clf, X_test, y_test)\n",
    "# TODO: Run the helper function above for desired subsets of training data\n",
    "# Note: Keep the test set constant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GridSearchCV(cv=None, error_score='raise',\n",
      "       estimator=DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,\n",
      "            max_features=None, max_leaf_nodes=None, min_samples_leaf=1,\n",
      "            min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
      "            random_state=None, splitter='best'),\n",
      "       fit_params={}, iid=True, loss_func=None, n_jobs=1,\n",
      "       param_grid={'criterion': ['gini', 'entropy'], 'max_depth': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]},\n",
      "       pre_dispatch='2*n_jobs', refit=True, score_func=None, scoring='f1',\n",
      "       verbose=0)\n",
      " Best regressor params: {'criterion': 'gini', 'max_depth': 2}\n"
     ]
    }
   ],
   "source": [
    "clf = DecisionTreeClassifier()\n",
    "n = range(1,11)\n",
    "parameters = {'max_depth':n, 'criterion':['gini', 'entropy'] }\n",
    "\n",
    "from sklearn.grid_search import GridSearchCV \n",
    "\n",
    "reg = GridSearchCV(clf, param_grid = parameters,  verbose = 0, scoring='f1')\n",
    "print reg.fit(X_train, y_train)\n",
    "\n",
    "print \" Best regressor params:\",  reg.best_params_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decision Tree Classifier Model\n",
    "After obraining best parmeter, use it to perform clasification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decision Tree Classifier Model \n",
      "------------------------------------------\n",
      "Training set size: 100\n",
      "Training DecisionTreeClassifier...\n",
      "Done!\n",
      "Training time (secs): 0.000\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for training set: 0.805755395683\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for test set: 0.802919708029\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "------------------------------------------\n",
      "Training set size: 200\n",
      "Training DecisionTreeClassifier...\n",
      "Done!\n",
      "Training time (secs): 0.000\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for training set: 0.830985915493\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for test set: 0.794117647059\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "------------------------------------------\n",
      "Training set size: 300\n",
      "Training DecisionTreeClassifier...\n",
      "Done!\n",
      "Training time (secs): 0.001\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for training set: 0.829493087558\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for test set: 0.785185185185\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "Predicting labels using DecisionTreeClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEZCAYAAACAZ8KHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nwk2CTgdurgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10b5c7710>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=2,\n",
      "            max_features=None, max_leaf_nodes=None, min_samples_leaf=1,\n",
      "            min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
      "            random_state=None, splitter='best')\n",
      "size [ 100.  200.  300.]\n",
      "train  [ 0.8057554   0.83098592  0.82949309]\n",
      "test [ 0.80291971  0.79411765  0.78518519]\n"
     ]
    }
   ],
   "source": [
    "print 'Decision Tree Classifier Model '\n",
    "from sklearn.metrics import f1_score\n",
    "\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "clf = DecisionTreeClassifier(max_depth =2)\n",
    "\n",
    "sizes = np.linspace(len(X_train) / 3, len(X_train), 3)\n",
    "train_err = np.zeros(len(sizes))\n",
    "test_err = np.zeros(len(sizes))\n",
    "train_time = np.zeros(len(sizes))\n",
    "test_time= np.zeros(len(sizes)) \n",
    "for i, s in enumerate(sizes):\n",
    "    s = s.astype(int)\n",
    "    \n",
    "    #print \"Done!\\nTraining time (secs): {:.3f}\".format(end - start)\n",
    "    # Create and fit the decision tree regressor model\n",
    "    clf.fit(X_train[:s], y_train[:s])\n",
    "\n",
    "    # Find the performance on the training and testing set\n",
    "    train_err[i], test_err[i] =  train_predict(clf, X_train[:s], y_train[:s], X_test, y_test)\n",
    "\n",
    "\n",
    "# Plot learning curve graph\n",
    "learning_curve_graph(sizes, train_err, test_err)\n",
    "\n",
    "# end of copy\n",
    "\n",
    "# Fit model to training data\n",
    "#train_classifier(clf, X_train, y_train)  # note: using entire training set here\n",
    "print clf  # you can inspect the learned model by printing it\n",
    "\n",
    "print'size',  sizes\n",
    "print 'train ', train_err\n",
    "print 'test', test_err"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print decision treee.\n",
    "from StringIO import StringIO\n",
    "from sklearn import tree\n",
    "import pydot\n",
    "\n",
    "str_buffer = StringIO()\n",
    "tree.export_graphviz(dt, out_file=str_buffer)\n",
    "graph = pydot.graph_from_dot_data(str_buffer.getvalue())\n",
    "graph.write(\"myfile.jpg\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LinearSVC Classifier Model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GridSearchCV(cv=None, error_score='raise',\n",
      "       estimator=LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
      "     multi_class='ovr', penalty='l2', random_state=0, tol=0.0001,\n",
      "     verbose=0),\n",
      "       fit_params={}, iid=True, loss_func=None, n_jobs=1,\n",
      "       param_grid={'C': [1, 2, 3, 4, 5, 6, 7, 8, 9]},\n",
      "       pre_dispatch='2*n_jobs', refit=True, score_func=None, scoring='f1',\n",
      "       verbose=0)\n",
      " Best regressor params: {'C': 4}\n"
     ]
    }
   ],
   "source": [
    "from sklearn import svm\n",
    "clf = svm.LinearSVC(random_state=0)\n",
    "n = [i for i in range(1,10)]\n",
    "parameters = {'C':n }\n",
    "\n",
    "from sklearn.grid_search import GridSearchCV \n",
    "reg = GridSearchCV(clf, param_grid = parameters,  verbose = 0, scoring='f1')\n",
    "print reg.fit(X_all, y_all)\n",
    "\n",
    "print \" Best regressor params:\",  reg.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinearSVC Model training\n",
      "------------------------------------------\n",
      "Training set size: 100\n",
      "Training LinearSVC...\n",
      "Done!\n",
      "Training time (secs): 0.008\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for training set: 0.561797752809\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for test set: 0.444444444444\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "------------------------------------------\n",
      "Training set size: 200\n",
      "Training LinearSVC...\n",
      "Done!\n",
      "Training time (secs): 0.017\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for training set: 0.540540540541\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for test set: 0.547619047619\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "------------------------------------------\n",
      "Training set size: 300\n",
      "Training LinearSVC...\n",
      "Done!\n",
      "Training time (secs): 0.027\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for training set: 0.833693304536\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "F1 score for test set: 0.768115942029\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n",
      "Predicting labels using LinearSVC...\n",
      "Done!\n",
      "Prediction time (secs): 0.000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEZCAYAAAB8culNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nKhNNDkoppTLR5KCUUiqT/wfF4PewIWsApgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10afadf50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinearSVC(C=4, class_weight=None, dual=True, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
      "     multi_class='ovr', penalty='l2', random_state=0, tol=0.0001,\n",
      "     verbose=0)\n",
      "size [ 100.  200.  300.]\n",
      "train  [ 0.56179775  0.54054054  0.8336933 ]\n",
      "test [ 0.44444444  0.54761905  0.76811594]\n"
     ]
    }
   ],
   "source": [
    "print 'LinearSVC Model training'\n",
    "# TODO: Choose a model, import it and instantiate an object\n",
    "# Linear SVC .LinearSVC\n",
    "#KN Neibers \n",
    "#SVC Ensable Classification \n",
    "# We will vary the training set size so that we have 50 different sizes\n",
    "#start of copy  \n",
    "from sklearn import svm\n",
    "#parameters from grid search came out as default. No need to tune\n",
    "clf = svm.LinearSVC( C=4, random_state=0)\n",
    "\n",
    "sizes = np.linspace(len(X_train) / 3, len(X_train), 3)\n",
    "train_err = np.zeros(len(sizes))\n",
    "test_err = np.zeros(len(sizes))\n",
    "train_time = np.zeros(len(sizes))\n",
    "test_time= np.zeros(len(sizes))\n",
    "\n",
    "for i, s in enumerate(sizes):\n",
    "    s = s.astype(int)\n",
    "    \n",
    "    # Create and fit the decision tree regressor model\n",
    "    clf.fit(X_train[:s], y_train[:s])\n",
    "    \n",
    "    train_err[i], test_err[i] =  train_predict(clf, X_train[:s], y_train[:s], X_test, y_test)\n",
    "\n",
    "\n",
    "# Plot learning curve graph\n",
    "learning_curve_graph(sizes, train_err, test_err)\n",
    "\n",
    "# end of copy\n",
    "\n",
    "# Fit model to training data\n",
    "#train_classifier(clf, X_train, y_train)  # note: using entire training set here\n",
    "print clf  # you can inspect the learned model by printing it\n",
    "print'size',  sizes\n",
    "print 'train ', train_err\n",
    "print 'test', test_err"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### KNeighborsClassifier Model training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GridSearchCV(cv=None, error_score='raise',\n",
      "       estimator=KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
      "           metric_params=None, n_neighbors=5, p=2, weights='uniform'),\n",
      "       fit_params={}, iid=True, loss_func=None, n_jobs=1,\n",
      "       param_grid={'n_neighbors': [1, 3, 5, 7, 9, 11, 13]},\n",
      "       pre_dispatch='2*n_jobs', refit=True, score_func=None, scoring='f1',\n",
      "       verbose=0)\n",
      " Best regressor params: {'n_neighbors': 11}\n"
     ]
    }
   ],
   "source": [
    "#Get odd list of neighbors \n",
    "n = [i for i in range(1,15,2)]\n",
    "\n",
    "\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "clf = KNeighborsClassifier()\n",
    "parameters = {'n_neighbors':n }\n",
    "\n",
    "from sklearn.grid_search import GridSearchCV \n",
    "reg = GridSearchCV(clf, param_grid = parameters,  verbose = 0, scoring='f1')\n",
    "print reg.fit(X_all, y_all)\n",
    "\n",
    "print \" Best regressor params:\",  reg.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KNeighborsClassifier Model training\n",
      "------------------------------------------\n",
      "Training set size: 100\n",
      "Training KNeighborsClassifier...\n",
      "Done!\n",
      "Training time (secs): 0.001\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.003\n",
      "F1 score for training set: 0.781456953642\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.002\n",
      "F1 score for test set: 0.768115942029\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.002\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.002\n",
      "------------------------------------------\n",
      "Training set size: 200\n",
      "Training KNeighborsClassifier...\n",
      "Done!\n",
      "Training time (secs): 0.001\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.004\n",
      "F1 score for training set: 0.830065359477\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.002\n",
      "F1 score for test set: 0.783216783217\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.004\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.002\n",
      "------------------------------------------\n",
      "Training set size: 300\n",
      "Training KNeighborsClassifier...\n",
      "Done!\n",
      "Training time (secs): 0.001\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.007\n",
      "F1 score for training set: 0.841437632135\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.003\n",
      "F1 score for test set: 0.788732394366\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.007\n",
      "Predicting labels using KNeighborsClassifier...\n",
      "Done!\n",
      "Prediction time (secs): 0.003\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEZCAYAAACAZ8KHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nHMYYY/xigcMYY4xfLHAYY4zxy/8DcyWuamJXqOkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10aca3b50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
      "           metric_params=None, n_neighbors=11, p=2, weights='uniform')\n",
      "size [ 100.  200.  300.]\n",
      "train  [ 0.78145695  0.83006536  0.84143763]\n",
      "test [ 0.76811594  0.78321678  0.78873239]\n"
     ]
    }
   ],
   "source": [
    "print 'KNeighborsClassifier Model training'\n",
    "# TODO: Choose a model, import it and instantiate an object\n",
    "# Linear SVC .LinearSVC\n",
    "#KN Neibers \n",
    "#SVC Ensable Classification \n",
    "# We will vary the training set size so that we have 50 different sizes\n",
    "#start of copy \n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "clf = KNeighborsClassifier(n_neighbors=11)\n",
    "    \n",
    "sizes = np.linspace(len(X_train) / 3, len(X_train), 3)\n",
    "train_err = np.zeros(len(sizes))\n",
    "test_err = np.zeros(len(sizes))\n",
    "\n",
    "for i, s in enumerate(sizes):\n",
    "    s = s.astype(int)\n",
    "   \n",
    "    # Create and fit the decision tree regressor model\n",
    "    clf.fit( X_train[:s], y_train[:s])\n",
    "    \n",
    "    # Find the performance on the training and testing set\n",
    "    train_err[i], test_err[i] =  train_predict(clf, X_train[:s], y_train[:s], X_test, y_test)\n",
    "    \n",
    "\n",
    "# Plot learning curve graph\n",
    "learning_curve_graph(sizes, train_err, test_err)\n",
    "\n",
    "# end of copy\n",
    "\n",
    "# Fit model to training data\n",
    "#train_classifier(clf, X_train, y_train)  # note: using entire training set here\n",
    "print clf  # you can inspect the learned model by printing it\n",
    "print'size',  sizes\n",
    "print 'train ', train_err\n",
    "print 'test', test_err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Train and predict using different training set sizes\n",
    "def train_predict(clf, X_train, y_train, X_test, y_test):\n",
    "    print \"------------------------------------------\"\n",
    "    print \"Training set size: {}\".format(len(X_train))\n",
    "    train_classifier(clf, X_train, y_train)\n",
    "    print \"F1 score for training set: {}\".format(predict_labels(clf, X_train, y_train))\n",
    "    print \"F1 score for test set: {}\".format(predict_labels(clf, X_test, y_test))\n",
    "\n",
    "# TODO: Run the helper function above for desired subsets of training data\n",
    "# Note: Keep the test set constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Choosing the Best Model\n",
    "\n",
    "- Based on the experiments you performed earlier, in 1-2 paragraphs explain to the board of supervisors what single model you chose as the best model. Which model is generally the most appropriate based on the available data, limited resources, cost, and performance?\n",
    "\n",
    "###### Based on tests performed, I compared 3 models, Decision tree clasifier, Random forest, and Support Vector Classification. After evaluating performance of each model I choose Decision Tree Classifier Model for number of reasons:\n",
    "###### - Accurancy: Model predicts with high F1 Score.  F1 score conveys the balance between the precision and the recall. \n",
    "###### - Peformance: Obtainings training and test prediction fastes\n",
    "\n",
    "- In 1-2 paragraphs explain to the board of supervisors in layman's terms how the final model chosen is supposed to work (for example if you chose a Decision Tree or Support Vector Machine, how does it make a prediction).\n",
    "###### KNeighborsClassifier Classifier uses a majority neibour voting to detirmine the  class of a new example\n",
    "<p>\n",
    "- Fine-tune the model. Use Gridsearch with at least one important parameter tuned and with at least 3 settings. Use the entire training set for this.\n",
    "<p>\n",
    "<B>\n",
    "Without finding the best parameters following were the prediction accurancies:\n",
    "<p>\n",
    "F1 Messure: 0.71 (+/- 0.05) [DecisionTreeClassifier] <br>\n",
    "F1 Messure: 0.77 (+/- 0.04) [KNeighborsClassifier] <br>\n",
    "F1 Messure: 0.81 (+/- 0.04) [SVC] <br>\n",
    "</p>\n",
    "I have tuned each model to find best parmaeter. Please refer to outputs of each model </b>\n",
    "\n",
    "<p>\n",
    "- What is the model's final F<sub>1</sub> score?\n",
    "<p>\n",
    "<B>Best F1 score for test set is 0.788</B>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Student Intervention System - Decision Tree Classifier\n",
    "\n",
    "\n",
    "\n",
    "<table cellpadding=\"0\" cellspacing=\"0\" class=\"c12\">\n",
    "   <tbody>\n",
    "      <tr class=\"c10\">\n",
    "         <td class=\"c1 c9\" colspan=\"1\" rowspan=\"2\">\n",
    "            <p class=\"c0\"><span class=\"c2\"></span></p>\n",
    "         </td>\n",
    "         <td class=\"c9 c13\" colspan=\"3\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">Training set size</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c10\">\n",
    "         <td class=\"c4 c9\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">100</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4 c9\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">200</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4 c9\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">300</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">Training time (secs)</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">Prediction time (secs)</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">F1 score for training set</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.805</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.830</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.829</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">F1 score for test set</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.802</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.794</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.785</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "   </tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Student Intervention System - LinearSVC Classifier\n",
    "\n",
    "\n",
    "\n",
    "<table cellpadding=\"0\" cellspacing=\"0\" class=\"c12\">\n",
    "   <tbody>\n",
    "      <tr class=\"c10\">\n",
    "         <td class=\"c1 c9\" colspan=\"1\" rowspan=\"2\">\n",
    "            <p class=\"c0\"><span class=\"c2\"></span></p>\n",
    "         </td>\n",
    "         <td class=\"c9 c13\" colspan=\"3\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">Training set size</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c10\">\n",
    "         <td class=\"c4 c9\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">100</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4 c9\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">200</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4 c9\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">300</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">Training time (secs)</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.007</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.018</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.024</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">Prediction time (secs)</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">F1 score for training set</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.561</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.540</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.833</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">F1 score for test set</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.444</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.547</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.768</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "   </tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Student Intervention System - KNeighborsClassifier Classifier\n",
    "\n",
    "\n",
    "\n",
    "<table cellpadding=\"0\" cellspacing=\"0\" class=\"c12\">\n",
    "   <tbody>\n",
    "      <tr class=\"c10\">\n",
    "         <td class=\"c1 c9\" colspan=\"1\" rowspan=\"2\">\n",
    "            <p class=\"c0\"><span class=\"c2\"></span></p>\n",
    "         </td>\n",
    "         <td class=\"c9 c13\" colspan=\"3\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">Training set size</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c10\">\n",
    "         <td class=\"c4 c9\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">100</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4 c9\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">200</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4 c9\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">300</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">Training time (secs)</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.001</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.001</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.001</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">Prediction time (secs)</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.002</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.002</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.006</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">F1 score for training set</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.781</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.830</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.841</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "      <tr class=\"c11\">\n",
    "         <td class=\"c1\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c6\"><span class=\"c2\">F1 score for test set</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.768</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.783</span></p>\n",
    "         </td>\n",
    "         <td class=\"c4\" colspan=\"1\" rowspan=\"1\">\n",
    "            <p class=\"c0\"><span class=\"c2\">0.788</span></p>\n",
    "         </td>\n",
    "      </tr>\n",
    "   </tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}