Interactive_Decision_Tree.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"https://github.com/GeostatsGuy/GeostatsPy/blob/master/TCG_color_logo.png?raw=true\" width=\"220\" height=\"240\" />\n",
    "\n",
    "</p>\n",
    "\n",
    "## Interactive Decision Tree from Predictive Machine Learning\n",
    "\n",
    "\n",
    "### Michael Pyrcz, Professor, University of Texas at Austin \n",
    "\n",
    "##### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)\n",
    "\n",
    "\n",
    "### The Interactive Workflow\n",
    "\n",
    "Here's a simple workflow, demonstration of decision trees for subsurface modeling workflows. This should help you get started with building subsurface models that data analytics and machine learning. \n",
    "\n",
    "* I have a lecture on [Decision Trees](https://youtu.be/JUGo1Pu3QT4) as part of my [Machine Learning](https://www.youtube.com/playlist?list=PLG19vXLQHvSC2ZKFIkgVpI9fCjkN38kwf) course. Note, all recorded lectures, interactive and well-documented workflow demononstrations are available on my GitHub repository [GeostatsGuy's Python Numerical Demos](https://github.com/GeostatsGuy/PythonNumericalDemos).\n",
    "\n",
    "* Here's some basic details about predictive machine learning decision tree models. \n",
    "\n",
    "### Decision Tree\n",
    "\n",
    "Machine learning method for supervised learning for classification and regression analysis.  Here are some key aspects of support vector machines.\n",
    "\n",
    "**Prediction**\n",
    "\n",
    "* estimate a function $\\hat{f}$ such that we predict a response feature $Y$ from a set of predictor features $X_1,\\ldots,X_m$. \n",
    "\n",
    "* the prediction is of the form $\\hat{Y} = \\hat{f}(X_1,\\ldots,X_m)$ \n",
    "\n",
    "**Suppervised Learning**\n",
    "\n",
    "* the response feature label, $Y$, is available over the training and testing data\n",
    "    \n",
    "**Hiearchical, Binary Segmentation of the Feature Space**\n",
    "\n",
    "The fundamental idea is to divide the predictor space, $𝑋_1,\\ldots,X_m$, into $J$ mutually exclusive, exhaustive regions\n",
    "\n",
    "* **mutually exclusive** – any combination of predictors only belongs to a single region, $R_j$\n",
    "\n",
    "* **exhaustive** – all combinations of predictors belong a region, $R_j$, regions cover entire feature space (range of the variables being considered)\n",
    "\n",
    "For every observation in a region, $R_j$, we use the same prediction, $\\hat{Y}(R_j)$    \n",
    "\n",
    "For example predict production, $\\hat{Y}$, from porosity, ${X_1}$\n",
    "\n",
    "* given the data within a mD feature space, $X_1,\\ldots,X_m$, find that boundary maximizes the gap between the two categories\n",
    "\n",
    "* new cases are classified based on where they fall relative to this boundary \n",
    "\n",
    "**Compact, Interpretable Model**\n",
    "\n",
    "Since the classification is based on a hierarchy of binary segmentations of the feature space (one feature at a time) the the model can be specified in a intuitive manner as a:\n",
    "\n",
    "* **tree with binary branches**, hence the name decision tree\n",
    "\n",
    "* **set of nested if statements**, for example:\n",
    "\n",
    "```python\n",
    "if porosity > 0.15:\n",
    "    if brittleness < 20:\n",
    "        initial_production = 1000\n",
    "    else:\n",
    "        initial_production = 7000\n",
    "else:\n",
    "    if brittleness < 40:\n",
    "        initial_production = 500\n",
    "    else:\n",
    "        initial_production = 3000\n",
    "```\n",
    "\n",
    "* **predicts with the average of training response features** in each region $\\hat{Y}(R_j)$.   \n",
    "\n",
    "**Proceedure for Tree Construction**\n",
    "\n",
    "The tree is constructed from the top down.  We begin with a sigle region that covers the entire feature space and then proceed with a sequence of splits.\n",
    "\n",
    "* **Scan All Possible Splits** over all regions and over all features.\n",
    "\n",
    "* **Greedy Optimization**  The method proceeds by finding the first segmentation (split) in any feature that minimizes the residual sum of squares of errors over all the training data $y_i$ over all of the regions $j = 1,\\ldots,J$.\n",
    "\n",
    "\\begin{equation}\n",
    "RSS = \\sum^{J}_{j=1} \\sum_{i \\in R_j} (y_i - \\hat{y}_{R_j})^2\n",
    "\\end{equation}\n",
    "\n",
    "* **Stopping Criteria** is typically based on minimum number of training data in each region for a robust estimation and / or minimum reduction in RSS for the next split \n",
    "\n",
    "##### Applications to Subsurface Modeling\n",
    "\n",
    "To provide a wide variety of spatiotemporal  \n",
    "\n",
    "* we work with just 2 predictor features for the example below for easy visualization\n",
    "\n",
    "* flexibility through selection of kernel (hyperparameter) and associated kernel and cost parameters \n",
    "\n",
    "\n",
    "##### Why Cover Decision Trees?\n",
    "\n",
    "They are not the most powerful, cutting edge method in machine learning\n",
    "\n",
    "* but they are likely the most understandable, interpretable  \n",
    "\n",
    "* decision trees are expanded with random forests, bagging and boosting to be cutting edge  \n",
    "\n",
    "\n",
    "#### Getting Started\n",
    "\n",
    "Here's the steps to get setup in Python with the GeostatsPy package:\n",
    "\n",
    "1. Install Anaconda 3 on your machine (https://www.anaconda.com/download/). \n",
    "2. From Anaconda Navigator (within Anaconda3 group), go to the environment tab, click on base (root) green arrow and open a terminal. \n",
    "3. In the terminal type: pip install geostatspy. \n",
    "4. Open Jupyter and in the top block get started by copy and pasting the code block below from this Jupyter Notebook to start using the geostatspy functionality. \n",
    "\n",
    "You may want to copy the data file to your working directory. They are available here:\n",
    "\n",
    "* Tabular data - unconv_MV.csv at https://git.io/fjmBH.\n",
    "\n",
    "or you can use the code below to load the data directly from my GitHub [GeoDataSets](https://github.com/GeostatsGuy/GeoDataSets) repository.\n",
    "\n",
    "#### Install Packages\n",
    "\n",
    "We will include the standard packages for DataFrames and ndarrays and add sci-kit-learn (sklearn) for machine learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "supress_warnings = False\n",
    "import os                                               # to set current working directory \n",
    "import sys                                              # supress output to screen for interactive variogram modeling\n",
    "import numpy as np                                      # arrays and matrix math\n",
    "import pandas as pd                                     # DataFrames\n",
    "import matplotlib.pyplot as plt                         # plotting\n",
    "from sklearn.model_selection import train_test_split    # train and test split\n",
    "from sklearn import tree                                # tree program from scikit learn (package for machine learning)\n",
    "from sklearn import metrics                             # measures to check our models\n",
    "from matplotlib.patches import Rectangle                # build a custom legend\n",
    "from matplotlib.ticker import (MultipleLocator, AutoMinorLocator) # control of axes ticks\n",
    "import math                                             # sqrt operator\n",
    "from ipywidgets import interactive                      # widgets and interactivity\n",
    "from ipywidgets import widgets                            \n",
    "from ipywidgets import Layout\n",
    "from ipywidgets import Label\n",
    "from ipywidgets import VBox, HBox\n",
    "cmap = plt.cm.inferno                                   # default color bar, no bias and friendly for color vision defeciency\n",
    "plt.rc('axes', axisbelow=True)                          # grid behind plotting elements\n",
    "if supress_warnings == True:\n",
    "    import warnings                                     # supress any warnings for this demonstration\n",
    "    warnings.filterwarnings('ignore')                       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you get a package import error, you may have to first install some of these packages. This can usually be accomplished by opening up a command window on Windows and then typing 'python -m pip install [package-name]'. More assistance is available with the respective package docs.  \n",
    "\n",
    "#### Declare Functions\n",
    "\n",
    "These are functions that I wrote (with one exception) to diagnose and visualize decision tree models.\n",
    "\n",
    "* **extract_rules** - recursive function to get the rules for each devision tree region as a set of conditional statements. Note there is some repeat. I found this on Stack Overflow (I think paulkernfeld was the author).\n",
    "\n",
    "* **plot_decision_tree_regions** - inspired by rstats' tree package, this function takes the extract_rules output to add the tree prediction regions to a plot. Note, only works with 2 predictor features.\n",
    "\n",
    "* **visualize_tree_model** - plot the data in feature space and a grid of the tree predictions. Note, only works for 2 predictor features.\n",
    "\n",
    "* **check_tree_model** - cross validation plot with prediction vs. true for testing and training data. Shows the region values and conditional statistics for the true values in each region (P10, mean and P90)\n",
    "\n",
    "* **tree_tuning** - vary the tree complexity via the number of regions (a.k.a. max_leaf_nodes) hyperparameter and plot the mean square error (MSE) training and testing along with the currently displayed model to visually hyperparameter tune.\n",
    "\n",
    "I'm stoked about these functions. They provide a great improvement in diagnosing and visualizing decision tree models in predictive machine learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_rules(tree_model, feature_names):           # recursive method to extract rules, from paulkernfeld Stack Overflow (?)\n",
    "    rules = []\n",
    "    def traverse(node, depth, prev_rule):\n",
    "        if tree_model.tree_.children_left[node] == -1:  # Leaf node\n",
    "            class_label = np.argmax(tree_model.tree_.value[node])\n",
    "            rule = f\"{prev_rule} => Class {class_label}\"\n",
    "            rules.append(rule)\n",
    "        else:  # Split node\n",
    "            feature = feature_names[tree_model.tree_.feature[node]]\n",
    "            threshold = tree_model.tree_.threshold[node]\n",
    "            left_child = tree_model.tree_.children_left[node]\n",
    "            right_child = tree_model.tree_.children_right[node]\n",
    "\n",
    "            # Recursively traverse left and right subtrees\n",
    "            traverse(left_child, depth + 1, f\"{prev_rule} & {feature} <= {threshold}\")\n",
    "            traverse(right_child, depth + 1, f\"{prev_rule} & {feature} > {threshold}\")\n",
    "    traverse(0, 0, \"Root\")\n",
    "    return rules\n",
    "\n",
    "def plot_decision_tree_regions(tree_model, feature_names,X_min,X_max):\n",
    "    rules = extract_rules(tree_model, feature_names)\n",
    "    for irule, ____ in enumerate(rules):\n",
    "        rule = rules[irule].split()[2:]\n",
    "        X_min = Xmin[0]; X_max = Xmax[0]; Y_min = Xmin[1]; Y_max = Xmax[1];\n",
    "        index = [i for i,val in enumerate(rule) if val==feature_names[0]]\n",
    "        for i in index:\n",
    "            if rule[i+1] == '<=':\n",
    "                X_max = min(float(rule[i+2]),X_max)\n",
    "            else:\n",
    "                X_min = max(float(rule[i+2]),X_min)\n",
    "        index = [i for i,val in enumerate(rule) if val==feature_names[1]]\n",
    "        for i in index:\n",
    "            if rule[i+1] == '<=':\n",
    "                Y_max = min(float(rule[i+2]),Y_max)\n",
    "            else:\n",
    "                Y_min = max(float(rule[i+2]),Y_min) \n",
    "        plt.gca().add_patch(plt.Rectangle((X_min,Y_min),X_max-X_min,Y_max-Y_min, lw=2,ec='black',fc=\"none\"))\n",
    "        cx = (X_min + X_max)*0.5; cy = (Y_min + Y_max)*0.5; loc = np.array((cx,cy)).reshape(1, -1)\n",
    "        plt.annotate(text = str(np.round(tree_model.predict(loc)[0],2)),xy=(cx,cy),ha='center',weight='bold',c='white',zorder=100)\n",
    "\n",
    "def visualize_tree_model(model,X1_train,X1_test,X2_train,X2_test,Xmin,Xmax,y_train,y_test,ymin,ymax,title,Xname,yname,Xlabel,ylabel):# plots the data points and the decision tree prediction \n",
    "    cmap = plt.cm.inferno\n",
    "    X1plot_step = (Xmax[0] - Xmin[0])/300.0; X2plot_step = -1*(Xmax[1] - Xmin[1])/300.0 # resolution of the model visualization\n",
    "    XX1, XX2 = np.meshgrid(np.arange(Xmin[0], Xmax[0], X1plot_step), # set up the mesh\n",
    "                     np.arange(Xmax[1], Xmin[1], X2plot_step))\n",
    "    y_hat = model.predict(np.c_[XX1.ravel(), XX2.ravel()]) # predict with our trained model over the mesh\n",
    "    y_hat = y_hat.reshape(XX1.shape)\n",
    "\n",
    "    plt.imshow(y_hat,interpolation=None, aspect=\"auto\", extent=[Xmin[0],Xmax[0],Xmin[1],Xmax[1]], \n",
    "        vmin=ymin,vmax=ymax,alpha = 0.2,cmap=cmap,zorder=1)\n",
    "    sp = plt.scatter(X1_train,X2_train,s=None, c=y_train, marker='o', cmap=cmap, \n",
    "        norm=None, vmin=ymin, vmax=ymax, alpha=0.6, linewidths=0.3, edgecolors=\"black\", label = 'Train',zorder=10)\n",
    "    plt.scatter(X1_test,X2_test,s=None, c=y_test, marker='s', cmap=cmap, \n",
    "        norm=None, vmin=ymin, vmax=ymax, alpha=0.3, linewidths=0.3, edgecolors=\"black\", label = 'Test',zorder=10)\n",
    "\n",
    "    plot_decision_tree_regions(model,Xname,Xmin,Xmax)\n",
    "    plt.title(title); plt.xlabel(Xlabel[0]); plt.ylabel(Xlabel[1])\n",
    "    plt.xlim([Xmin[0],Xmax[0]]); plt.ylim([Xmin[1],Xmax[1]])\n",
    "    cbar = plt.colorbar(sp, orientation = 'vertical')   # add the color bar\n",
    "    cbar.set_label(ylabel, rotation=270, labelpad=20)\n",
    "    return y_hat\n",
    "\n",
    "def check_tree_model(model,X1_train,X1_test,X2_train,X2_test,Xmin,Xmax,y_train,y_test,ymin,ymax,title):    # plots the estimated vs. the actual  \n",
    "    y_hat_train = model.predict(np.c_[X1_train,X2_train]); y_hat_test = model.predict(np.c_[X1_test,X2_test])\n",
    "\n",
    "    df_cross = pd.DataFrame(np.c_[y_test,y_hat_test],columns=['y_test','y_hat_test'])\n",
    "    df_cross_train = pd.DataFrame(np.c_[y_train,y_hat_train],columns=['y_train','y_hat_train'])\n",
    "\n",
    "    plt.scatter(y_train,y_hat_train,s=15, c='blue',marker='o', cmap=None, norm=None, vmin=None, vmax=None, alpha=0.7, \n",
    "                linewidths=0.3, edgecolors=\"black\",label='Train',zorder=10)\n",
    "    plt.scatter(y_test,y_hat_test,s=15, c='red',marker='s', cmap=None, norm=None, vmin=None, vmax=None, alpha=0.7, \n",
    "                linewidths=0.3, edgecolors=\"black\",label='Test',zorder=10)\n",
    "\n",
    "    unique_y_hat_all = set(np.concatenate([y_hat_test,y_hat_train]))\n",
    "    for y_hat in unique_y_hat_all:\n",
    "        plt.plot([ymin,ymax],[y_hat,y_hat],c='black',alpha=0.2,ls='--',zorder=1)\n",
    "        \n",
    "    unique_y_hat_test = set(y_hat_test)\n",
    "    for y_hat in unique_y_hat_test:\n",
    "        #plt.plot([ymin,ymax],[y_hat,y_hat],c='black',alpha=0.3,ls='--',zorder=1)\n",
    "        cond_mean_y_hat = df_cross.loc[df_cross['y_hat_test'] == y_hat, 'y_test'].mean()\n",
    "        cond_P75_y_hat = df_cross.loc[df_cross['y_hat_test'] == y_hat, 'y_test'].quantile(0.75)\n",
    "        cond_P25_y_hat = df_cross.loc[df_cross['y_hat_test'] == y_hat, 'y_test'].quantile(0.25)\n",
    "        plt.scatter(cond_mean_y_hat,y_hat-0.02*(ymax-ymin),color='red',edgecolor='black',s=60,marker='^',zorder=100)\n",
    "        plt.plot([cond_P25_y_hat,cond_P75_y_hat],[y_hat-0.025*(ymax-ymin),y_hat-0.025*(ymax-ymin)],c='black',lw=0.7)\n",
    "        plt.plot([cond_P25_y_hat,cond_P25_y_hat],[y_hat-0.032*(ymax-ymin),y_hat-0.018*(ymax-ymin)],c='black',lw=0.7)\n",
    "        plt.plot([cond_P75_y_hat,cond_P75_y_hat],[y_hat-0.032*(ymax-ymin),y_hat-0.018*(ymax-ymin)],c='black',lw=0.7)\n",
    "        \n",
    "    unique_y_hat_train = set(y_hat_train)\n",
    "    for y_hat in unique_y_hat_train:\n",
    "        #plt.plot([ymin,ymax],[y_hat,y_hat],c='black',alpha=0.3,ls='--',zorder=1)\n",
    "        cond_mean_y_hat = df_cross_train.loc[df_cross_train['y_hat_train'] == y_hat, 'y_train'].mean()\n",
    "        cond_P75_y_hat = df_cross_train.loc[df_cross_train['y_hat_train'] == y_hat, 'y_train'].quantile(0.75)\n",
    "        cond_P25_y_hat = df_cross_train.loc[df_cross_train['y_hat_train'] == y_hat, 'y_train'].quantile(0.25)\n",
    "        plt.scatter(cond_mean_y_hat,y_hat+0.02*(ymax-ymin),color='blue',edgecolor='black',s=60,marker='v',zorder=100)\n",
    "        plt.plot([cond_P25_y_hat,cond_P75_y_hat],[y_hat+0.025*(ymax-ymin),y_hat+0.025*(ymax-ymin)],c='black',lw=0.7)\n",
    "        plt.plot([cond_P25_y_hat,cond_P25_y_hat],[y_hat+0.032*(ymax-ymin),y_hat+0.018*(ymax-ymin)],c='black',lw=0.7)\n",
    "        plt.plot([cond_P75_y_hat,cond_P75_y_hat],[y_hat+0.032*(ymax-ymin),y_hat+0.018*(ymax-ymin)],c='black',lw=0.7)\n",
    "        \n",
    "    plt.title(title); plt.xlabel('Actual Production (MCFPD)'); plt.ylabel('Estimated Production (MCFPD)')\n",
    "    plt.xlim([ymin,ymax]); plt.ylim([ymin,ymax]); plt.legend(loc='upper left')\n",
    "    plt.gca().grid(True, which='major',linewidth = 1.0); plt.gca().grid(True, which='minor',linewidth = 0.2) # add y grids\n",
    "    plt.gca().tick_params(which='major',length=7); plt.gca().tick_params(which='minor', length=4)\n",
    "    plt.gca().xaxis.set_minor_locator(AutoMinorLocator()); plt.gca().yaxis.set_minor_locator(AutoMinorLocator()) # turn on minor ticks\n",
    "\n",
    "    plt.arrow(ymin,ymin,ymax,ymax,width=0.02,color='black',head_length=0.0,head_width=0.0)\n",
    "    MSE_train = metrics.mean_squared_error(y_train,y_hat_train); MSE_test = metrics.mean_squared_error(y_test,y_hat_test)\n",
    "    Var_Explained = metrics.explained_variance_score(y_test,y_hat_test)\n",
    "    cor = math.sqrt(metrics.r2_score(y_test,y_hat_test))\n",
    "    plt.gca().add_patch(plt.Rectangle((ymin+0.6*(ymax-ymin),ymin+0.1*(ymax-ymin)),0.40*(ymax-ymin),0.12*(ymax-ymin),\n",
    "        lw=0.5,ec='black',fc=\"white\",zorder=100))\n",
    "    plt.annotate('MSE Testing: ' + str(np.round(MSE_test,2)),(ymin+0.62*(ymax-ymin),ymin+0.18*(ymax-ymin)),zorder=1000)\n",
    "    plt.annotate('MSE Training: ' + str(np.round(MSE_train,2)),(ymin+0.62*(ymax-ymin),ymin+0.12*(ymax-ymin)),zorder=1000)\n",
    "    \n",
    "def tree_tuning(node_max,cnode,X1_train,X1_test,X2_train,X2_test,Xmin,Xmax,y_train,y_test,ymin,ymax,title,seed):\n",
    "    MSE_test_mat = np.zeros(node_max-1); MSE_train_mat = np.zeros(node_max-1);\n",
    "    \n",
    "    for imax_leaf_node, max_leaf_node in enumerate(range(2,node_max+1)):\n",
    "        np.random.seed(seed = seed)\n",
    "        tree_temp = tree.DecisionTreeRegressor(max_leaf_nodes = max_leaf_node)\n",
    "        tree_temp = tree_temp.fit(X_train.values, y_train.values)\n",
    "        y_hat_train = tree_temp.predict(np.c_[X1_train,X2_train]); y_hat_test = tree_temp.predict(np.c_[X1_test,X2_test])  \n",
    "        MSE_train_mat[imax_leaf_node] = metrics.mean_squared_error(y_train,y_hat_train)\n",
    "        MSE_test_mat[imax_leaf_node] = metrics.mean_squared_error(y_test,y_hat_test)\n",
    "        if max_leaf_node == cnode:\n",
    "            plt.scatter(cnode,MSE_train_mat[imax_leaf_node],color='blue',edgecolor='black',s=20,marker='o',zorder=1000)\n",
    "            plt.scatter(cnode,MSE_test_mat[imax_leaf_node],color='red',edgecolor='black',s=20,marker='o',zorder=1000)\n",
    "    maxcheck = max(np.max(MSE_train_mat),np.max(MSE_test_mat))\n",
    "    \n",
    "    plt.vlines(cnode,0,maxcheck,color='black',ls='--',lw=1,zorder=1) \n",
    "    plt.plot(range(2,node_max+1),MSE_train_mat,color='blue',zorder=100,label='Train')\n",
    "    plt.plot(range(2,node_max+1),MSE_test_mat,color='red',zorder=100,label='Test')\n",
    "    \n",
    "    plt.title(title); plt.xlabel('Maximum Number of Leaf Nodes'); plt.ylabel('Means Square Error')\n",
    "    plt.xlim([0,node_max]); plt.ylim([0,maxcheck]); plt.legend(loc='upper right')\n",
    "    plt.gca().grid(True, which='major',linewidth = 1.0); plt.gca().grid(True, which='minor',linewidth = 0.2) # add y grids\n",
    "    plt.gca().tick_params(which='major',length=7); plt.gca().tick_params(which='minor', length=4)\n",
    "    plt.gca().xaxis.set_minor_locator(AutoMinorLocator()); plt.gca().yaxis.set_minor_locator(AutoMinorLocator()) # turn on minor ticks\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading Data\n",
    "\n",
    "Let's load the provided multivariate, spatial dataset [unconv_MV.csv](https://raw.githubusercontent.com/GeostatsGuy/GeoDataSets/master/unconv_MV.csv) available in my GeoDataSet repo. It is a comma delimited file with: \n",
    "\n",
    "* well index (integer)\n",
    "* porosity (fraction)\n",
    "* permeability ($mD$)\n",
    "* acoustic impedance ($\\frac{kg}{m^3} \\cdot \\frac{m}{s} \\cdot 10^6$). \n",
    "* total organic carbon (%)\n",
    "* vitrinite reflectance (%)\n",
    "* initial gass production (90 day average) (MCFPD)\n",
    "\n",
    "We load it with the pandas 'read_csv' function into a data frame we called 'df' and then preview it to make sure it loaded correctly.\n",
    "\n",
    "**Python Tip: using functions from a package** just type the label for the package that we declared at the beginning:\n",
    "\n",
    "```python\n",
    "import pandas as pd\n",
    "```\n",
    "\n",
    "so we can access the pandas function 'read_csv' with the command: \n",
    "\n",
    "```python\n",
    "pd.read_csv()\n",
    "```\n",
    "\n",
    "but read csv has required input parameters. The essential one is the name of the file. For our circumstance all the other default parameters are fine. If you want to see all the possible parameters for this function, just go to the docs [here](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html).  \n",
    "\n",
    "* The docs are always helpful\n",
    "* There is often a lot of flexibility for Python functions, possible through using various inputs parameters\n",
    "\n",
    "also, the program has an output, a pandas DataFrame loaded from the data.  So we have to specficy the name / variable representing that new object.\n",
    "\n",
    "```python\n",
    "df = pd.read_csv(\"unconv_MV.csv\")  \n",
    "```\n",
    "\n",
    "Let's run this command to load the data and then this command to extract a random subset of the data.\n",
    "\n",
    "```python\n",
    "df = df.sample(frac=.30, random_state = 73073); \n",
    "df = df.reset_index()\n",
    "```\n",
    "\n",
    "#### Feature Engineering\n",
    "\n",
    "Let's make some changes to the data to improve the workflow:\n",
    "\n",
    "* **Select the predictor features (x2) and the response feature (x1)**, make sure the metadata is also consistent.\n",
    "* **Metadata** encoding such as the units, labels and display ranges for each feature.\n",
    "* **Reduce the number of data** for ease of visualization (hard to see if too many points on our plots).\n",
    "* **Train and test data split** to demonstrate and visualize simple hyperparameter tuning.\n",
    "* **Add random noise to the data** to demonstrate model overfit. The original data is error free and does not readily demonstrate overfit.\n",
    "\n",
    "Given this is properly set, one should be able to use any dataset and features for this demonstration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "add_error = True                                        # add random error to the response feature\n",
    "std_error = 700; seed = 71071\n",
    "\n",
    "yname = 'Production'; Xname = ['Por','Brittle']         # specify the predictor features (x2) and response feature (x1)\n",
    "Xmin = [5.0,0.0]; Xmax = [25.0,100.0]                   # set minumums and maximums for visualization \n",
    "ymin = 0.0; ymax = 10000.0\n",
    "Xlabel = ['Porosity','Brittleness']; ylabel = 'Production' # specify the feature labels for plotting\n",
    "Xunit = ['%','fraction']; yunit = 'MCFPD'\n",
    "Xlabelunit = [Xlabel[0] + ' (' + Xunit[0] + ')',Xlabel[1] + ' (' + Xunit[1] + ')']\n",
    "ylabelunit = ylabel + ' (' + yunit + ')'\n",
    "\n",
    "#df = pd.read_csv(\"unconv_MV.csv\")                      # load the data from local current directory\n",
    "df = pd.read_csv(r\"https://raw.githubusercontent.com/GeostatsGuy/GeoDataSets/master/unconv_MV.csv\") # load the data from my github repo\n",
    "df = df.sample(frac=.30, random_state = 73073); df = df.reset_index() # extract 30% random to reduce the number of data\n",
    "\n",
    "if add_error == True:                                   # method to add error\n",
    "    np.random.seed(seed=seed)                           # set random number seed\n",
    "    df[yname] = df[yname] + np.random.normal(loc = 0.0,scale=std_error,size=len(df)) # add noise\n",
    "    values = df._get_numeric_data(); values[values < 0] = 0  # set negative to 0 in a shallow copy ndarray\n",
    "    \n",
    "y = pd.DataFrame(df[yname])                             # extract selected features as X and y DataFrames\n",
    "X = df[Xname]\n",
    "df = pd.concat([X,y],axis=1)                            # make one DataFrame with both X and y (remove all other features)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.25,random_state=73073) # train and test split\n",
    "# y_train = pd.DataFrame({yname:y_train.values}); y_test = pd.DataFrame({yname:y_test.values}) # optional to ensure response is a DataFrame\n",
    "\n",
    "plt.subplot(121)                                        # visualize the data\n",
    "im = plt.scatter(X_train[Xname[0]],X_train[Xname[1]],s=None, c=y_train[yname], marker='o', cmap=cmap, \n",
    "    norm=None, vmin=ymin, vmax=ymax, alpha=0.8, linewidths=0.3, edgecolors=\"black\", label = 'Train')\n",
    "plt.scatter(X_test[Xname[0]],X_test[Xname[1]],s=None, c=y_test[yname], marker='s', cmap=cmap, \n",
    "    norm=None, vmin=ymin, vmax=ymax, alpha=0.5, linewidths=0.3, edgecolors=\"black\", label = 'Test')\n",
    "plt.title('Training ' + ylabel + ' vs. ' + Xlabel[1] + ' and ' + Xlabel[0]); \n",
    "plt.xlabel(Xlabel[0] + ' (' + Xunit[0] + ')'); plt.ylabel(Xlabel[1] + ' (' + Xunit[1] + ')')\n",
    "plt.xlim(Xmin[0],Xmax[0]); plt.ylim(Xmin[1],Xmax[1]); plt.legend(loc = 'upper right'); plt.grid(True)\n",
    "cbar = plt.colorbar(im, orientation = 'vertical')\n",
    "cbar.set_label(ylabel + ' (' + yunit + ')', rotation=270, labelpad=20)\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=1.2, wspace=0.2, hspace=0.2); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Interactive Decision Tree Method\n",
    "\n",
    "The following code includes a dashboard with widgets linked to plots to run a decision tree predictive machine learning model and to provide diagnostics.\n",
    "\n",
    "* visualization of the decision tree regions with the estimate in each region annotated\n",
    "* cross validation plot with conditional mean, P10 and P90 of the truth for each possible estimate\n",
    "* the MSE train and test curves for hyperparameter tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = widgets.Text(value='                                                Machine Learning Decision Tree Demo, Prof. Michael Pyrcz, The University of Texas at Austin',\n",
    "        layout=Layout(width='970px', height='30px'))\n",
    "\n",
    "max_leaf_nodes = widgets.IntSlider(min=2, max = 150, value=2, step = 1, description = r'$n_{leaf}$',orientation='horizontal', \n",
    "        style = {'description_width': 'initial'},layout=Layout(width='900px', height='30px'),continuous_update=False)\n",
    "\n",
    "ui_summary = widgets.HBox([max_leaf_nodes,],)\n",
    "ui2_summary = widgets.VBox([l,ui_summary],)\n",
    "\n",
    "def run_plot_summary(max_leaf_nodes):\n",
    "    global tree_model                                   # make the current tree model available for additional visualizations\n",
    "    tree_model = tree.DecisionTreeRegressor(max_leaf_nodes = max_leaf_nodes) # instantiate and train tree model\n",
    "    tree_model = tree_model.fit(X_train.values, y_train.values)\n",
    "    \n",
    "    plt.subplot(131)                                    # visualize, data, and decision tree regions and predictions\n",
    "    visualize_tree_model(tree_model,X_train[Xname[0]],X_test[Xname[0]],X_train[Xname[1]],X_test[Xname[1]],Xmin,Xmax,\n",
    "                    y_train[yname],y_test[yname],ymin,ymax,'Decision Tree Model',Xname,yname,Xlabelunit,ylabelunit) # plots the data points and the decision tree prediction \n",
    "    \n",
    "    plt.subplot(132)                                    # cross validation with conditional statistics plot\n",
    "    check_tree_model(tree_model,X_train[Xname[0]],X_test[Xname[0]],X_train[Xname[1]],X_test[Xname[1]],Xmin,Xmax,\n",
    "                    y_train[yname],y_test[yname],ymin,ymax,'Decision Tree Model',)\n",
    "    \n",
    "    plt.subplot(133)                                    # hyperparameter tuning plot with current result plotted\n",
    "    tree_tuning(100,max_leaf_nodes,X_train[Xname[0]],X_test[Xname[0]],X_train[Xname[1]],X_test[Xname[1]],Xmin,Xmax,\n",
    "                    y_train[yname],y_test[yname],ymin,ymax,'Decision Tree Model Error',seed)\n",
    "    \n",
    "    plt.subplots_adjust(left=0.0, bottom=0.0, right=3.0, top=1.2, wspace=0.3, hspace=0.2); plt.show()\n",
    "    \n",
    "    return tree_model\n",
    "    \n",
    "# connect the function to make the samples and plot to the widgets    \n",
    "interactive_plot_summary = widgets.interactive_output(run_plot_summary, {'max_leaf_nodes':max_leaf_nodes,})\n",
    "interactive_plot_summary.clear_output(wait = True)                  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interactive Decision Tree Demonstration\n",
    "\n",
    "* select maximum number of leaf nodes, $n_{leaf}$, and observe the decision tree model, cross validation plot and entire training and testing error curves.\n",
    "\n",
    "#### Michael Pyrcz, Professor, University of Texas at Austin \n",
    "\n",
    "##### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1) | [GeostatsPy](https://github.com/GeostatsGuy/GeostatsPy)\n",
    "\n",
    "### The Inputs\n",
    "\n",
    "Change the complexity of the decision tree model\n",
    "\n",
    "* $n_{leaf}$: the maximum number of leaf nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ed6e72ff114c44388c805ca74c8ebb5b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Text(value='                                                Machine Learning Decision Tree Demo…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a9acc79797d042b1b23626d6e77026ae",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output(outputs=({'output_type': 'display_data', 'data': {'text/plain': '<Figure size 640x480 with 4 Axes>', 'i…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(ui2_summary, interactive_plot_summary)                           # display the interactive plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Additional Tree Model Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tree.plot_tree(tree_model,label='none',impurity=False)\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=1.0, wspace=0.2, hspace=0.2); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comments\n",
    "\n",
    "This was an interactive demonstration of predictive machine learning with decision trees. Much more could be done, I have other demonstrations on the basics of working with DataFrames, ndarrays, univariate statistics, plotting data, declustering, data transformations and many other workflows available at https://github.com/GeostatsGuy/PythonNumericalDemos and https://github.com/GeostatsGuy/GeostatsPy. \n",
    "  \n",
    "#### The Author:\n",
    "\n",
    "### Michael Pyrcz, Associate Professor, University of Texas at Austin \n",
    "*Novel Data Analytics, Geostatistics and Machine Learning Subsurface Solutions*\n",
    "\n",
    "With over 17 years of experience in subsurface consulting, research and development, Michael has returned to academia driven by his passion for teaching and enthusiasm for enhancing engineers' and geoscientists' impact in subsurface resource development. \n",
    "\n",
    "For more about Michael check out these links:\n",
    "\n",
    "#### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)\n",
    "\n",
    "#### Want to Work Together?\n",
    "\n",
    "I hope this content is helpful to those that want to learn more about subsurface modeling, data analytics and machine learning. Students and working professionals are welcome to participate.\n",
    "\n",
    "* Want to invite me to visit your company for training, mentoring, project review, workflow design and / or consulting? I'd be happy to drop by and work with you! \n",
    "\n",
    "* Interested in partnering, supporting my graduate student research or my Subsurface Data Analytics and Machine Learning consortium (co-PIs including Profs. Foster, Torres-Verdin and van Oort)? My research combines data analytics, stochastic modeling and machine learning theory with practice to develop novel methods and workflows to add value. We are solving challenging subsurface problems!\n",
    "\n",
    "* I can be reached at mpyrcz@austin.utexas.edu.\n",
    "\n",
    "I'm always happy to discuss,\n",
    "\n",
    "*Michael*\n",
    "\n",
    "Michael Pyrcz, Ph.D., P.Eng. Associate Professor The Hildebrand Department of Petroleum and Geosystems Engineering, Bureau of Economic Geology, The Jackson School of Geosciences, The University of Texas at Austin\n",
    "\n",
    "#### More Resources Available at: [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)  \n",
    "  "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}