FreqML4_gradient_boosted_trees.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "FreqML4_gradient_boosted_trees.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/yuvalofek/FrequentistML/blob/master/FreqML4_gradient_boosted_trees.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x6a1z_OvNQxX"
      },
      "source": [
        "# **Frequentist ML Assignment 4 - Gradient Boosted Trees**\n",
        "\n",
        "Yuval Epstain Ofek & Theo Jaquenoud\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NvpEJOynNbn4"
      },
      "source": [
        "**The Prompt:**\n",
        "For this assignment, you will learn how to use and tune a common gradient boosted tree package XGBoost:\n",
        "\n",
        "https://xgboost.readthedocs.io/en/latest/\n",
        "\n",
        "1. First, select one of the datasets from section 10.14 of the test(either California Housing or New Zealand Fish) and replicate the analysis, including the plots. You don't have to do the maps. \n",
        "\n",
        "2. Next, select a dataset of your choice and perform a similar analysis. You can perform classification or regresssion, your choice. This should be a more complicated, and if you want, messier, dataset than the ones we've looked at so far. Use the built-in functions that come with the xgboost package to tune the model and optimize your performance, and determine the feature importance.  As this assignment is more focused on using a library, I will be expecting a more thoughtful analysis of the results.\n",
        "\n",
        "For some more details on XGBoost, you can have a look at : https://arxiv.org/pdf/1603.02754v3.pdf and https://medium.com/@gabrieltseng/gradient-boosting-and-xgboost-c306c1bcfaf5\n",
        "\n",
        "If you wish to get your hands a bit dirty on tree-related algorithms, there are 2 stretch goals available as well.\n",
        "\n",
        "* Stretch goal #1, 3 points: Implement a basic tree algorithm for both regression and classification. It must work for several loss functions: mean-squared error, misclassification, Gini index, and cross-entropy. You do not have to implement any pruning, but the # of nodes should be a parameter. Select a dataset to test your algorithm on, and tune it using cross-validation to select the optimal # of nodes. Compare against a baseline.\n",
        "\n",
        "* Stretch goal #2, 3 points: Use a simple tree method, (like your tree from stretch goal #1) and implement algorithm 10.3. Select a dataset, tune your algorithm and compare it against a baseline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DKXRzqdSXm0l"
      },
      "source": [
        "Summary:\n",
        "* get dataset (either California Housing or New Zealand Fish)\n",
        "* Train gradient boost\n",
        "* Plot Absolute Error vs iteration for training and test\n",
        "* Bar plot relative importance of features\n",
        "* repeat above for a chosen dataset\n",
        "\n",
        "\n",
        "\n",
        "Stretch Goals:\n",
        "* Implement a basic tree algorithm that works with a bouple of losses \n",
        "* Select a dataset\n",
        "* Tune using cross validation to get # of nodes\n",
        "* Compare with baseline\n",
        "\n",
        "\n",
        "* Using a simple tree based methid implement 10.3\n",
        "* Select dataset\n",
        "* Tune algorithm\n",
        "* Compare with baseline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nO46JpUiZnRp"
      },
      "source": [
        "##Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PldljdzYONn-"
      },
      "source": [
        "#import stuff\n",
        "import xgboost as xgb\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "#from sklearn import *\n",
        "import sklearn\n",
        "\n",
        "from tabulate import tabulate\n",
        "from sklearn.model_selection import train_test_split  #for spliting data\n",
        "from sklearn.model_selection  import GridSearchCV, StratifiedKFold, RandomizedSearchCV\n",
        "\n",
        "SEED = 123\n",
        "np.random.seed(SEED)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fvz4p5SZmqfS"
      },
      "source": [
        "## California Housing Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kTbNimbX0QjY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 215
        },
        "outputId": "35845509-131f-40ef-db12-79ddd9ddcdb5"
      },
      "source": [
        "#sklearn has the california housing dataset already, lucky us\n",
        "sklearn_housing = sklearn.datasets.fetch_california_housing()\n",
        "cali = pd.DataFrame(sklearn_housing['data'],\n",
        "                    columns = sklearn_housing['feature_names'])\n",
        "cal = cali.to_numpy()\n",
        "cali.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading Cal. housing from https://ndownloader.figshare.com/files/5976036 to /root/scikit_learn_data\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>MedInc</th>\n",
              "      <th>HouseAge</th>\n",
              "      <th>AveRooms</th>\n",
              "      <th>AveBedrms</th>\n",
              "      <th>Population</th>\n",
              "      <th>AveOccup</th>\n",
              "      <th>Latitude</th>\n",
              "      <th>Longitude</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>8.3252</td>\n",
              "      <td>41.0</td>\n",
              "      <td>6.984127</td>\n",
              "      <td>1.023810</td>\n",
              "      <td>322.0</td>\n",
              "      <td>2.555556</td>\n",
              "      <td>37.88</td>\n",
              "      <td>-122.23</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>8.3014</td>\n",
              "      <td>21.0</td>\n",
              "      <td>6.238137</td>\n",
              "      <td>0.971880</td>\n",
              "      <td>2401.0</td>\n",
              "      <td>2.109842</td>\n",
              "      <td>37.86</td>\n",
              "      <td>-122.22</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>7.2574</td>\n",
              "      <td>52.0</td>\n",
              "      <td>8.288136</td>\n",
              "      <td>1.073446</td>\n",
              "      <td>496.0</td>\n",
              "      <td>2.802260</td>\n",
              "      <td>37.85</td>\n",
              "      <td>-122.24</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>5.6431</td>\n",
              "      <td>52.0</td>\n",
              "      <td>5.817352</td>\n",
              "      <td>1.073059</td>\n",
              "      <td>558.0</td>\n",
              "      <td>2.547945</td>\n",
              "      <td>37.85</td>\n",
              "      <td>-122.25</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>3.8462</td>\n",
              "      <td>52.0</td>\n",
              "      <td>6.281853</td>\n",
              "      <td>1.081081</td>\n",
              "      <td>565.0</td>\n",
              "      <td>2.181467</td>\n",
              "      <td>37.85</td>\n",
              "      <td>-122.25</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   MedInc  HouseAge  AveRooms  ...  AveOccup  Latitude  Longitude\n",
              "0  8.3252      41.0  6.984127  ...  2.555556     37.88    -122.23\n",
              "1  8.3014      21.0  6.238137  ...  2.109842     37.86    -122.22\n",
              "2  7.2574      52.0  8.288136  ...  2.802260     37.85    -122.24\n",
              "3  5.6431      52.0  5.817352  ...  2.547945     37.85    -122.25\n",
              "4  3.8462      52.0  6.281853  ...  2.181467     37.85    -122.25\n",
              "\n",
              "[5 rows x 8 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zr3MbCNfljpf"
      },
      "source": [
        "def train_val_test_split(X,y, test_size, val_size, random_state = None):\n",
        "  '''Extended train_test_split to also provide a validation set'''\n",
        "\n",
        "  #We want to split the data in 3, but the train_test_split only splits in 2. \n",
        "  #This means we need to split once to get a testing set and an intermediate set \n",
        "  #which we split again to get the validation and training sets. because \n",
        "  #train_test_split takes a percentage to determine the split, we first determine \n",
        "  #the relative percentage of the intermediate set needed to generate the \n",
        "  #necessary number of samples in the validation set:\n",
        "  rel_val_percent = np.round((val_size)/(1-test_size), 2)\n",
        "\n",
        "  #splitting the data\n",
        "  X_inter, X_test, y_inter, y_test = train_test_split(X,\n",
        "                                                      y,\n",
        "                                                      test_size = test_size,\n",
        "                                                      random_state = random_state\n",
        "                                                      )\n",
        "  X_train, X_val, y_train, y_val = train_test_split(X_inter,\n",
        "                                                      y_inter,\n",
        "                                                      test_size = rel_val_percent,\n",
        "                                                      random_state = random_state\n",
        "                                                      )\n",
        "  \n",
        "  return X_train, X_val, X_test, y_train, y_val, y_test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IuuAp76Hlna8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "outputId": "932bd5e8-1ccb-4583-d60d-4eec302dc74e"
      },
      "source": [
        "#data splitting conditions\n",
        "PERCENT_VAL = 0.10\n",
        "PERCENT_TEST = 0.10\n",
        "random_state = 25  #for reproducibility\n",
        "\n",
        "#Median income is the 2nd column (column 1)\n",
        "split_data = train_val_test_split(cal[:,1:],\n",
        "                                  cal[:,0],\n",
        "                                  PERCENT_TEST,\n",
        "                                  PERCENT_VAL,\n",
        "                                  random_state)\n",
        "#unpacking\n",
        "X_train, X_val, X_test, y_train, y_val, y_test = split_data\n",
        "\n",
        "#printing sizes to check\n",
        "print('Input length:', len(cal))\n",
        "print('Number of training samples:', len(X_train))\n",
        "print('Number of validation samples:', len(X_val))\n",
        "print('Number of testing samples:', len(X_test))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Input length: 20640\n",
            "Number of training samples: 16532\n",
            "Number of validation samples: 2044\n",
            "Number of testing samples: 2064\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uEX7hlWHoFMM"
      },
      "source": [
        "params = {\n",
        "        'min_child_weight': [1, 5, 10],\n",
        "        'gamma': [0, 0.5, 1],\n",
        "        'colsample_bytree': [0.6, 0.8, 1.0],\n",
        "        'max_depth': [2, 4, 6]\n",
        "        }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9l8mTapporM4"
      },
      "source": [
        "xgb1 = xgb.XGBRegressor(learning_rate=0.02,\n",
        "                        n_estimators=800,\n",
        "                        silent=True,\n",
        "                        nthread=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O7Pk3jjrpBcl",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 478
        },
        "outputId": "005f7209-9902-4c55-ca42-ffc337d80b36"
      },
      "source": [
        "#This one takes a WHILE to run\n",
        "random_search = RandomizedSearchCV(xgb1,\n",
        "                                   param_distributions=params,\n",
        "                                   n_jobs = -1,\n",
        "                                   verbose=1,\n",
        "                                   random_state=SEED)\n",
        "random_search.fit(X_train, y_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 5 folds for each of 10 candidates, totalling 50 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 2 concurrent workers.\n",
            "[Parallel(n_jobs=-1)]: Done  46 tasks      | elapsed:  4.2min\n",
            "[Parallel(n_jobs=-1)]: Done  50 out of  50 | elapsed:  4.5min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomizedSearchCV(cv=None, error_score=nan,\n",
              "                   estimator=XGBRegressor(base_score=0.5, booster='gbtree',\n",
              "                                          colsample_bylevel=1,\n",
              "                                          colsample_bynode=1,\n",
              "                                          colsample_bytree=1, gamma=0,\n",
              "                                          importance_type='gain',\n",
              "                                          learning_rate=0.02, max_delta_step=0,\n",
              "                                          max_depth=3, min_child_weight=1,\n",
              "                                          missing=None, n_estimators=800,\n",
              "                                          n_jobs=1, nthread=1,\n",
              "                                          objective='reg:linear',\n",
              "                                          random_state=0, reg_alpha=0,\n",
              "                                          reg_lambda=1, scale_pos_weight=1,\n",
              "                                          seed=None, silent=True, subsample=1,\n",
              "                                          verbosity=1),\n",
              "                   iid='deprecated', n_iter=10, n_jobs=-1,\n",
              "                   param_distributions={'colsample_bytree': [0.6, 0.8, 1.0],\n",
              "                                        'gamma': [0, 0.5, 1],\n",
              "                                        'max_depth': [2, 4, 6],\n",
              "                                        'min_child_weight': [1, 5, 10]},\n",
              "                   pre_dispatch='2*n_jobs', random_state=123, refit=True,\n",
              "                   return_train_score=False, scoring=None, verbose=1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HwyLo_mZuQ-S",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "outputId": "f2321b0a-4673-43ca-de30-73a6c0204996"
      },
      "source": [
        "best_xgb = random_search.best_estimator_\n",
        "eval_sets = [(X_train, y_train), (X_val, y_val)]\n",
        "best_xgb.fit(X_train, y_train,\n",
        "             eval_metric='mae',\n",
        "             eval_set=eval_sets,\n",
        "             verbose = False)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
              "             colsample_bynode=1, colsample_bytree=0.6, gamma=1,\n",
              "             importance_type='gain', learning_rate=0.02, max_delta_step=0,\n",
              "             max_depth=6, min_child_weight=1, missing=None, n_estimators=800,\n",
              "             n_jobs=1, nthread=1, objective='reg:linear', random_state=0,\n",
              "             reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,\n",
              "             silent=True, subsample=1, verbosity=1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iOe1yTq9ullF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9f591b79-4531-426f-8248-98f1cf7613a4"
      },
      "source": [
        "baseline_abserr = np.mean( np.abs(y_val - y_train.mean()) )\n",
        "baseline_abserr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.3795885236744205"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AiVJBZdKxaAK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 730
        },
        "outputId": "a07da89f-03b5-4420-dc01-06d3c71c53e4"
      },
      "source": [
        "#Thanks to https://setscholars.net/wp-content/uploads/2019/02/visualise-XgBoost-model-with-learning-curves-in-Python.html\n",
        "\n",
        "results = best_xgb.evals_result()\n",
        "epochs = len(results['validation_0']['mae']) \n",
        "x_axis = range(0, epochs)\n",
        "\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(12,12))\n",
        "ax.plot(x_axis, results['validation_0']['mae'], label='Training')\n",
        "ax.plot(x_axis, results['validation_1']['mae'], label='Validation')\n",
        "\n",
        "plt.hlines(baseline_abserr, 0, 800, colors='black', linestyles='dotted', label='Baseline')    \n",
        "ax.legend()\n",
        "    \n",
        "plt.ylabel('Mean Absolute Error')\n",
        "plt.xlabel('Iterations M')\n",
        "plt.title('Training and Validation Absolute Error')\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x864 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3urGBPpHzERV",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 605
        },
        "outputId": "238f06bf-f5b9-45b2-f450-732e729c7646"
      },
      "source": [
        "feat = best_xgb.feature_importances_\n",
        "names = sklearn_housing['feature_names'][1:]\n",
        "\n",
        "\n",
        "feat, names = zip(*sorted(zip(feat, names)))\n",
        "plt.figure(figsize=(10,10))\n",
        "plt.barh( names, feat)\n",
        "plt.xlabel('Relative Importance')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sU_x5YDh8qih"
      },
      "source": [
        "##Second Dataset: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M0zmcAVi8p-f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        },
        "outputId": "7ef74fc6-5f5a-419a-9180-24c53dadef88"
      },
      "source": [
        "#in this dataset, we want to try to predict the critical temperature of\n",
        "#a potential superconducter, using a variety of material properties relating\n",
        "#to mass, size, conductivity, entropy, thermal properties etc...\n",
        "\n",
        "df_super = pd.read_csv('train.csv')\n",
        "\n",
        "#The dataset has 81 features, the first time we trained the model it took over half an hour\n",
        "#and most of the variables were completely insignificant with a relative importance near 0.\n",
        "#So here we preselected the 10 variables with the highest relative importance.\n",
        "df_super = df_super[['range_ThermalConductivity', 'range_atomic_radius', 'wtd_std_ThermalConductivity',\n",
        "                  'wtd_gmean_ThermalConductivity', 'wtd_std_ElectronAffinity','std_atomic_mass',\n",
        "                  'wtd_range_ElectronAffinity', 'std_Density', 'gmean_ElectronAffinity','wtd_mean_Valence'\n",
        "                  ,'critical_temp']]\n",
        "\n",
        "super = df_super.to_numpy()\n",
        "df_super.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>range_ThermalConductivity</th>\n",
              "      <th>range_atomic_radius</th>\n",
              "      <th>wtd_std_ThermalConductivity</th>\n",
              "      <th>wtd_gmean_ThermalConductivity</th>\n",
              "      <th>wtd_std_ElectronAffinity</th>\n",
              "      <th>std_atomic_mass</th>\n",
              "      <th>wtd_range_ElectronAffinity</th>\n",
              "      <th>std_Density</th>\n",
              "      <th>gmean_ElectronAffinity</th>\n",
              "      <th>wtd_mean_Valence</th>\n",
              "      <th>critical_temp</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>399.97342</td>\n",
              "      <td>205</td>\n",
              "      <td>138.517163</td>\n",
              "      <td>0.621979</td>\n",
              "      <td>42.558396</td>\n",
              "      <td>51.968828</td>\n",
              "      <td>80.987143</td>\n",
              "      <td>3306.162897</td>\n",
              "      <td>60.123179</td>\n",
              "      <td>2.257143</td>\n",
              "      <td>29.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>429.97342</td>\n",
              "      <td>205</td>\n",
              "      <td>139.630922</td>\n",
              "      <td>0.619735</td>\n",
              "      <td>41.667621</td>\n",
              "      <td>47.094633</td>\n",
              "      <td>81.207857</td>\n",
              "      <td>3767.403176</td>\n",
              "      <td>69.833315</td>\n",
              "      <td>2.257143</td>\n",
              "      <td>26.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>399.97342</td>\n",
              "      <td>205</td>\n",
              "      <td>138.540613</td>\n",
              "      <td>0.619095</td>\n",
              "      <td>41.639878</td>\n",
              "      <td>51.968828</td>\n",
              "      <td>81.207857</td>\n",
              "      <td>3306.162897</td>\n",
              "      <td>60.123179</td>\n",
              "      <td>2.271429</td>\n",
              "      <td>19.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>399.97342</td>\n",
              "      <td>205</td>\n",
              "      <td>138.528893</td>\n",
              "      <td>0.620535</td>\n",
              "      <td>42.102344</td>\n",
              "      <td>51.968828</td>\n",
              "      <td>81.097500</td>\n",
              "      <td>3306.162897</td>\n",
              "      <td>60.123179</td>\n",
              "      <td>2.264286</td>\n",
              "      <td>22.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>399.97342</td>\n",
              "      <td>205</td>\n",
              "      <td>138.493671</td>\n",
              "      <td>0.624878</td>\n",
              "      <td>43.452059</td>\n",
              "      <td>51.968828</td>\n",
              "      <td>80.766429</td>\n",
              "      <td>3306.162897</td>\n",
              "      <td>60.123179</td>\n",
              "      <td>2.242857</td>\n",
              "      <td>23.0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   range_ThermalConductivity  ...  critical_temp\n",
              "0                  399.97342  ...           29.0\n",
              "1                  429.97342  ...           26.0\n",
              "2                  399.97342  ...           19.0\n",
              "3                  399.97342  ...           22.0\n",
              "4                  399.97342  ...           23.0\n",
              "\n",
              "[5 rows x 11 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jYe6nM5_1hhz",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "outputId": "f7223616-1c28-47f6-f3da-7cf9ca5bfdc1"
      },
      "source": [
        "#Critical Temperature is in the last column of the dataset\n",
        "split_data = train_val_test_split(super[:,:-1],\n",
        "                                  super[:,-1],\n",
        "                                  PERCENT_TEST,\n",
        "                                  PERCENT_VAL,\n",
        "                                  random_state)\n",
        "#unpacking\n",
        "X_train, X_val, X_test, y_train, y_val, y_test = split_data\n",
        "\n",
        "#printing sizes to check\n",
        "print('Input length:', len(super))\n",
        "print('Number of training samples:', len(X_train))\n",
        "print('Number of validation samples:', len(X_val))\n",
        "print('Number of testing samples:', len(X_test))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Input length: 21263\n",
            "Number of training samples: 17031\n",
            "Number of validation samples: 2105\n",
            "Number of testing samples: 2127\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jpIGGM5T3lAm",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 478
        },
        "outputId": "2a14d170-cc73-4203-ea59-b5762e0b6b61"
      },
      "source": [
        "random_search.fit(X_train, y_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 5 folds for each of 10 candidates, totalling 50 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 2 concurrent workers.\n",
            "[Parallel(n_jobs=-1)]: Done  46 tasks      | elapsed:  5.2min\n",
            "[Parallel(n_jobs=-1)]: Done  50 out of  50 | elapsed:  5.6min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomizedSearchCV(cv=None, error_score=nan,\n",
              "                   estimator=XGBRegressor(base_score=0.5, booster='gbtree',\n",
              "                                          colsample_bylevel=1,\n",
              "                                          colsample_bynode=1,\n",
              "                                          colsample_bytree=1, gamma=0,\n",
              "                                          importance_type='gain',\n",
              "                                          learning_rate=0.02, max_delta_step=0,\n",
              "                                          max_depth=3, min_child_weight=1,\n",
              "                                          missing=None, n_estimators=800,\n",
              "                                          n_jobs=1, nthread=1,\n",
              "                                          objective='reg:linear',\n",
              "                                          random_state=0, reg_alpha=0,\n",
              "                                          reg_lambda=1, scale_pos_weight=1,\n",
              "                                          seed=None, silent=True, subsample=1,\n",
              "                                          verbosity=1),\n",
              "                   iid='deprecated', n_iter=10, n_jobs=-1,\n",
              "                   param_distributions={'colsample_bytree': [0.6, 0.8, 1.0],\n",
              "                                        'gamma': [0, 0.5, 1],\n",
              "                                        'max_depth': [2, 4, 6],\n",
              "                                        'min_child_weight': [1, 5, 10]},\n",
              "                   pre_dispatch='2*n_jobs', random_state=123, refit=True,\n",
              "                   return_train_score=False, scoring=None, verbose=1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NjhXmnCe3pX1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "outputId": "36eaf8d6-2782-44a3-a5cb-93035c679673"
      },
      "source": [
        "best_xgb = random_search.best_estimator_\n",
        "eval_sets = [(X_train, y_train), (X_val, y_val)]\n",
        "best_xgb.fit(X_train, y_train,\n",
        "             eval_metric='mae',\n",
        "             eval_set=eval_sets,\n",
        "             verbose = False)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
              "             colsample_bynode=1, colsample_bytree=0.6, gamma=1,\n",
              "             importance_type='gain', learning_rate=0.02, max_delta_step=0,\n",
              "             max_depth=6, min_child_weight=1, missing=None, n_estimators=800,\n",
              "             n_jobs=1, nthread=1, objective='reg:linear', random_state=0,\n",
              "             reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,\n",
              "             silent=True, subsample=1, verbosity=1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LBKc2MnH3uKY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b886e3f6-cf27-4d92-e8a2-8496ac387048"
      },
      "source": [
        "baseline_abserr = np.mean( np.abs(y_val - y_train.mean()) )\n",
        "baseline_abserr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "29.792239293312555"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m-byZxTt3vMC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 730
        },
        "outputId": "eeee333e-1b7e-4f35-ddab-28c3577767e5"
      },
      "source": [
        "results = best_xgb.evals_result()\n",
        "epochs = len(results['validation_0']['mae']) \n",
        "x_axis = range(0, epochs)\n",
        "\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(12,12))\n",
        "ax.plot(x_axis, results['validation_0']['mae'], label='Training')\n",
        "ax.plot(x_axis, results['validation_1']['mae'], label='Validation')\n",
        "\n",
        "plt.hlines(baseline_abserr, 0, 800, colors='b', linestyles='dotted', label='Baseline')    \n",
        "ax.legend()\n",
        "\n",
        "plt.ylabel('Mean Absolute Error')\n",
        "plt.xlabel('Iterations M')\n",
        "plt.title('Training and Validation Absolute Error')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x864 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vanlbsvk32xq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 884
        },
        "outputId": "a5fa373c-4106-4a07-d83b-7880aed68c00"
      },
      "source": [
        "feat = best_xgb.feature_importances_\n",
        "names = list(df_super.columns)\n",
        "\n",
        "feat, names = zip(*sorted(zip(feat, names)))\n",
        "plt.figure(figsize=(20,20))\n",
        "plt.barh( names, feat)\n",
        "plt.xlabel('Relative Importance')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x1440 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yIIcSRZwRpu9"
      },
      "source": [
        "The first time we ran this on the entire dataset (with 81 features), the randomized search (grid search alternative) took over half an hour to run. In the end, the vast majority of features were completely irrelevant (some didn't even get splits in the tree) so we decided to take only the ten most important features to make future testing easier, and to improve the overall model."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CbjgK67Q8ypI"
      },
      "source": [
        "##Stretch Goals"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-IbWvh2-MpaY"
      },
      "source": [
        "import statistics as stat"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1JuTpH6p_Pnf"
      },
      "source": [
        "#Thanks to https://machinelearningmastery.com/implement-decision-tree-algorithm-scratch-python/\n",
        "def gini_index(groups, classes):\n",
        "\t# count all samples at split point\n",
        "\tn_instances = float(sum([len(group) for group in groups]))\n",
        "\t# sum weighted Gini index for each group\n",
        "\tgini = 0.0\n",
        "\tfor group in groups:\n",
        "\t\tsize = float(len(group))\n",
        "\t\t# avoid divide by zero\n",
        "\t\tif size == 0:\n",
        "\t\t\tcontinue\n",
        "\t\tscore = 0.0\n",
        "\t\t# score the group based on the score for each class\n",
        "\t\tfor class_val in classes:\n",
        "\t\t\tp = [row[-1] for row in group].count(class_val) / size\n",
        "\t\t\tscore += p * p\n",
        "\t\t# weight the group score by its relative size\n",
        "\t\tgini += (1.0 - score) * (size / n_instances)\n",
        "\treturn gini\n",
        "\n",
        "class tree():\n",
        "  def __init__(self, loss, max_depth, isreg  = True):\n",
        "    self.loss = loss\n",
        "    self.max_depth = max_depth\n",
        "    self.root = None\n",
        "    self.reg = isreg\n",
        "\n",
        "  # Split a dataset based on an attribute and an attribute value\n",
        "  def test_split(self, index, value, dataset):\n",
        "    left, right = list(), list()\n",
        "    for row in dataset:\n",
        "      if row[index] < value:\n",
        "        left.append(row)\n",
        "      else:\n",
        "        right.append(row)\n",
        "    return left, right\n",
        "\n",
        "  # Select the best split point for a dataset\n",
        "  def get_split(self, dataset):\n",
        "    class_values = list(set(row[-1] for row in dataset))\n",
        "    b_index, b_value, b_score, b_groups = 999, 999, 999, None\n",
        "    for index in range(len(dataset[0])-1):\n",
        "      for row in dataset:\n",
        "        groups = self.test_split(index, row[index], dataset)\n",
        "        score = self.loss(groups, class_values)\n",
        "        if score < b_score:\n",
        "          b_index, b_value, b_score, b_groups = index, row[index], score, groups\n",
        "    return {'index':b_index, 'value':b_value, 'groups':b_groups}\n",
        "\n",
        "  # Create a terminal node value\n",
        "  def to_terminal(self, group):\n",
        "    outcomes = [row[-1] for row in group]\n",
        "    if self.reg:\n",
        "      return sum(outcomes)/len(outcomes)\n",
        "    else:\n",
        "      return stat.mode(outcomes)\n",
        "\n",
        "  # Create child splits for a node or make terminal\n",
        "  def split(self, node, depth):\n",
        "    left, right = node['groups']\n",
        "    del(node['groups'])\n",
        "    # check for a no split\n",
        "    if not left or not right:\n",
        "      node['left'] = node['right'] = self.to_terminal(left + right)\n",
        "      return\n",
        "    # check for max depth\n",
        "    if depth >= self.max_depth:\n",
        "      node['left'], node['right'] = self.to_terminal(left), self.to_terminal(right)\n",
        "      return\n",
        "\n",
        "    node['left'] = self.get_split(left)\n",
        "    self.split(node['left'],  depth+1)\n",
        "    node['right'] = self.get_split(right)\n",
        "    self.split(node['right'], depth+1)\n",
        "    return \n",
        "\n",
        "\n",
        "  # Fit the data\n",
        "  def fit(self, X,y):\n",
        "    #numpy to formatted input\n",
        "    data = np.concatenate((X,y.reshape(-1,1)), axis = 1).tolist()   \n",
        "\n",
        "    self.root = self.get_split(data)\n",
        "    self.split(self.root, 1)\n",
        "    return self.root\n",
        "\n",
        "  # Make a prediction with a decision tree\n",
        "  def predict(self, X):\n",
        "    def predict_(node, X):\n",
        "        if row[node['index']] < node['value']:\n",
        "          if isinstance(node['left'], dict):\n",
        "            return (predict_(node['left'], row))\n",
        "          else:\n",
        "            return node['left']\n",
        "        else:\n",
        "          if isinstance(node['right'], dict):\n",
        "            return (predict_(node['right'], row))\n",
        "          else:\n",
        "            return node['right']\n",
        "    data = X.tolist()   \n",
        "    pred = []\n",
        "    for row in data:\n",
        "      pred.append(predict_(self.root, row))\n",
        "    return pred\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3EzJ74w-0AHo",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 212
        },
        "outputId": "93fdd470-bf64-4b3e-dadd-874b38c0e859"
      },
      "source": [
        "!wget -O iris.data https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2020-10-22 05:46:27--  https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data\n",
            "Resolving archive.ics.uci.edu (archive.ics.uci.edu)... 128.195.10.252\n",
            "Connecting to archive.ics.uci.edu (archive.ics.uci.edu)|128.195.10.252|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 4551 (4.4K) [application/x-httpd-php]\n",
            "Saving to: ‘iris.data’\n",
            "\n",
            "iris.data           100%[===================>]   4.44K  --.-KB/s    in 0s      \n",
            "\n",
            "2020-10-22 05:46:28 (84.1 MB/s) - ‘iris.data’ saved [4551/4551]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eF4Noqb40ED6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 306
        },
        "outputId": "0a71b9b0-373f-46cc-820d-a9370f96e372"
      },
      "source": [
        "#reading the data into a numpy array of floats\n",
        "header = ['sepal length','sepal width', 'petal length', 'petal width', 'classes']\n",
        "\n",
        "iris_df = pd.read_csv('iris.data', names = header)\n",
        "#text to numerical\n",
        "\n",
        "class_labels = iris_df.classes.unique()\n",
        "for i, label in enumerate(class_labels):\n",
        "  iris_df.classes[iris_df.classes == label] = i\n",
        "\n",
        "iris = iris_df.to_numpy().astype('float')\n",
        "iris_df.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:9: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  if __name__ == '__main__':\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>sepal length</th>\n",
              "      <th>sepal width</th>\n",
              "      <th>petal length</th>\n",
              "      <th>petal width</th>\n",
              "      <th>classes</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>5.1</td>\n",
              "      <td>3.5</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>4.9</td>\n",
              "      <td>3.0</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>4.7</td>\n",
              "      <td>3.2</td>\n",
              "      <td>1.3</td>\n",
              "      <td>0.2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>4.6</td>\n",
              "      <td>3.1</td>\n",
              "      <td>1.5</td>\n",
              "      <td>0.2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>5.0</td>\n",
              "      <td>3.6</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   sepal length  sepal width  petal length  petal width classes\n",
              "0           5.1          3.5           1.4          0.2       0\n",
              "1           4.9          3.0           1.4          0.2       0\n",
              "2           4.7          3.2           1.3          0.2       0\n",
              "3           4.6          3.1           1.5          0.2       0\n",
              "4           5.0          3.6           1.4          0.2       0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lm5iZHji0RXn"
      },
      "source": [
        "X = iris[:,:-1]\n",
        "y = iris[:,-1]\n",
        "t = tree(gini_index, 5)\n",
        "tree = t.fit(X,y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5l0qFDM_1GGb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7bb8b545-9f3d-459d-ae16-17b37e373c0b"
      },
      "source": [
        "np.mean((np.round(t.predict(X))-y) != 0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.02666666666666667"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4I9WkbXj18PH"
      },
      "source": [
        "Classification error rate is 2.6% for a max depth of 3, 0.6% for a depth of 4, and goes to 0% for 5 and above."
      ]
    }
  ]
}