RandomForestShowcase.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing packages "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data wrangling \n",
    "import pandas as pd \n",
    "\n",
    "# Array math\n",
    "import numpy as np \n",
    "\n",
    "# Ploting \n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# List iteration tracking\n",
    "from tqdm import tqdm\n",
    "\n",
    "# Importing the custom written class \n",
    "from DecisionTree import Node \n",
    "\n",
    "# Importing the custom regression tree \n",
    "from RandomForest import RandomForestClassifier, RandomForestTree\n",
    "\n",
    "# Time tracking\n",
    "import time\n",
    "\n",
    "# Precision metrics \n",
    "from sklearn.metrics import precision_score, recall_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reading data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data regards telecom churn. \n",
    "\n",
    "The objective is to create a model that predicts whether a customer will quit using the features available."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = pd.read_csv('data/random_forest/telecom_churn.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data shape: (3333, 11)\n"
     ]
    }
   ],
   "source": [
    "print(f\"Data shape: {d.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "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>Churn</th>\n",
       "      <th>AccountWeeks</th>\n",
       "      <th>ContractRenewal</th>\n",
       "      <th>DataPlan</th>\n",
       "      <th>DataUsage</th>\n",
       "      <th>CustServCalls</th>\n",
       "      <th>DayMins</th>\n",
       "      <th>DayCalls</th>\n",
       "      <th>MonthlyCharge</th>\n",
       "      <th>OverageFee</th>\n",
       "      <th>RoamMins</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>128</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2.7</td>\n",
       "      <td>1</td>\n",
       "      <td>265.1</td>\n",
       "      <td>110</td>\n",
       "      <td>89.0</td>\n",
       "      <td>9.87</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>107</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3.7</td>\n",
       "      <td>1</td>\n",
       "      <td>161.6</td>\n",
       "      <td>123</td>\n",
       "      <td>82.0</td>\n",
       "      <td>9.78</td>\n",
       "      <td>13.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>137</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>243.4</td>\n",
       "      <td>114</td>\n",
       "      <td>52.0</td>\n",
       "      <td>6.06</td>\n",
       "      <td>12.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>84</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2</td>\n",
       "      <td>299.4</td>\n",
       "      <td>71</td>\n",
       "      <td>57.0</td>\n",
       "      <td>3.10</td>\n",
       "      <td>6.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>75</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3</td>\n",
       "      <td>166.7</td>\n",
       "      <td>113</td>\n",
       "      <td>41.0</td>\n",
       "      <td>7.42</td>\n",
       "      <td>10.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Churn  AccountWeeks  ContractRenewal  DataPlan  DataUsage  CustServCalls  \\\n",
       "0      0           128                1         1        2.7              1   \n",
       "1      0           107                1         1        3.7              1   \n",
       "2      0           137                1         0        0.0              0   \n",
       "3      0            84                0         0        0.0              2   \n",
       "4      0            75                0         0        0.0              3   \n",
       "\n",
       "   DayMins  DayCalls  MonthlyCharge  OverageFee  RoamMins  \n",
       "0    265.1       110           89.0        9.87      10.0  \n",
       "1    161.6       123           82.0        9.78      13.7  \n",
       "2    243.4       114           52.0        6.06      12.2  \n",
       "3    299.4        71           57.0        3.10       6.6  \n",
       "4    166.7       113           41.0        7.42      10.1  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Churn                int64\n",
       "AccountWeeks         int64\n",
       "ContractRenewal      int64\n",
       "DataPlan             int64\n",
       "DataUsage          float64\n",
       "CustServCalls        int64\n",
       "DayMins            float64\n",
       "DayCalls             int64\n",
       "MonthlyCharge      float64\n",
       "OverageFee         float64\n",
       "RoamMins           float64\n",
       "dtype: object"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Churn\n",
       "0    2850\n",
       "1     483\n",
       "dtype: int64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Distribution of churn in data \n",
    "d.groupby('Churn').size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random forest - quick theory review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The classifier which will be created is a random forest classifier. \n",
    "\n",
    "Lets denote it as **rf()**.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a set of input matrix $\\mathbb{X}_{nxp}$ the classifier **rf()** outputs either 1 or 0.\n",
    "\n",
    "$$rf: \\mathbb{X} \\rightarrow \\{1, 0\\}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The algorithm of the random forest grows **k** decision trees. \n",
    "\n",
    "The final prediction of the **rf()** classifier is a majority vote: the input matrix $\\mathbb{X}$ is used with each of the **k** trees, and then the class with the most outputs wins. \n",
    "\n",
    "In the notebook about decision trees it is clear that with the same input and the same hyperparameters, the same output and the same rules will be learnt by a decision tree. So why grow **k** of them? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data bootstrapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The random in the random forest starts at the data sample creation for each of the decision trees. The technique used in creating **k** datasamples is bootstrapping\n",
    "\n",
    "Given a dataset of n rows and p features: we sample the rows from the original dataset with replacement. For every new decision tree *i*, a new bootsrapped dataset is created: $\\mathbb{X_{b}^{i}}$.\n",
    "\n",
    "For example, lets assume that the whole dataset has 10 rows of data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Churn  DataPlan  DayMins  OverageFee\n",
      "0      0         0    156.2        4.50\n",
      "1      0         0    259.3        8.76\n",
      "2      0         0    247.4        8.80\n",
      "3      0         0    149.7       10.63\n",
      "4      0         1    155.9        8.12\n",
      "5      0         0    191.0       15.94\n",
      "6      0         0    146.0        5.49\n",
      "7      0         0    203.7       10.82\n",
      "8      0         0    162.7       14.60\n",
      "9      0         0    219.4       11.29\n"
     ]
    }
   ],
   "source": [
    "# Lets imagine this the whole dataset\n",
    "dsubset = d.sample(10).copy()[['Churn', 'DataPlan', 'DayMins', 'OverageFee']]\n",
    "dsubset.reset_index(inplace=True, drop=True)\n",
    "\n",
    "print(dsubset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create 3 more random bootsrapped samples we use the pandas function **sample(replace=True)**. The key concept is that the sampling is done *with replacement*: the same rows might appear several times in our sample. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----- \n",
      "\n",
      "Boostrapped sample: 1 \n",
      "\n",
      "   Churn  DataPlan  DayMins  OverageFee\n",
      "4      0         1    155.9        8.12\n",
      "1      0         0    259.3        8.76\n",
      "1      0         0    259.3        8.76\n",
      "4      0         1    155.9        8.12\n",
      "4      0         1    155.9        8.12\n",
      "5      0         0    191.0       15.94\n",
      "5      0         0    191.0       15.94\n",
      "5      0         0    191.0       15.94\n",
      "0      0         0    156.2        4.50\n",
      "4      0         1    155.9        8.12\n",
      "----- \n",
      "\n",
      "----- \n",
      "\n",
      "Boostrapped sample: 2 \n",
      "\n",
      "   Churn  DataPlan  DayMins  OverageFee\n",
      "7      0         0    203.7       10.82\n",
      "8      0         0    162.7       14.60\n",
      "4      0         1    155.9        8.12\n",
      "2      0         0    247.4        8.80\n",
      "1      0         0    259.3        8.76\n",
      "4      0         1    155.9        8.12\n",
      "0      0         0    156.2        4.50\n",
      "1      0         0    259.3        8.76\n",
      "9      0         0    219.4       11.29\n",
      "4      0         1    155.9        8.12\n",
      "----- \n",
      "\n",
      "----- \n",
      "\n",
      "Boostrapped sample: 3 \n",
      "\n",
      "   Churn  DataPlan  DayMins  OverageFee\n",
      "8      0         0    162.7       14.60\n",
      "3      0         0    149.7       10.63\n",
      "9      0         0    219.4       11.29\n",
      "7      0         0    203.7       10.82\n",
      "4      0         1    155.9        8.12\n",
      "3      0         0    149.7       10.63\n",
      "1      0         0    259.3        8.76\n",
      "3      0         0    149.7       10.63\n",
      "1      0         0    259.3        8.76\n",
      "4      0         1    155.9        8.12\n",
      "----- \n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i, _ in enumerate(range(3)):\n",
    "    print(\"----- \\n\")\n",
    "    print(f\"Boostrapped sample: {i + 1} \\n\")\n",
    "    print(dsubset.sample(frac=1.0, replace=True))\n",
    "    print(\"----- \\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each of the **k** trees grown in random forest, we create **k** bootstrapped data samples. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature selection at each split "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have a dataset $\\mathbb{X_{b}^{i}}$ for each of the **k** trees the final part is to determine the splitting criterion for the creation of the nodes. \n",
    "\n",
    "In the classification case, the gini gain criterion is the same as in the simple decision tree case. The difference is that at each node splitting, a random subsample of collumns are select to find the \"best split\". \n",
    "\n",
    "For example, if we have 10 collumns as features and we select the hyperparameter of **X_features_fraction = 0.8** then at each node where the best split is beeing calculated, we would select 8 random features (10 * 0.8 = 8).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Features to use "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The bellow feature list will be used in the creation of the random forest. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining the feature list used in the growth of the tree\n",
    "features = [\n",
    "    'AccountWeeks',\n",
    "    'DataUsage',\n",
    "    'DayMins',\n",
    "    'DayCalls',\n",
    "    'MonthlyCharge',\n",
    "    'OverageFee',\n",
    "    'RoamMins'\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "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>AccountWeeks</th>\n",
       "      <th>DataUsage</th>\n",
       "      <th>DayMins</th>\n",
       "      <th>DayCalls</th>\n",
       "      <th>MonthlyCharge</th>\n",
       "      <th>OverageFee</th>\n",
       "      <th>RoamMins</th>\n",
       "      <th>Churn</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>977</th>\n",
       "      <td>93</td>\n",
       "      <td>3.19</td>\n",
       "      <td>134.2</td>\n",
       "      <td>105</td>\n",
       "      <td>68.9</td>\n",
       "      <td>8.13</td>\n",
       "      <td>11.8</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3104</th>\n",
       "      <td>63</td>\n",
       "      <td>2.78</td>\n",
       "      <td>214.2</td>\n",
       "      <td>61</td>\n",
       "      <td>79.8</td>\n",
       "      <td>9.06</td>\n",
       "      <td>10.3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>355</th>\n",
       "      <td>31</td>\n",
       "      <td>0.28</td>\n",
       "      <td>166.1</td>\n",
       "      <td>105</td>\n",
       "      <td>37.8</td>\n",
       "      <td>3.97</td>\n",
       "      <td>12.7</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>845</th>\n",
       "      <td>144</td>\n",
       "      <td>2.70</td>\n",
       "      <td>283.9</td>\n",
       "      <td>98</td>\n",
       "      <td>92.0</td>\n",
       "      <td>9.60</td>\n",
       "      <td>10.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1943</th>\n",
       "      <td>125</td>\n",
       "      <td>0.00</td>\n",
       "      <td>168.6</td>\n",
       "      <td>99</td>\n",
       "      <td>44.0</td>\n",
       "      <td>8.78</td>\n",
       "      <td>10.9</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1219</th>\n",
       "      <td>36</td>\n",
       "      <td>0.00</td>\n",
       "      <td>178.6</td>\n",
       "      <td>83</td>\n",
       "      <td>49.0</td>\n",
       "      <td>10.66</td>\n",
       "      <td>10.9</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>94</th>\n",
       "      <td>90</td>\n",
       "      <td>0.00</td>\n",
       "      <td>179.1</td>\n",
       "      <td>71</td>\n",
       "      <td>47.0</td>\n",
       "      <td>9.53</td>\n",
       "      <td>10.6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>203</th>\n",
       "      <td>105</td>\n",
       "      <td>0.00</td>\n",
       "      <td>140.6</td>\n",
       "      <td>109</td>\n",
       "      <td>40.0</td>\n",
       "      <td>8.93</td>\n",
       "      <td>6.8</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1423</th>\n",
       "      <td>127</td>\n",
       "      <td>2.81</td>\n",
       "      <td>95.9</td>\n",
       "      <td>117</td>\n",
       "      <td>58.1</td>\n",
       "      <td>7.98</td>\n",
       "      <td>10.4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1370</th>\n",
       "      <td>96</td>\n",
       "      <td>0.00</td>\n",
       "      <td>179.5</td>\n",
       "      <td>125</td>\n",
       "      <td>45.0</td>\n",
       "      <td>8.12</td>\n",
       "      <td>6.6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      AccountWeeks  DataUsage  DayMins  DayCalls  MonthlyCharge  OverageFee  \\\n",
       "977             93       3.19    134.2       105           68.9        8.13   \n",
       "3104            63       2.78    214.2        61           79.8        9.06   \n",
       "355             31       0.28    166.1       105           37.8        3.97   \n",
       "845            144       2.70    283.9        98           92.0        9.60   \n",
       "1943           125       0.00    168.6        99           44.0        8.78   \n",
       "1219            36       0.00    178.6        83           49.0       10.66   \n",
       "94              90       0.00    179.1        71           47.0        9.53   \n",
       "203            105       0.00    140.6       109           40.0        8.93   \n",
       "1423           127       2.81     95.9       117           58.1        7.98   \n",
       "1370            96       0.00    179.5       125           45.0        8.12   \n",
       "\n",
       "      RoamMins  Churn  \n",
       "977       11.8      1  \n",
       "3104      10.3      0  \n",
       "355       12.7      0  \n",
       "845       10.0      0  \n",
       "1943      10.9      0  \n",
       "1219      10.9      0  \n",
       "94        10.6      0  \n",
       "203        6.8      0  \n",
       "1423      10.4      0  \n",
       "1370       6.6      0  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[features + ['Churn']].sample(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the train and test sets "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total rows in the dataset: 3333\n",
      "Rows in training set: 2500\n",
      "Rows in test set: 833\n"
     ]
    }
   ],
   "source": [
    "# Fraction of rows in the training set \n",
    "train_share = 0.75\n",
    "\n",
    "# Creating the train and test sets\n",
    "train = d.sample(frac=train_share)\n",
    "test = d[~d.index.isin(train.index)].copy()\n",
    "\n",
    "print(f\"Total rows in the dataset: {d.shape[0]}\")\n",
    "print(f\"Rows in training set: {train.shape[0]}\")\n",
    "print(f\"Rows in test set: {test.shape[0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training the random forest "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████| 30/30 [02:34<00:00,  5.14s/it]\n"
     ]
    }
   ],
   "source": [
    "# Initiating the random forest object \n",
    "rf = RandomForestClassifier(\n",
    "    Y=train['Churn'], \n",
    "    X=train[features],\n",
    "    min_samples_split=5,\n",
    "    max_depth=3,\n",
    "    n_trees=30, # Number of trees grown\n",
    "    X_features_fraction=0.75\n",
    "    )\n",
    "\n",
    "# Growing the random forest \n",
    "rf.grow_random_forest()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Printing out the trees\n",
    "if rf.n_trees < 10:\n",
    "    rf.print_trees()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total churns in test set: 116\n",
      "Total predicted churns in test set: 44\n",
      "Precision: 75.0 %\n",
      "Recall: 28.000000000000004 %\n"
     ]
    }
   ],
   "source": [
    "yhat = rf.predict(test[features])\n",
    "test['yhat'] = yhat\n",
    "\n",
    "print(f\"Total churns in test set: {test['Churn'].sum()}\")\n",
    "print(f\"Total predicted churns in test set: {test['yhat'].sum()}\")\n",
    "\n",
    "print(f\"Precision: {round(precision_score(test['Churn'], test['yhat']), 2) * 100} %\")\n",
    "print(f\"Recall: {round(recall_score(test['Churn'], test['yhat']), 2) * 100} %\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sklearn implementation "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compare the custom implementation of RF to that of skicit learn. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time took for scikit learn: 0.05 seconds\n",
      "Total churns in test set: 116\n",
      "Total predicted churns in test set: 44\n",
      "Precision: 79.0 %\n",
      "Recall: 26.0 %\n"
     ]
    }
   ],
   "source": [
    "# Skicit learn implementation\n",
    "from sklearn.ensemble import RandomForestClassifier as RandomForestClassifierScikit\n",
    "\n",
    "# Initiating\n",
    "rf_scikit = RandomForestClassifierScikit(n_estimators=30, max_features=0.75, max_depth=3, min_samples_split=5)\n",
    "\n",
    "# Fitting \n",
    "start = time.time()\n",
    "rf_scikit.fit(X=train[features], y=train['Churn'])\n",
    "print(f\"Time took for scikit learn: {round(time.time() - start, 2)} seconds\")\n",
    "\n",
    "# Forecasting \n",
    "yhatsc = rf_scikit.predict(test[features])\n",
    "test['yhatsc'] = yhatsc\n",
    "\n",
    "print(f\"Total churns in test set: {test['Churn'].sum()}\")\n",
    "print(f\"Total predicted churns in test set: {test['yhat'].sum()}\")\n",
    "\n",
    "print(f\"Precision: {round(precision_score(test['Churn'], test['yhatsc']), 2) * 100} %\")\n",
    "print(f\"Recall: {round(recall_score(test['Churn'], test['yhatsc']), 2) * 100} %\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "decision-tree",
   "language": "python",
   "name": "decision-tree"
  },
  "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}