decisionTreesBreastCancer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Decision Tree Classification on Breast Cancer Dataset**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download the Breast Cancer Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.datasets import load_breast_cancer;\n",
    "\n",
    "cancer = load_breast_cancer();\n",
    "X = cancer.data;\n",
    "y = cancer.target;\n",
    "\n",
    "#data = np.c_[cancer.data, cancer.target];\n",
    "#columns = np.append(cancer.feature_names, [\"target\"]);\n",
    "\n",
    "#cancer.df = pd.DataFrame(data, columns = columns);\n",
    "#print(cancer.df.head());\n",
    "#print(\"\\ncancer.df.shape = \",cancer.df.shape);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Divide the data into train (80%) and test (20%)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(455, 30)\n",
      "(455,)\n",
      "\r\n",
      "\n",
      "(114, 30)\n",
      "(114,)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split;\n",
    "\n",
    "X_train , X_test, y_train, y_test = train_test_split(X,\n",
    "                                                     y,\n",
    "                                                     test_size = 0.2,\n",
    "                                                     random_state = 0);\n",
    "\n",
    "print(X_train.shape);\n",
    "print(y_train.shape);\n",
    "print(\"\\r\\n\");\n",
    "print(X_test.shape);\n",
    "print(y_test.shape);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. ***Decision Tree Classifier*** using all the features of the data. Model tested on the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(ccp_alpha=0.0, class_weight=None, criterion='entropy',\n",
       "                       max_depth=3, max_features=None, max_leaf_nodes=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, presort='deprecated',\n",
       "                       random_state=0, splitter='best')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier;\n",
    "\n",
    "tree = DecisionTreeClassifier(criterion    =  'entropy',\n",
    "                              max_depth    =  3,\n",
    "                              random_state =  0 );\n",
    "tree.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(193.15384615384616, 190.26, 'worst concave points <= 0.142\\nentropy = 0.945\\nsamples = 455\\nvalue = [165, 290]'),\n",
       " Text(103.01538461538462, 135.9, 'worst perimeter <= 107.75\\nentropy = 0.399\\nsamples = 303\\nvalue = [24, 279]'),\n",
       " Text(51.50769230769231, 81.53999999999999, 'symmetry error <= 0.016\\nentropy = 0.133\\nsamples = 269\\nvalue = [5, 264]'),\n",
       " Text(25.753846153846155, 27.180000000000007, 'entropy = 0.337\\nsamples = 80\\nvalue = [5, 75]'),\n",
       " Text(77.26153846153846, 27.180000000000007, 'entropy = 0.0\\nsamples = 189\\nvalue = [0, 189]'),\n",
       " Text(154.52307692307693, 81.53999999999999, 'worst texture <= 20.22\\nentropy = 0.99\\nsamples = 34\\nvalue = [19, 15]'),\n",
       " Text(128.76923076923077, 27.180000000000007, 'entropy = 0.0\\nsamples = 11\\nvalue = [0, 11]'),\n",
       " Text(180.27692307692308, 27.180000000000007, 'entropy = 0.667\\nsamples = 23\\nvalue = [19, 4]'),\n",
       " Text(283.2923076923077, 135.9, 'worst perimeter <= 112.8\\nentropy = 0.375\\nsamples = 152\\nvalue = [141, 11]'),\n",
       " Text(257.53846153846155, 81.53999999999999, 'worst texture <= 27.575\\nentropy = 0.948\\nsamples = 30\\nvalue = [19, 11]'),\n",
       " Text(231.7846153846154, 27.180000000000007, 'entropy = 0.964\\nsamples = 18\\nvalue = [7, 11]'),\n",
       " Text(283.2923076923077, 27.180000000000007, 'entropy = 0.0\\nsamples = 12\\nvalue = [12, 0]'),\n",
       " Text(309.04615384615386, 81.53999999999999, 'entropy = 0.0\\nsamples = 122\\nvalue = [122, 0]')]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWMAAADnCAYAAADLlDebAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOy9eViV1frw/1n7KIKCCDlkjq9anhywTmQ55JCn1MQ0BzQHFAdAZDAERESPoEgqouYIhTmczKHUo+XX962+Wjn8so5IoObQURQxOwaJJCCy1++PDTs2IINs2HvD+lzXvnQ/z3rWutdzr32znvu5172ElBKFQqFQmBaNqQVQKBQKhTLGCoVCYRYoY6xQKBRmgDLGCoVCYQYoY6xQKBRmgDLGCoVCYQYoY6xQKBRmgDLGCoVCYQYoY6xQKBRmgDLGCoVCYQYoY6xQKBRmgDLGCoVCYQYoY6xQKBRmgDLGCoVCYQYoY6xQKBRmQD1TC6CwbGxsbH7JyclpYWo5FMbH2tr6dnZ29pOmlqOuIFRyeUVVEEJINYZqJ0IIpJTC1HLUFZSbQqFQKMwAZYwVCoXCDFDGWKFQKMwAZYwVJkWr1ZY4NmbMGBNIUjWCgoJKPb5161Y+++yzStWVk5NToXJHjx5lypQpTJw4kbS0NINzCxYs4JlnniErK0t/7NatW3To0IHk5GTS09OZOnUqkydPJiAgoFLyKaoHFU2hMCr+/v4sWbKEgIAABg4ciJWVFVZWVgAcOnSInJwcFi9ezPHjx/nyyy9xdnYmPz+flJQU7O3tGTduHOfPn2fx4sUEBgZia2sLwMqVK7l+/TpNmjRhyZIl+Pn5Ua9ePfLy8li3bh0uLi4MGDCA5ORkAgICaNeuHX5+fjRt2pT+/fvTsWNHPvroI27fvs2MGTO4dOkSjo6ODB8+HHd3d9atW8fatWv573//y71791izZg12dnYALF68mMzMTOzs7OjYsSPjx4/H09MTe3t7HB0dWbRoEVevXgWgb9++jBo1ih9++IHo6GiOHz/O/fv3AThx4gQ5OTm0adOmhAF88OABn3/+OYcPH+bZZ5+tkIHcvHkzH3/8MefPnyc+Pp6FCxfqz0VGRnLz5k2D8itXrmTs2LEAODo6snXrVgDGjh2LVqtFo1FzM1OijLHCqPTt25dvv/0We3t7EhMTycnJITw8nBkzZvDpp5+SkpLCunXr6NatG0OHDmXixIkEBQXh7OzM0KFDadasGV26dGHx4sX6OrOyskhKSmL79u0AJCcn4+DgQHh4OOHh4SQnJwMQEBDAuXPn+Oyzz7C3t2fSpEm89tprAFy5coWcnBxatGjBjh07WLFiBX5+fgwYMIB69epx48YNvvnmG3r16kVubi4XLlygZ8+eehlGjRpF3759cXV1xdHRkX79+uHu7s706dPJzMzUl7OzsyMgIIBDhw7x9ddf07dvX5o2bYqLiwsHDhxg8ODBDB482OCexcbG8q9//QsvLy82btxI/fr1AVi/fj1XrlzRl+vZsycTJkzQf5dSotFoaNeuHampqWXq5cMPP2T06NF88cUXBse//fZb/vrXvypDbAYoDSiMyoABA9iyZQtPP/00Wq2W9PR0HBwc9OeF+DNSyt7eHoDly5fTuXNn3N3dyczMNCgDOqNT9FjR74X/Wltbo9FoqF+/Prm5uXpDVcjatWuZM2cOnp6e3L9/H1tbW4QQbNu2jVGjRqHVaunatSuLFy9m06ZNBoYY4OHDhwDk5eWVkKcojRo1AtDLUVSGTZs20axZM8aPH29wzfDhwxkwYAD/+te/iIuL486dOwDk5+fz8OFD/ae4S0ej0aDVarl+/TqtW7cuVZ5CTp8+zd69ezly5AixsbEAHDt2jAMHDhAREVHmtYqaQc2MFUalWbNmXLp0icjISHJycvQGZNKkSXpDuHDhQk6ePKm/ZsWKFdy5cwdHR0caNmxIixYtCAkJISwsDFtbW+zs7OjSpQvvvPMOjo6OLFy4kNjYWIKCgsjOzqZbt24l5JgwYQLvvPMOX3zxBa+88goDBw5k+fLltGjx5/qU0aNH4+Pjw6VLl6hXrx4ajYaAgACys7MJDQ2lTZs2+rJ79uxh9+7dvPXWW7z++ut4eXmRlJREmzZtaNy48SPvR48ePYiMjOThw4ecPHkSrVZLhw4dDMo89dRTBAcHA/D999+zb98+PDw88Pf3L/Nee3h4MGPGDPLy8li+fDmpqals2LCBqKgoYmJiOHXqFHPmzCEiIoJNmzYBOpfLmDFjuH37Nq6urrz11lvMmjWL1atXY2NjU2Z7iupFLfpQVIm6sOij0ICVZvRrM2rRR82ijLGiStQFY1xXUca4ZlE+Y0WtZurUqQbhXVB6OJ0x2blzJzNnzsTNzY0//vhDf/z+/ftMmjQJb29vli5dqj+elJRE8+bN9XJ27NgRLy8v4uLiqlVOhXmhjLHCYklJScHPzw9fX1/WrFnDtWvX6NevH9HR0bi7u3Pv3j3Onj3LsmXLSE5Opk+fPrz77rv88MMP+Pn5ERAQgK+vLwAuLi6sWrWKWbNm8eOPP/LOO+9w8+ZNcnNzmTx5cqXk2r9/P++//z6urq7s27dPf/zChQt07tyZjRs3cuvWLW7cuEFeXh4ffPABQ4cO1ZeztbUlOzvbwGetqP0oY6ywWDZu3IiNjQ1PPPEESUlJAHTt2pXAwEAcHR3JysriueeeIzQ0lG7dutGwYUNCQkJo2LAhDg4OxMTE0LRpU5KTk8nPz8ff359ly5axYcMGZs+eTVxcHLt27SoR/RAREcGcOXP0nyNHjhicL4y0KB5y9vzzz5Obm0tAQABpaWncvHmT6OhofH19DaIzEhIS2LJlC2vXrq2uW6cwQ1Q0hcJi0Wq1TJ48GScnJwCuXbtWZmhZYShdaaFxWq2W/Px88vLyEELQqVMn0tLSuHDhArt27TJotzDkrKgcpVE85Eyj0ejdE9OmTaNDhw6sXr2a27dvc/r0aWJjY5k7d65eZmtra7UYow6hjLHCYvHx8SE0NJSWLVtiZ2fHlClTSpTp1asXwcHBeHl56Y917969RGiclZUVS5cu5fLly4SGhgIwaNAgbt26VcIYhoeHlynXyJEjmTVrFtnZ2WzYsIFTp06RkJCAt7c33t7e5OXl4ezsTPPmzdm9ezeg8217enpy8eJFli9fDuhitpUhrjuoaApFlagt0RRjxozhk08+0X8/ceIEa9euJT4+Xr8suq6hoilqFmWMFVWithhjRUmUMa5Z1DOQQlGEx8myVhG8vLwIDAwEdItIxo0bh5eXlz7bmgpnUyifscLi2blzJ8eOHcPOzo5ly5axd+9ezp49S2ZmJhs2bCAyMpKMjAwyMjJwcnLit99+IzU1lR07duDi4sLAgQO5cuUKs2bN0teZkpLCqlWrkFLSsWNHBg8eTHh4OG3btsXNza1Sq/E++eQTnJ2d+emnnwCoV68eVlZW1K9fnyZNmgAqnE2hjLGiFpCamoqTkxMjRoygQYMGgM7g3bx5k4SEBADGjRtH165dcXd31+d+yMjI0Ie03bt3j5CQEHr16gX8GTZnY2NDUlISL7/8Mg4ODkyYMMHAEKenp5dItOPj40OnTp0AuH37NgkJCcycOVNvjENDQ9FoNBw8eJAPPvgAPz8/EhISkFIybNgwg5hjRd1BGWOFxRMcHExiYiJBQUEsWbKEPXv2cPDgQcLDw/W5hBs3bkyDBg30SX2srKzIzc0tEdJWSPGwOYBWrVoRHx9PYmKiQeRG0TA30IXOFfL111/z66+/EhERQWJiIpcuXeKZZ54BoHnz5vr0nyqcTaGMscLiiYuL4/Lly2g0Gp544glatmzJihUrOH36NP379y/z2uIhbWfOnAFKhs3169ePQ4cOkZ6ers+RDLok7evXr39k/a6urri6unLt2jXWr1/PM888w7Jly7hx4wZ37tzhvffeU+FsCkBFUyiqiKVHUxQPaVP8iYqmqFmUMVZUCUs3xopHo4xxzaKehxS1hurYyLR3794cPHgQAE9PT7p3764/d+vWLX2iohMnTgDlh6hdvHiRadOmMWHCBL1rYvfu3bi5uTF9+nQuXLgAQEhICH5+foSEhABw5MgRnJ2djd4/hfmgjLHCIvD09OS3335Dq9Xy9ttvk5aWxoIFC/Dy8uLAgQMGZQuN8ubNmzl27BgJCQn4+/sze/Zs/vnPf1aq3aeeeoo333wT0O1V17lzZ/256Oho7Ozs0Gg0+hwU5YWode7cmS1btrBz506+++47AD799FPi4+OJiopi1apVXL9+nby8PN577z3y8/O5ceMGQ4YMoX379pWSXWFZqBd4CovA1dWVPXv28PTTT/Pqq69Sr149cnNzadGiBR999BEjR4585LUxMTF07NgR0GVEmzRpkv5cREQE6enp+u9DhgxhyJAhFZLp3LlzrF27lubNmxMUFMQHH3xQ4RC1Xbt28frrrwMQGBiIr68vTz75JBkZGdy8eVNvzNu2bUtqaqqKP64DKGOssAgGDhxIXFwcP/74I1FRUcTHx/Pmm2/y0ksvMWLECIOyhdEIhYndHzx4gL+/v8HGqIVUNANbabRu3RoHBwdsbW3JyckxaLusELVdu3aRkpLCvHnzAN2uzz179uTKlSusX7+eVq1a6VNv3rhxo8w/NIragzLGCotAo9HQvn17bt26RZMmTejduzebN2/mxIkTWFlZGZRt1aoV0dHRHD9+nBdeeIF58+bh6+tLixYtaN++vT6hPJSfga0oCxYsICEhAS8vL9auXUtAQADBwcEIIZg1a1apIWpffPEFTZo04cUXXwR0M/PAwEBcXFwICAggJiaGw4cPc+jQIbKysli5ciVPPvkk9evXJyAggAYNGqhZcR1BRVMoqkRtj6aoauhbZGQkPj4++lzKppSlsqhoippFvcBTKMrAwcFBH03xOCxYsMAohvjIkSP6xPmK2omaGSuqRG2fGddl1My4ZlEzY4VCoTAD1As8RZWwtra+LYRoYWo5FMbH2tr6tqllqEsoN4XCIhBCdAc2AjaAt5TytIlFqjGEEK8AG4DbgK+U8icTi6SoBpSbQmHWCCEaCyFigK+Aj4CX6pIhBpBSfgv8DfgcOC6EiBJCqLd5tQxljBVmidAxAbgA2ANdpZSbpZT5JhbNJEgpH0op1wDdgbbAeSHEKFE0CbPColFuCoXZIYTogu6xvAk6l8QpE4tkdgghBqC7RzfQuS4um1YiRVVRM2OF2SCEsBVCrAC+Bj4FnJUhLh0p5THgOeBL4JQQYokQoqFppVJUBWWMFSanwCXhis4l0RzoJqVcX1ddEhVFSpknpYxGZ5SfAc4JId40sViKx0S5KRQmRQjRGVgPtABmF7ysUjwGQoi/o7uXlwF/KeV/TCySohKombHCJAghGgkhlgHH0UUJ/E0Z4qohpfwScAJOAN8LIf4hhLA2sViKCqKMsaJGKXBJjALOA+0AJynlGinlw3IuVVQAKeUDKeW7wPPoIi+ShRBvmFgsRQVQbgpFjSGEeBp4D11o1uyCl1CKakQIMQRYB5wD5kgpr5lWIsWjUDNjRbUjhGgohFgCnEK3eOM5ZYhrBinlEXQz5B+AH4QQC4QQDUwslqIUlDFWVCsFb/fPAU+jM8LRUso8E4tVp5BS5kgplwLOQE8gSQjxuonFUhRDuSkU1YIQogOwFp0R9il4uaQwA4QQLujcRWeAd6SUN0wskgI1M1YYCSHES0KIVkIIayHEIuA0ukgJJ2WIzQsp5WdAVyAZSBBCzBNCWAkh/o8Q4m8mFq/OooyxosoIIZoC/wLeRPcDd0IXqrZcSvnApMIpSkVKmS2lXAy8BPQDEoE3gH8JIRqbUra6inJTKKqMEOJToAcggQAp5SETi6SoBAXJhkYBq4CHwLdSSnfTSlX3UMZYUSWEEIPQ5Ud4gO5Ja7eUcpJppVJUFiHEAcAF0AL10T3ZJJhWqrqFMsaKKiGE0KALnboB/C6l1JpYJMVjIoT4C7pMea2BH9XmhjWLMsYKhUJhBtTJPfBsbGx+ycnJUfu2mTHW1ta3s7OznzS1HJaEGtfmR2XGcZ2cGavt5c0ftU185VHj2vyozDhWoW0KhUJhBihjrFAoFGaAMsaPgVZbMmBgzJgxj12flJKDBw/y7beVS+e7detWPvvsszLLlCZr0XZzc3PLbefu3btMmzaNgQMH6o8dPXqUKVOmMHHiRNLS0jh//jxeXl54eXnRsWNHg+sPHDiAl5cX48eP5+233wagZ8+eeHl5ERUVVW77ippBjWvYvn07/fr107d//PhxZsyYwZgxY9i+fbvB9f/+978ZMWIEkydPZtu2beW2Vx518gVecfz9/VmyZAkBAQEMHDgQKysrrKysADh06BA5OTksXryY48eP8+WXX+Ls7Ex+fj4pKSnY29szbtw4zp8/z+LFiwkMDMTW1haAPn36MHbsWM6dO8fixYv59ddf2bp1Kw8fPqRXr160bt2alStX0qdPH1q0aIFGo2Hr1q0cPXoUGxsbWrZsSV5eHsnJyezZs4evv/6azz//nOzsbEaPHs3x48e5f/8+AA0aNDA4l5aWppd1zpw5Bv39+eef2bFjB1evXuUf//gHHTp0KPP+2Nvbs2XLFoMf5ubNm/n44485f/488fHxLFy4kM2bN3P27FkcHR0Nrh85ciQjR45kzZo1PPvsswA0atSIBw8e8NRTT1VNeYpHosZ15ce1m5ubgaHv27cvffv2BWD06NG4ubnpzyUkJODt7c2gQYPw8PBgypQpVdCWMsaA7oZ/++232Nvbk5iYSE5ODuHh4cyYMYNPP/2UlJQU1q1bR7du3Rg6dCgTJ04kKCgIZ2dnhg4dSrNmzejSpQuLFy82qNfGxoY5c+aQkJDA9u3bOX/+vH7WmJCQQOvWrenduzehoaFs3bpVf93gwYOZMGECgwYN4quvvmLZsmWcO3eO9957jxdeeIEmTZpw+vRp+vbtS9OmTXFxcWH48OEG51q3bq2XtZCMjAxcXV3p1asX06ZNo3379gBcuXKF9evXG8i+aNGiEka1KFJKNBoN7dq1IzU1VX/8gw8+KPEjKeSLL77Az88PgK+++gqNRsO4ceMYPnx4mW0pHg81ris/rh/FypUrcXc3XJQ4aNAgJk6cyJIlS/jHP/5R6TqLo4wxMGDAALy8vHjttde4cuUK6enpODg46M/rVovqsLe3B2D58uV8//33uLu7s3PnToMyhTx8qNu8Ii8vDyEEDx48wN/fX1/3sWPH9PUVpXFjXWqAZs2aAWBlZUVubi5arZawsDDq1dOprehjU/FzW7duLVG3vb09gYGBHDx4kDVr1jB69Gj69u2LlFIva0XRaDRotVquX79O69atAbh//z5paWl06tSpRPnjx4/z0ksvodFo9NcDODg4kJOTU6m2FRVDjevKj+vSiImJ4cknn8TFxcXg+KpVq9i1axdt27Zl7NixvPbaa1VqRxljdIPj0qVLREZGkpOTo39MmTRpEp6enty/f5+FCxdy8uRJ/TUrVqzgzp07ODo60rBhQ1q0aEFISAhhYWH6xzmtVsuCBQu4fPkyq1ev5vXXX8fX15cWLVrQvn17unfvXik5/fz8mDFjBo6Ojjg7O9OjRw8iIyN5+PBhiXOlodFoGDx4MIMHD+bu3bvs2bOH5s2b07lz5xIziOJ4eXmRkJBAYGAg0dHReHh4MGPGDPLy8li+fDkAu3fvNnjkCwgIYP78+TRr1owtW7YQEREB6GYy/v7+WFtb4+joqFwV1YQa15Uf15999hnbtm3DxsYGW1tbMjMz2bx5M6+++irXr19nwYIF+nE9atQogoODsbOz48UXX6xUn0tDxRlXI2PGjOGTTz6p9nZqIyrOuPKocW1+VGYcK2OsMEuUMa48alybH5UZx8pNYQKmTp3K+vXr9Y99oHv0K/SjVgc7d+7k6NGj5ObmsmnTJho1aqRvd9asWWRnZ9OwYUM2b97M7t27+fzzz6lfvz6BgYG0a9cODw8PGjduzFNPPUVYWFi1yamwTMx9TMfHx/P9999z48YNnJyciIqKomPHjrz22mv87W9/w8PDo9rkrDBSyjr30XW7erh27Zr09fWVPj4+cvXq1fLq1avylVdekStXrpRTp06VmZmZskePHnL+/PkyKSlJ9u7dW0ZFRcnvvvtO+vr6ynfeeUf6+PhIKaUcNmyYjI6Oll5eXjIxMVHOmTNHpqamypycHDlp0qRKyTVmzBgppZSHDh2S27dvL7WMu7u7zM/Pl2PHjpUPHjyQt2/fltOnT5c//PCDjIiIkFJK6e3tLa9fv16FO1QxCnRk8rFiSZ/qGte1YUwXMmfOHPnTTz9JKaV0cnKSbm5u8vDhw49zWypEZcaxmhkbmY0bN2JjY4ONjQ1JSUmMHDmSrl27EhgYyNy5c8nKyuK5554jNDQUW1tbGjZsSEhICMnJyTg4OBAeHk54eDjJycnk5+fj7+/PvXv3CAkJISgoiLi4ODp06MD48eMN2o2IiCA9PV3/fciQIQwZMkT/vfCteLt27UhKSjK49vz584SFhdGyZUs0Gg2BgYH4+vry5JNPkpGRwfPPP8/+/fsJCAggLS2Nmzdv0qZNm2q8iwpzojaMaYCcnByuXr1K586dAV0YnpSSYcOGMXTo0Gq5d5VBGWMjo9VqmTx5Mk5OTgBcu3ZN//hUv359cnNzDR7dCsN0pJT6wVX4r1arJT8/Xx9C1KlTJ9LS0rhw4QK7du0yaDc/P98gjOdRK5SKhqIV0qVLF/bt24e3tzcpKSn07NmTnj176uM0NRoNS5cuBWDatGnlBtMrahe1YUy3a9eOTz75hFGjRunLFMpsbW1d7S6ViqCMsZHx8fEhNDSUli1bYmdnV+qqnF69ehEcHIyXl5f+WPfu3YmNjSUoKIjs7Gy6deuGlZUVS5cu5fLly4SGhgK6QPNbt26VGDjh4eFlyjVy5Ei9H23Dhg2cOnWKhIQERo4cSVRUFFqtlnr16tGmTRsOHz7MoUOHyMrKYuXKlQB4e3uTl5eHs7MzzZs3r+ptUlgQtWFMA+zdu1dv8C9evKgPyRwwYIDJDTGgfMbmzOjRow2+Hz9+XI4dO1ZmZmaaSKKaA+UzrpXjuq6N6cqMYxXapjBLVGhb5VHj2vxQoW21kK1bt+rX6xuD0sJ/kpOT9VnU5s+fT5cuXUqUUSiMgbHHM4CnpycnT57Uv8xbvHgxFy5cwMHBgUWLFnHv3j2WL19OTk4OPXr0YN68eUZr2xgoY1yN7Ny5k2PHjmFnZ8eyZcvYu3cvZ8+eJTMzkw0bNhAZGUlGRgYZGRk4OTnx22+/kZqayo4dO3BxcWHgwIFcuXKFWbNm6etMSUlh1apVSCnp2LEjgwcPJjw8nLZt2+Lm5ka3bt0qJJtGoyE2NhbQvZTTarWsXbuWDRs2IIQgODiY2NjYEmXMwremMAnmPJ4BYmNjDZbj16tXDysrK+rXr0+TJk146qmn2LJlC4DBizxzQRnjaiQ1NRUnJydGjBhBgwYNAN0AuXnzJgkJul3Qx40bR9euXXF3d2ffvn14eHiQkZFRIgSoV69eQMkwo5dffhkHBwcmTJhgMHDT09P1uSAK8fHxMUjiUzz85+7duzRp0gSAe/fulVpGUXcx9/FcnNDQUDQaDQcPHuSDDz7QZwzctWsXr7/+ulHvjTFQxrgaCQ4OJjExkaCgIJYsWcKePXs4ePAg4eHh+nytjRs3pkGDBvqMVkUzWRUNASqkeJgRQKtWrYiPjycxMdHgTXfxjFXF/YnFw3/s7e25e/cuQgjs7OxKLdOuXTvj3iSFxWDu47k4hZOH5s2bk5ycDOgMcUpKitm5KEAZ42olLi6Oy5cvo9FoeOKJJ2jZsiUrVqzg9OnT9O/fv8xri4cAnTlzBigZZtSvXz8OHTpEenq6QQo/R0fHMjNWpaWllQj/8ff3x8/PDyklwcHBpZZR1F3MeTwDLFiwgISEBLy8vFi7di2rVq3ixo0b3Llzh/fee0+fnc3FxYWAgABiYmKqflOMiIqmMFPqemYsFU1Recx5XNfV8ayytpWDOQ9ahQ5ljCuPGtfmR2XGsXojo1AoFGaAMsY1SFV22n0UvXv35uDBg1y8eJFp06YxYcIE/TJPgKSkJJo3b05WVlap17/77rvMnDmT4cOHk5qayu3bt/W7PLdt25bMzEx2796Nm5sb06dP58KFC+Tk5OhTJirqNtU5pkEXO1x855DiY7q0MsUpXubw4cO88cYb+jFsFmO6okv1atOHalg26uHhIe/cuSPz8/Pl+PHj5c2bN2VoaKj09PSU+/fvl1L+uRS08N9NmzbJo0ePyjNnzkg/Pz/p7e0td+zYUal2iy8vlVLKt956S0op5YMHD6Sfn590c3OT9+7dK7Oeffv2GaQh/PXXX6Wbm5uUUpZIqSmllEePHpXr1q2rlKyVAbUc2uTj2lzGdNHvjxrTpf0Oyqu3+BiujjFdmXGsoimMhKurK3v27OHpp5/m1VdfpV69euTm5tKiRQs++ugjRo4c+chrY2JiDHbXnTRpkv5ceWkEi1M0hjI6OhpfX199xrVHkZWVxZ49e4iLi9Mf+/DDD/VhRcVTairqBuYypotS0TFtiShjbCQGDhxIXFwcP/74I1FRUcTHx/Pmm2/y0ksvMWLECIOyhfGPf/zxB0CJ3XWLUtE0glAyhvLs2bPcvn2b06dPExsby9y5c0tck5mZyezZs1mxYoU+tlhKydGjRwkKCgIokVJTUTcwhzFdnIqMaUtFGWMjodFoaN++Pbdu3aJJkyb07t2bzZs3c+LECaysrAzKtmrViujoaI4fP84LL7zAvHnzDHbX9fX11ZctL41gIaXFUO7evRvQbYnj6ekJQGRkJAsWLNBfN3XqVPLy8oiMjMTV1ZVXX32VY8eO8corr+iD80tLqamo/Zh6TEPJ2OHSxnTxMt988w1NmjQx2LG5eJkzZ84QExNDRkYGLVu2ZPTo0VW5Vcahov6M2vTBAlINVpSK+MoKuXfvngwPDzdKu8pnbH6f2jKuKzOmS2Pp0qXy999/r/R1pvYZq2gKC8fBwUH/5rk8bG1tWbRoUZXbzGVM+j8AACAASURBVMnJ4cCBA7Rq1arKdSkUxanMmC6NBQsW6HcbqSjmMKbVog+FWaIWfVQeNa7ND7XoQ6FQKCyMOvkCz9ra+rYQooWp5VA8Gmtr69umlsHSUOPa/KjMOK6TbgpTI4RoDnwDfCCljDa1PABCCBvgf4ALgLd63lUYGyFEH2A70FlK+bC88uXUtRv43lx+P8ZAGeMaRgjhABwFDkopq/42zYgIIRoDXwJfA8HKICuMiRDiM+AzKWWV9+8SQjwHHAY6SClzqiycGaB8xjWIEMIW3QA6CvzDxOKUQEqZCQwBBgNhJhZHUYsQQjgBfwO2GqM+KeVZ4CwwpbyyloKaGdcQQghr4HPgKjDTnGedQogn0blRNkop15haHoXlI4TYCSRIKY22akgI8Qo6415lt4c5oGbGNYAQoj6wF/gV8DRnQwwgpfwF+DswRwgxw9TyKCwbIURH4DXAqNuLSym/BdKAscas11QoY1zNCCH+AuwAJOAmpcw3sUgVQkp5Hd0PKFwIMd7U8igsmmBgs5TyXjXUHQXMF0U31rNQlDGuRgoGSCzQDHCVUuaZWKRKIaW8jM6HvEYIMdzU8igsDyHEU+hmru9VUxP/A2iBYdVUf42hjHE1UWCIY4CuwAhLfeMrpUwChgPxQohBppZHYXG8A2yXUv63OiovcPnVitmxeoFXTQghItAZsVellBafBFgI0Q/4BN0fllOmlkdh/gghHIErQA8p5Y1qbOcvwE/AdCnlN9XVTnWjZsbVgBAiCHAFBtcGQwxQMMjdgAMFMZ4KRXn4AAeq0xADFLyHWQGEVmc71Y2aGRsZIYQXMA94RUqZamp5jI0QYjSwDt2M/ydTy6MwT4QQjdCFcb4ipbxYA+01AH4G3pRSnqnu9qqDOpmbwtgIIayklA+EEJOABcCA2miIAaSUnxb80L4ocF1cA+pLKR+YVjKFOVDgMvgASAS+rglDDCClzBVCxAAh6J5KLQ41M64iBYs5rgGzgfXAICnleZMKVQMIIbyBucBSYKCU0s3EIinMgAJj/AC4BawGjkspv6uhtm3Rzcb7SCkv1USbxkQZ4yoihHgDeBd4EpgopfzCxCLVCAWPhfOBt4EWQHM1O1YACCG0wA0gD3ijJg2jEOIfQFsp5fSaatNYqBd4VccDeBbIBDYWrLarC7wMzEE3hmzRxSMrFIWkAS+aYIa6DnhLCNFaCNG5htuuEsoYV51n0GU6m45ujbxFLex4XKSUXwOtgQjgOtDftBIpzIix6FwFpogkygQ+BBYCX5mg/cdGuSkUCkWtQQgxD118f3fgnpSytYlFqjAqmkKhUNQmogE7wBmwiDwwhVR6ZmxjY/NLTk6O2trFDLC2tr6dnZ395KPOK13VLOXpA5ROTE1FdGQqKm2M1Q605kN5O88qXdUsFdkJWOnEtJjzruPqBZ5CoVCYAcoYKxQKhRlgMcZ4zJgxJY49zuOeVqst9f9llStOTk7FsmGmpaUxceJE3NzcOHr0qMG5o0ePMmXKFCZOnEhaWhp3795l2rRpDBw4UF/mwoULzJ49Gz8/P86fr/lFfaXdg9L0UNqxR1GRsmXd+9KoiD4uXrzItGnTmDBhAsuXLwcgOTmZiRMnMnHiRJKTkw3Ku7u74+7uzpQpU8jPz+fAgQPMnDmTESNG8P/+3/+rlHzGpDbppE2bNgghavQDOleRuXxsbGx+KbwfVfYZ79y5k2PHjmFnZ8eiRYvw9/dn69atfPrpp+Tl5XHkyBHatm3LhQsX6NevH9evX+fhw4esXr2a/v37069fPy5evMiAAQP4/vvv+fvf/864ceNYsGABubm55OfnM2PGDN5++21cXV0ZM2YMnp6eDB8+nL/85S/079+fnj174urqyu7du/U3fNOmTVy6dImMjAyWLl1KWFgY7du3p3v37nz44Yf07t2bF198kZMnT5KRkcHdu3eJjY3Fw8NDX2706NEGfT916hS7d+/mjz/+4P333y/3Xi1ZsoSRI0fStWtXJk2axM6dO/Xnxo0bx8cff8z58+fZv38/CxcuBHQ/jE8++QSA6dOn06JFC3Jzc1mwYAGOjo7FdVEpn7G/vz9LliwhICCAgQMHYmVlhZWVFQCHDh0iJyeHxYsXc/z4cb788kucnZ3Jz88nJSUFe3t7xo0bh6urK66urgQGBmJra0tycrLBsSVLluj1Fh0dzaRJk4iLi8Pb25sVK1YwePBgXF1dmTFjBnPmzOGTTz5h8+bN/PWvf+XYsWOkp6fz/PPP07p1az7//HOys7MZPXo0r7/+ukHfbt26xT//+U+SkpLw9fXlxRdfLFcfhYwaNYp9+/Yxc+ZMVq5ciRCC4OBgYmNjS5T19/cnMDCQNm3aAJCRkUFgYCDx8fGl3e9K+4zrsk4K7leZZWo7RcdMlUPbUlNTcXJyYsSIEdjb29O+fXsuX77Mvn372Lp1K0eOHMHLy4v//ve/bNu2jZiYGP1f4gYNGrBkyRLWrl1L69atmTVrFuPGjcPR0ZFr167x7LPPkpKSgoODA126dGHx4sVcu3aNLl26EBISwt27dwkJCSE7O5v+/fvrDXFWVhbbt29n8ODBAJw5o0viNHPmTFq1akV8fDzBwcHcv3+fnTt38uGHH7Jt2zb9jKewXCGnTp0iJCSEiRMnsnjxYpo0aQLAkSNHOHLkiL6co6MjixYtMrg3bdq0QaMp+QAipUSj0dCuXTtSU0vPKfTvf/+br7/+mtTUVNasWUNERMRj6wmgb9++fPvtt9jb25OYmEhOTg7h4eHMmDGDTz/9lJSUFNatW0e3bt0YOnQoEydOJCgoCGdnZ4YOHUqzZs30eiikW7du+mP/8z//Y6C327dvExkZSd++fYmJiaFNmzYlri/OuHHj6NOnD8OHD+eFF16gSZMmnD592uCHP2zYMDp16oSHhwdBQUEApKenl7g/Pj4+dOrUyeDYrl279HXdvXtXr8t790ruCPTTTz+Rm5urN8QAS5cuZfbs2RW74RVA6URRSJWNcXBwMImJiQQFBbFkyRK8vLzw9PTE2dmZ+vV1K4MbN25MZmYmjRs3Nri28HuDBg1o3LgxQgi0Wi1arZY+ffrg5+enL1s0ib+9vb3+X1tbW1avXs2OHTv056WUtGrVymCA7du3T39dw4YNqVfPsOul1V+Ik5MT06ZN4/jx46SlpTFhwgSeeeYZtFotDx/+uSltfr5hWGPr1q1JTU0t0W8AjUaDVqvl+vXrtG5delx6hw4daNSoEQ4ODqUai8oyYMAAvLy8eO2117hy5Qrp6ek4ODjoz5d2D5YvX87333+Pu7s7O3fuNChT/LrS9PbNN9/QrFkzMjIySrRR+Efqjz/+KNGuVqslLCyshJ4A5s+fzyeffMLGjRsZPnw4r732GoCBLqCkG2vXrl2kpKQwb948fVt3795FCIGdnZ1B2eTkZNasWcPGjRv1dYWEhDB06FD+9re/lZDpcanrOlH8SZWNcVxcHJcvX0aj0fDEE0/g6OiIlBIPD4/HrnPw4MF4eXkRFBTE77//zrp162jRogUhISFMmjTJoOzo0aP5+OOPDX5MdnZ29OzZE19fX6SUTJs2rdR2GjduTLt27Zg7dy7p6enExsbqXQRFadSoEVOmTGHKlCmkpKSwY8cOwsLCeOONN3jjjTce2Y/p06cTEhJCvXr1mDFDt8ny5MmT2bFjBx4eHsyYMYO8vDy9D9PLy4uEhAQCAwOJjo5mzpw5eHp68uDBA8LCwip9H4vTrFkzLl26RGRkJDk5OXo/4KRJk/D09OT+/fssXLiQkydP6q9ZsWIFd+7cwdHRkYYNG+r1EBYWhq2tLYDBsf379+v1Fh0dzcaNG/nyyy/x8PCgV69edO3alcDAQPz9/WnVqhXR0dEcP36cF154wUBWPz8/ZsyYgaOjI87OzkyYMEF/rm/fvvTt25fs7GwOHDjA6dOn6dWrF+vXr39k3wvvq4uLCwEBAcTExODv74+fnx9SSoKDg/X62bZtG6+99hpDhw7Fz8+PsLAw9u3bx5dffsndu3e5cuUKXl5eVdZHXdeJMZg6dSrr16/X9xt0fzRKexo1Fjt37uTo0aPk5uayadMmGjVqpD8XEhLC/fv3adiwIe+++27lKpZSVuqju+TRrFq1Si5atKjMMsbi3Llz0tXVVV67dq1G2jM3CnTx2LpSGJfy9CGVTgwo715cu3ZN+vr6Sh8fH7l69Wp59epV+corr8iVK1fKqVOnyszMTNmjRw85f/58mZSUJHv37i2joqLkd999J319feU777wjfXx8pJRSDhs2TEZHR0svLy+ZmJgo58yZI1NTU2VOTo6cNGlSpeQeM2aMlFLKQ4cOye3bt+uPp6SkyICAACmllIGBgfL69esVvQdIKY2/HDogIMDYVT6SLl26sHv37hprT6FQ1BwbN27ExsYGGxsbkpKS9C/DAwMDmTt3LllZWTz33HOEhoZia2tLw4YNCQkJITk5GQcHB8LDwwkPDyc5OZn8/Hz8/f25d+8eISEhBAUFERcXR4cOHRg/frxBuxEREaSnp+u/DxkyhCFD/kxKWOjWadeuHUlJSfrjN2/e1L9faNu2rf6dUUWxmNwU5vY44unpycmTJ/XKOHDgAEeOHOHGjRssXLiQnj17MmvWLLKzs2nYsCGbN2+uNjnNBXPS0f379/Hw8KBx48Y89dRThIWFsXv3bj7//HPq169PYGAgzz77bLXJZS6Ys07KQ6vVMnnyZJycnAC4du2avq769euTm5tr0I9C37aUsmgYm76u/Px88vLyEELQqVMn0tLSuHDhArt27TJoNz8/38DX/aiwvuLve1q1aqV/GX/jxg1GjhxZbh8NkBV0T8hqfMyytMeRQkaPHl3i2JkzZ+SaNWsMjrm7u8v8/PxKtV0RqEE3haXp6IcffpARERFSSim9vb3l9evX5dixY+WDBw/k7du35fTp0410Z/6kPH1IpRMDnZR3L65duyYnTJgg586dKxcvXiyvXr0q586dK6WUct68efLq1asyLi5Ozpo1SyYmJhr8HmfPni0DAwPl7NmzpZRSuri4yLCwMDlu3DiZmJgopZTy448/ljExMZXqm5RSfvTRR9LLy0tOmTJFZmVlyZMnT8oNGzZIKaUMCQmR77zzjgwJCalQXVSnm+JxsLTHkUexcuVKdu3axbZt2wA4f/48YWFhtGzZslpnIjWBpeno+eefZ//+/QQEBJCWlsbNmzcJDAzE19eXJ598Uh9JYMlYuk7Ko127dnz00UcGx6KjowH0L8dmzpypP1f05XvxF4eFYbSFnDhxgn379pUaL14eEyZMMHh52atXL3r16gVAVFRUpesrxCyMsaU9jjyKoKAgpkyZwrx58/jwww/p0qUL+/btw9vbm5SUFNq1a1fRW2J2WJqONBoNS5cuBWDatGl06NCB5s2b07NnT65cuVLtb/lrAkvXSU1SPEqqT58+9OnTp0ZlKA+zMMY+Pj6EhobSsmVL7OzsmDJlSokyvXr1Ijg42CCkqHv37sTGxhIUFER2djbdunXDysqKpUuXcvnyZUJDQwEYNGgQt27dKjE7DQ8PL1OukSNH6v2+GzZs4NSpUyQkJODt7c2CBQtISEjAy8uLtWvXsmPHDhITE7l79y4zZ84kLS2NqKgotFot9erVq5Qj3xyxRB15e3uTl5eHs7MzzZs35/Dhwxw6dIisrCxWrlxphLtiWixdJx9++KER7kLZbN26laZNm+Li4mK0Oou/L3r33Xf5+eef+eWXX9i0aRN//PEHy5cvJycnhx49eujj2suj1qXQLLqcGHSPI2vXriU+Pr5EYL+lY6kpNGurjiw5haYpdPKo5dBFUywsW7aMvXv3cvbsWTIzM9mwYQORkZFkZGSQkZGBk5MTv/32G6mpqezYsQMXFxcGDhzIlStXmDVrFmfOnKFp06Z0796dVatWIaWkY8eODB48mPDwcNq2bYubmxvdunWrlOzF7xfA/v37ycrKYvLkyfpjhUvvy7kHxlkObW5YwuNIXUfpyPwwJ50UTbHQoEEDAOrVq8fNmzdJSEgAdEu0u3btiru7O/v27cPDw4OMjIwSvu9CX25x//rLL7+Mg4MDEyZMMDDEj7uEOysriz179hAXF6c/VnTpfUWodca4EGM/nly8eLHEo8etW7eIiopCSsn48eN5/vnnS4RTKcrG2HrSarWlhhQmJSUxaNAg/vOf/xiEeSkeTXXr5lEUT7GwZ88eDh48SHh4OPfv3wd0q2cL0ygAWFlZkZubW8L3XbTtov51QJ+nJjEx0cDFU9kl3JmZmcyePZsVK1bonyKKL72vCGZljI35eFJISkqKUR5POnfuzJYtWwDdowfo3uza2dmRlZVF69atuXDhAp07d2bhwoXMnj2bGzduWLyvuDTMWU8ajUaffW3atGn6H+cHH3zA0KFDq+V+mBOWpJtHUTzFQsuWLVmxYgWnT5+mf/+yNyEv7vsuTBJW3L/er18/Dh06RHp6uj6PBuiSfZX3crf4+6KpU6eSl5dHZGQkrq6uODg4lFh6XxHMyhhbwuNJ0UePc+fOsXbtWpo3b64PBSoeTlUbjbG566l4SOHy5cvx9fXVv8mvzViSbh5F8bw2hQa8MH/IgAED9Oe2bt0K/BnKVjyErehMuHiYXNHc4ZUhMjKSyMhI/ffSfMKPysRYFmZljM398aT4o0fr1q1xcHDA1taWnJycUsOpaiPmrqfiIYVnz57l9u3bnD59mtjYWObOnWv0e2IuWJJuqoPSEn1ZCmZljM358aS0rF8BAQEEBwcjhNA/1hUPp6qNmLOeSgspLMxfMnXqVDw9PY1wB8wXS9LN41BaFENV6d27NyEhIbz55ptGC1srnr3tyJEjhIWF8cMPPzxaEFnO8s3iH8w061RpS5NrO1hg1rbarKfy9CHNVCeF1LRuit8LDw8PeefOHZmfny/Hjx8vb968KUNDQ6Wnp6fcv3+/gYyF/27atEkePXpUnjlzRvr5+Ulvb2+5Y8eOSslRvN+l3Yd9+/aVSInw1ltvlVrfo7K3lVYv5rYc2hhY8uNJXULpyXwxtW5cXV3Zs2cPTz/9NK+++ir16tUjNzeXFi1a8NFHH5WZeCcmJoaOHTsCuqfYonnPy1u+XR6VDVt73OxttcYYKxQKy2bgwIHExcXx448/EhUVRXx8PG+++SYvvfQSI0aMMChbfEeSBw8e4O/vb7BLSiEVXb5dGo8Ttva42dssJntNZXa7rSi9e/fm4MGDAHTs2BEvLy+Dv35FKW134Vu3buHn54evry8nTpzQl/Xy8iIwMBDQ7ZPn7OxsdNnNierWjaenJ927d9ef2717N25ubkyfPp0LFy6Uev3hw4d54403DHyYxXWsdPN4GEs3xdFoNLRv354//viDJk2a0Lt3b+Lj44mJidFv0lpI4Y4k3377LQDz5s3D19eXuXPnsm7dOoOy4eHhrF+/Xv8pa3eeomFrubm5TJ06ld9//53IyEj+93//V//u6OrVq/rc7V988QXff/+9vo62bdtSv359AgIC+Mtf/lLxiCpZCX+xrCaflzn4ipycnKSbm5s8fPhwudcV+ooCAgJkaGio9PPz0+82snfvXvn+++/rU/0Vb8eYUAM+Y3PQTfHvFU2FefToUblu3Tr999J0bEzdlKcPaeTfj6XrpjpsyeNQ1TGwdOlS+fvvvz9WO5ibz9gcfEUJCQlIKRk2bFiZiwPKijOOjIwkISGBmTNn8tNPP1XqHpgr5qCb4jxuKsyK6thSqE26MSUODg4cPHiQN99887GuX7BgQblljhw5YrA5RWmYhTE2B19RYb3W1taP3AmhvDjjr7/+ml9//ZWIiAgSExO5dOkSzzzzTCXvhnlhDropTs+ePR8rFWZFdGxJ1CbdmJL333+/2tuoyB80szDGhb6iW7du6X1Fmzdv5sSJE4/0FRXuXlvoK2rRogXt27fH19dXX7a8VH+FFOadAN3qHo1GwxdffEGTJk148cUXgYrFGffp0wdXV1euXbvG+vXrLd4Qg+l1AyWXn3711VclUmFGRkYazFBOnTpFTEwMGRkZtGzZkm7dupXQsaVj6bpRFENWwE8sq8nnZWrK8hVV1A9U1XaqAhYYZ1xRKnPP7t27J8PDw6u9nfIoTx/SwnVSiLF0UxvuRVUpOmYsf3pQBQp9RaWxYMEC/c4IVaEiviJFScrSTXFsbW1ZtGhRpdtQunk8jKWbdu3aIYSo0x9ra+vbhfej1iWXr0tYanL52oolJ5evK1RER6aiTs+MFQqFwlyo9As8a2vr20KIFtUhjKJyFH3EedR5pauaozx9FJZROjEdFdGRqai0m8KcEUJogGTAT0r5ZRXrigeuSykr/mpZ8UgKdJMIBEkpj1SxrljgVynlQqMIV8cRunyZCUCYlPKzKta1AciUUs43inB1iNrmpngT+AP4ygh1LQdmCyHUHj3GYRjwEPi/RqhrBTBLCNHYCHUpYAg6W/C5EepaCXgIIZoYoa46Ra0xxgV/3UOBKGO8IZFSXgK+BjzKK6som2rQzc/AF4BXeWUVFSIUeNdIurkGHAaqJ3t8LabWuCmEEIOA9UBXKWXFlwyVXeffgINARyllrjHqrIsIIQYAccCzUsp8I9XpBBwBOkgpc4xRZ11ECNEX2AZ0llI+LK98Bevsiu7ptIOU8r4x6qwL1JqZMTAf3V93oxhiACnlGXQ+6MnGqrOOMh9YbixDDCCl/BE4A0w1Vp11lPnACmMZYgAp5Tng/wMeveuoogS1YmYshOgJ7AU6SSnzjFx3f+AD4K/GNCZ1BSHEC8C/0M2SHhi57j7ADuAZYxqTuoIQ4jl0LgWjP10IIV4C9lANv8naSm2ZGc8HoqtJ6d8AvwLGTwxbN5gPrDK2IQaQUp4AbgDjjF13HSEEiKkON4+U8jvgCjDB2HXXVix+ZiyE6AL8L9XonxJCuABLgefV8qmKI4T4K7o/Zh2klFnV1MYQdG/wexjTRVXbEUJ0Ak6h0829amrj78B7QDelm/KpDTPjEOC9an5R8Dm6e1XxjbMUAMHA+uoyxAX8XyAPXeicouIEA5uqyxAX8BW6UNMR5RVUWPjMWAjRHvg3umiH36u5rbcBbynlK9XZTm1BCNEWOIvOZ5heXvkqtjUWCAB6qyeX8hFCtAKS0Pna71RzW2+hC53rqXRTNpY+Mw4E3q9uQ1zAXuCpglAgRfnMBbZUtyEuYB/gCPSvgbZqAwHAtuo2xAX8C2gEDKqBtiwai50ZF6zvv4AudrVG1psLITyBN6WU6pG4DIQQzYCL6HyFaTXU5nTAVUo5uCbas1SEEE8AlwEnKWVqDbU5BXCTUiqDXAaWPDOeA3xcU4a4gG3A8wUhQYpH4w/srSlDXMAOoGtBKJ3i0fgC+2vKEBewE+hUEO6meAQWOTMuWPf+M/BCwfLLmmw7EHCWUo6vyXYthYJ8Ef8BXipYtlyTbc8B+kopVRhiKRTkWbkK9ClY7l+TbfsAf5dSPnqX1DqOpRrjUHTuiRpfGSeEsENnbHpJKa/UdPvmjhAiGF0I4NsmaLsROmPTT0pZO7bnNiJCiADgZSmlqwnabojudzOoYIWeohgWZYyFEBOBZujC2UymVCFEBPAk8BQwWUppGXuSVyNCiPHo7kcQMLhgubIp5FgEtAeaAtNq6CWVWSOEGAP8H3Tuo+FSygQTyREK/BWwA7xq2MVo9liaz7glMBz4EfAvyJFbowghnIGG6FbkFf5fofvj5AKcB3yFEH+paQGEEM8DTYCRwAvo3uIrdLp5A92LO28hRI3vCl+Q2KkpunjwFwCVmrYYNa6UKvIQ6AtkAZ+ZaFXPJXR/3bPRDS6jL/O1UB4CvdEF+X9uojweV4COKN0UJw/ohU43/2OiPB7/QffEkgM0R+mmBJY2M25X8O9bUsr3TCGAlDITXRL7jwErdINLAW3RjacxUsoYUwhQsJrsLWA7SjdFaQP8BV3o3wpTCFCwCnM08CHQAFApaYthaT5jG6CxufiahBDtazqaw1wRQlgDDlLKW6aWBZRuiiKEaAA4Kt2YNxZljBUKhaK2YmluCoVCoaiVGLzAs7Gx+SUnJ6fWbCPeoEEDcnNrn2uqNvSrNvShkNrUl6LU1n6VhbW19e3s7OwnTdG2gZtCCFGrEisJIahN/SmkNvSrNvShkNrUl6LU1n6VRUGfhSnaVm4KhUKhMAOUMVYoFAozoMrGeOrUqWRlGW7koNVW71qMnTt3MnPmTNzc3Pjjjz8M2vX09MTNzQ0vLy+jtGVO/QMICQmpUt3m1p/KYG6yb9myBV9f38eq15z6cv/+fSZNmoS3tzdLly4F4NatqkXBmVP/QPe78fPzq/Lvp1qRUuo/uq9/cu3aNenr6yt9fHzk6tWr5dWrV+Urr7wiV65cKadOnSozMzNljx495Pz582VSUpLs3bu3jIqKkt9995309fWV77zzjvTx8ZFSSjls2DAZHR0tvby8ZGJiopwzZ45MTU2VOTk5ctKkSbIyjBkzRkop5aFDh+T27dtLLePu7i6L96c4lta/lJQUGRAQ8Mh+WVJ/LH2s3b59W77++uty3rx5Ft+XH374QUZEREgppfT29pbXr1+vNeNMyj9/N1JKGRgYKK9fv/7IOgr6jCk+ZS6H3rhxIzY2NtjY2JCUlMTIkSPp2rUrgYGBzJ07l6ysLJ577jlCQ0OxtbWlYcOGhISEkJycjIODA+Hh4YSHh5OcnEx+fj7+/v7cu3ePkJAQgoKCiIuLo0OHDowfb5iNMiIigvT0PzeIGDJkCEOG/Ln9nBA6/3q7du1ISkoyuPb8+fOEhYXRsmXLcv8QWVr/bt68SZs2bWpNfyxZ9v/85z84Ojry7rvvsnz5covuy/PPP8/+/fsJCAggLS2Nmzdvcu7co3NwWVr/iv5u2rZtS2pqapm/I1NRpjHWarVMnjwZJycnAK5d9kGxHgAACZlJREFUu0ajRrrcK/Xr1yc3NxeN5k9Ph729PaCbbRfemMJ/tVot+fn55OXlIYSgU6dOpKWlceHCBXbt2mXQbn5+Pg8f/rl8/lGPN9evX6d169YGx7p06cK+ffvw9vYut/OW1r9WrVqRmvronOCW1h9Llr1Vq1Y4OjrWir5oNBq9e2LatGl06NDhkXqyxP4V/d3cuHGDkSPNM6VymcbYx8eH0NBQWrZsiZ2dHVOmTClRplevXgQHBxv4aLt3705sbCxBQUFkZ2fTrVs3rKysWLp0KZcvXyY0NBSAQYMGcevWLQPFAYSHh5cp9MiRI5k1axbZ2dls2LCBU6dOkZCQwMiRI4mKikKr1VKvXvk5kCytf97e3tSvX79W9MeSZS/UhaOjIwEBAbWiL97e3uTl5eHs7Ezz5s0JCAggPj6+1HossX/169cnICCABg0amOWsGCjbZ2xMRo8ebfD9+PHjcuzYsTIzM7Pa2qzO/hSnJvtXE/2q7v7UprFWm/pSlNowzioLJvQZq0UfFkht6Fdt6EMhtakvRamt/SoLUy76MGk+461bt9K0aVNcXFyMUl9+fj6TJ0+mUaNGPHhQM+lSjd0HAE9PT06ePKl/CXH48GG2bNmCRqNhxowZRmunLGqiXzWFsfty8eJFli9fTk5ODj169DBKnZWhpsZcTVATfXn33Xf5+eef+eWXX9i0aVOZ/nBTUmljvHPnTo4dO4adnR3Lli1j7969nD17lszMTDZs2EBkZCQZGRlkZGTg5OTEb7/9RmpqKjt27MDFxYWBAwdy5coVZs2apa8zJSWFVatWIaWkY8eODB48mPDwcNq2bYubmxvdunWrkGzZ2dk0aNCA999/n9mzZ1tkHwBiY2MZM+bPPTVPnjxJZGQkjRs3Zs2aNbWmX2Vhzn3p3LkzW7ZsAWDUqFEW3x8ofczVlr4Uxhbv37+fo0ePMnlyjW+dWSEqbYxTU1NxcnJixIgRNGjQQFdJvXrcvHmThATd1lrjxo2ja9euuLu7s2/fPjw8PMjIyCgRxtKrVy+gZKjMyy+/jIODAxMmTDBQQnp6OhEREQby+Pj40KlTJwAaNmyIEIJhw4aVGdpmzn0ojbfeeoupU6ei1Wp5//33WbGi9PzgltavsrCEvuzatYvXX3+d/fv314r+FOWtt94iMjKyVvQFICsriz179hAXF1dmOVNSaWMcHBxMYmIiQUFBLFmyhD179nDw4EHCw8O5f/8+AI0bN6ZBgwY0btwYACsrK3Jzc0uEsRRSPFQGdOEo8fHxJCYmGrytLRraAhj4tM6cOUP79u3ZsmWLPlTH0vpQGlFRUXz99deAbmVTbelXWZh7X3bt2kVKSgrz5s0zmOFZan+KExUVVWv6kpmZyezZs1mxYgV2/397dxPSZBzHAfy7EbWD0azDDEGE0SXQS6ggaCUIiZoQNQJjCaYOQb3ohAZCkCimgigoggSGSEEvKHhIYh304sFBCAV1NZmI7wc17Nchtub27E2d++/p+7nI8Hn7sv/zw/2fn/9dvBhx22SKuxiPjo7i+/fvMBqNuHLlCq5evYqenh4sLCzg5s2bEfcNbmNZXFwEENoqU1xcjOnpaayvr6O0tNS//+XLlzE0NBT2+NevX0dfXx8aGxuxthb+S4FVzgAALpcLHo8HDocDAwMDuHfvHurq6iAiuHPnDiYnJ1M+VzQqZ/F4PGhtbUVFRYVma1uq5QG0x9zbt291kaWmpga/fv1CZ2cnbDYbSkpKIu6fNIGtFUhwK0twG0uiJSLPWWfQoodciRxresoikrwxp4dxFi+wtS0x9Nqao4dcesjgo6csgfSaKxKuZ0xE9J871WIca9tSPAoLCzE1NQUAsFqtcDgcYZ+Ier1eOBwOOBwOZGVlHet8ic4Qy1J+DQ0NyMnJ8b+emZnB/fv3YbPZ8PHjx2Ndg4q5jivRWYKv8/Xr17Db7aitrcXXr19P/dyJzBN8T2xvb2turzXmjuOs35vu7m7U1dWhsrIy7LotS0tLqK6uRnV1NZaWlrC3t4eampqoc89nLnDOAhHmiOrr62VtbU0ODw/l4cOHsry8LE+fPpWGhgZ5//69iPybD/L9HB4eFrfbLYuLi9Lc3CyNjY3y6tWruOZwAueYcnNzxW63y8zMTMR9VldXxW63h8x5JTtDPEv5BeZ2uVzy7ds3+fnzpzidTl3kCjfWkp1F6/WDBw/k4OBAvF6v1NbWhuyr+n0j8u+eiGcf1cZZuNciIu/evQu7nO6TJ09kY2NDNjc3pb6+XkRE3G63DA4OhmwLVZfQDGSz2fDmzRtcu3YNJSUlOHfuHPb392GxWDAxMRFxJaT+/n5YrVYAf59EP3r0yP+7aMviBfJ4PBARlJeXo6ysLOz5Xr58icePH2N8fFypDMddyi9an3Gq5tKS7CxaWltb0dTUhIyMDGxsbKRkHt89cRKqZAkWrYd4a2sLZrMZALCzsxPzcc9azMX49u3bGB0dxZcvX9DV1YWxsTHcvXsXBQUFqKqqOrKtb7Ul32r7BwcHaGlpQXp6eshxY10WL/C4JpMJv3//DlnVCfj7l77b7UZbW5tyGY67lF+0PuNUzaUl2Vm05OfnIz8/Hz9+/Ij7o60KeSLdE6mWJVgsPcSXLl3C1tYWDAaDPvqMjUYjsrOzsbKyArPZjMLCQoyMjGB+fh7nz58/sm1mZiZ6e3sxNzeHGzduoL29HU1NTbBYLMjOzj7yVTXRlsXz8a0HAAC3bt2C0WjE7OwszGYz8vLy/Nt9/vwZRUVFRxrKVcmQlZUVspSfVoZ4+4xTMVc4yc4SfJ0DAwP49OkTpqensbu7ixcvXgAAOjs74XK5oh5LhTzB90QsY87X/6tallh6iIPfm5aWFjQ3N0NE4HQ6Yz7XmQucs8AZLjkZq0h9ic+fP5fNzc2wv1clz0kyaNFDLlUy+MTT/7qzsyPPnj3zv1Yti8jpjDlVcp3kvQlHxTlj5Vvb0tPT/U9Sg7lcLv+3CKhMDxm06ClXpCzB0tLS0NHRkeArOhm+N+Ht7e3hw4cPyMzMPI3LOzX8p48UpIdcesjgo6csgfSaKxL+0wcR0X/uyAM8k8nkNRgMlmRdzGm7cOGC5oO8VKeHXHrI4KOnLIH0misSk8nkTda5Df/bxxAiIhVxmoKISAEsxkRECmAxJiJSAIsxEZECWIyJiBTAYkxEpAAWYyIiBbAYExEpgMWYiEgBLMZERApgMSYiUgCLMRGRAliMiYgUwGJMRKQAFmMiIgWwGBMRKYDFmIhIASzGREQK+AM1J8vhc7ebGwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.tree import plot_tree;\n",
    "\n",
    "plot_tree(tree,\n",
    "          feature_names = cancer.feature_names,\n",
    "          fontsize      = 7 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Set Accuracy :  0.9648351648351648\n",
      "Test Set Accuracy  :  0.9473684210526315\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score;\n",
    "y_pred_train = tree.predict(X_train);\n",
    "print(\"Train Set Accuracy : \", accuracy_score(y_train, y_pred_train))\n",
    "y_pred_test = tree.predict(X_test);\n",
    "print(\"Test Set Accuracy  : \", accuracy_score(y_test, y_pred_test))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Model Run for trees of *depth 1, 2, 3, 4, 5, and 6* and for the ***Gini Impurity*** and ***Entropy impurity*** measures for each tree depth. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Depth = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GINI IMPURITY\n",
    "tree_gin_d1 = DecisionTreeClassifier(criterion    =  'gini',\n",
    "                                     max_depth    =  1,\n",
    "                                     random_state =  0 );\n",
    "tree_gin_d1.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_gin_d1 = tree_gin_d1.predict(X_train);\n",
    "y_pred_test_gin_d1  = tree_gin_d1.predict(X_test);\n",
    "\n",
    "\n",
    "# ENTROPY IMPURITY\n",
    "tree_ent_d1 = DecisionTreeClassifier(criterion    =  'entropy',\n",
    "                                     max_depth    =  1,\n",
    "                                     random_state =  0 );\n",
    "tree_ent_d1.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_ent_d1 = tree_ent_d1.predict(X_train);\n",
    "y_pred_test_ent_d1  = tree_ent_d1.predict(X_test);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Depth = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GINI IMPURITY\n",
    "tree_gin_d2 = DecisionTreeClassifier(criterion    =  'gini',\n",
    "                                     max_depth    =  2,\n",
    "                                     random_state =  0);\n",
    "tree_gin_d2.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_gin_d2 = tree_gin_d2.predict(X_train);\n",
    "y_pred_test_gin_d2  = tree_gin_d2.predict(X_test);\n",
    "\n",
    "\n",
    "# ENTROPY IMPURITY\n",
    "tree_ent_d2 = DecisionTreeClassifier(criterion    =  'entropy',\n",
    "                                     max_depth    =  2,\n",
    "                                     random_state =  0 );\n",
    "tree_ent_d2.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_ent_d2 = tree_ent_d2.predict(X_train);\n",
    "y_pred_test_ent_d2  = tree_ent_d2.predict(X_test);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Depth = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GINI IMPURITY\n",
    "tree_gin_d3 = DecisionTreeClassifier(criterion    =  'gini',\n",
    "                                     max_depth    =  3,\n",
    "                                     random_state =  0 );\n",
    "tree_gin_d3.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_gin_d3 = tree_gin_d3.predict(X_train);\n",
    "y_pred_test_gin_d3  = tree_gin_d3.predict(X_test);\n",
    "\n",
    "\n",
    "# ENTROPY IMPURITY\n",
    "tree_ent_d3 = DecisionTreeClassifier(criterion    =  'entropy',\n",
    "                                     max_depth    =  3,\n",
    "                                     random_state =  0 );\n",
    "tree_ent_d3.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_ent_d3 = tree_ent_d3.predict(X_train);\n",
    "y_pred_test_ent_d3  = tree_ent_d3.predict(X_test);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 Depth = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GINI IMPURITY\n",
    "tree_gin_d4 = DecisionTreeClassifier(criterion    =  'gini',\n",
    "                                     max_depth    =  4,\n",
    "                                     random_state =  0 );\n",
    "tree_gin_d4.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_gin_d4 = tree_gin_d4.predict(X_train);\n",
    "y_pred_test_gin_d4  = tree_gin_d4.predict(X_test);\n",
    "\n",
    "\n",
    "# ENTROPY IMPURITY\n",
    "tree_ent_d4 = DecisionTreeClassifier(criterion    =  'entropy',\n",
    "                                     max_depth    =  4,\n",
    "                                     random_state =  0 );\n",
    "tree_ent_d4.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_ent_d4 = tree_ent_d4.predict(X_train);\n",
    "y_pred_test_ent_d4  = tree_ent_d4.predict(X_test);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5 Depth = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GINI IMPURITY\n",
    "tree_gin_d5 = DecisionTreeClassifier(criterion    =  'gini',\n",
    "                                     max_depth    =  5,\n",
    "                                     random_state =  0 );\n",
    "tree_gin_d5.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_gin_d5 = tree_gin_d5.predict(X_train);\n",
    "y_pred_test_gin_d5  = tree_gin_d5.predict(X_test);\n",
    "\n",
    "\n",
    "# ENTROPY IMPURITY\n",
    "tree_ent_d5 = DecisionTreeClassifier(criterion    =  'entropy',\n",
    "                                     max_depth    =  5,\n",
    "                                     random_state =  0 );\n",
    "tree_ent_d5.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_ent_d5 = tree_ent_d5.predict(X_train);\n",
    "y_pred_test_ent_d5  = tree_ent_d5.predict(X_test);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6 Depth = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GINI IMPURITY\n",
    "tree_gin_d6 = DecisionTreeClassifier(criterion    =  'gini',\n",
    "                                     max_depth    =  6,\n",
    "                                     random_state =  0 );\n",
    "tree_gin_d6.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_gin_d6 = tree_gin_d6.predict(X_train);\n",
    "y_pred_test_gin_d6  = tree_gin_d6.predict(X_test);\n",
    "\n",
    "\n",
    "# ENTROPY IMPURITY\n",
    "tree_ent_d6 = DecisionTreeClassifier(criterion    =  'entropy',\n",
    "                                     max_depth    =  6,\n",
    "                                     random_state =  0 );\n",
    "tree_ent_d6.fit(X_train, y_train)\n",
    "\n",
    "y_pred_train_ent_d6 = tree_ent_d6.predict(X_train);\n",
    "y_pred_test_ent_d6  = tree_ent_d6.predict(X_test);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.7 Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n",
      "DEPTH = 1\n",
      "\tGINI : \n",
      "\t\tTrain Set Accuracy :  0.9230769230769231\n",
      "\t\tTest Set Accuracy  :  0.9035087719298246\n",
      "\tENTROPY : \n",
      "\t\tTrain Set Accuracy :  0.9230769230769231\n",
      "\t\tTest Set Accuracy  :  0.9035087719298246\n",
      "\r\n",
      "DEPTH = 2\n",
      "\tGINI : \n",
      "\t\tTrain Set Accuracy :  0.9516483516483516\n",
      "\t\tTest Set Accuracy  :  0.9649122807017544\n",
      "\tENTROPY : \n",
      "\t\tTrain Set Accuracy :  0.9318681318681319\n",
      "\t\tTest Set Accuracy  :  0.9210526315789473\n",
      "\r\n",
      "DEPTH = 3\n",
      "\tGINI : \n",
      "\t\tTrain Set Accuracy :  0.9714285714285714\n",
      "\t\tTest Set Accuracy  :  0.9649122807017544\n",
      "\tENTROPY : \n",
      "\t\tTrain Set Accuracy :  0.9648351648351648\n",
      "\t\tTest Set Accuracy  :  0.9473684210526315\n",
      "\r\n",
      "DEPTH = 4\n",
      "\tGINI : \n",
      "\t\tTrain Set Accuracy :  0.9846153846153847\n",
      "\t\tTest Set Accuracy  :  0.956140350877193\n",
      "\tENTROPY : \n",
      "\t\tTrain Set Accuracy :  0.9868131868131869\n",
      "\t\tTest Set Accuracy  :  0.9385964912280702\n",
      "\r\n",
      "DEPTH = 5\n",
      "\tGINI : \n",
      "\t\tTrain Set Accuracy :  0.989010989010989\n",
      "\t\tTest Set Accuracy  :  0.9473684210526315\n",
      "\tENTROPY : \n",
      "\t\tTrain Set Accuracy :  0.9912087912087912\n",
      "\t\tTest Set Accuracy  :  0.9210526315789473\n",
      "\r\n",
      "DEPTH = 6\n",
      "\tGINI : \n",
      "\t\tTrain Set Accuracy :  0.9934065934065934\n",
      "\t\tTest Set Accuracy  :  0.9473684210526315\n",
      "\tENTROPY : \n",
      "\t\tTrain Set Accuracy :  0.9934065934065934\n",
      "\t\tTest Set Accuracy  :  0.9035087719298246\n"
     ]
    }
   ],
   "source": [
    "print(\"\\r\\nDEPTH = 1\");\n",
    "print(\"\\tGINI : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_gin_d1));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_gin_d1));\n",
    "print(\"\\tENTROPY : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_ent_d1));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_ent_d1));\n",
    "\n",
    "print(\"\\r\\nDEPTH = 2\");\n",
    "print(\"\\tGINI : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_gin_d2));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_gin_d2));\n",
    "print(\"\\tENTROPY : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_ent_d2));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_ent_d2));\n",
    "\n",
    "print(\"\\r\\nDEPTH = 3\");\n",
    "print(\"\\tGINI : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_gin_d3));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_gin_d3));\n",
    "print(\"\\tENTROPY : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_ent_d3));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_ent_d3));\n",
    "\n",
    "print(\"\\r\\nDEPTH = 4\");\n",
    "print(\"\\tGINI : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_gin_d4));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_gin_d4));\n",
    "print(\"\\tENTROPY : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_ent_d4));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_ent_d4));\n",
    "\n",
    "print(\"\\r\\nDEPTH = 5\");\n",
    "print(\"\\tGINI : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_gin_d5));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_gin_d5));\n",
    "print(\"\\tENTROPY : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_ent_d5));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_ent_d5));\n",
    "\n",
    "print(\"\\r\\nDEPTH = 6\");\n",
    "print(\"\\tGINI : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_gin_d6));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_gin_d6));\n",
    "print(\"\\tENTROPY : \");\n",
    "print(\"\\t\\tTrain Set Accuracy : \", accuracy_score(y_train, y_pred_train_ent_d6));\n",
    "print(\"\\t\\tTest Set Accuracy  : \", accuracy_score(y_test, y_pred_test_ent_d6));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use(\"dark_background\")\n",
    "fig = plt.figure();\n",
    "ax  = plt.axes();\n",
    "ax.set_xlabel('Depth - 1');\n",
    "ax.set_ylabel('Accuracy');\n",
    "ax.set_title('Accuracy of Test and Train Datasets at Varying Depths');\n",
    "\n",
    "train_gin_accuracy_lst = [accuracy_score(y_train, y_pred_train_gin_d1),\n",
    "                          accuracy_score(y_train, y_pred_train_gin_d2),\n",
    "                          accuracy_score(y_train, y_pred_train_gin_d3),\n",
    "                          accuracy_score(y_train, y_pred_train_gin_d4),\n",
    "                          accuracy_score(y_train, y_pred_train_gin_d5),\n",
    "                          accuracy_score(y_train, y_pred_train_gin_d6)];\n",
    "\n",
    "test_gin_accuracy_lst  = [accuracy_score(y_test, y_pred_test_gin_d1), \n",
    "                         accuracy_score(y_test, y_pred_test_gin_d2), \n",
    "                         accuracy_score(y_test, y_pred_test_gin_d3), \n",
    "                         accuracy_score(y_test, y_pred_test_gin_d4), \n",
    "                         accuracy_score(y_test, y_pred_test_gin_d5), \n",
    "                         accuracy_score(y_test, y_pred_test_gin_d6)];\n",
    "\n",
    "train_ent_accuracy_lst = [accuracy_score(y_train, y_pred_train_ent_d1),\n",
    "                          accuracy_score(y_train, y_pred_train_ent_d2),\n",
    "                          accuracy_score(y_train, y_pred_train_ent_d3),\n",
    "                          accuracy_score(y_train, y_pred_train_ent_d4),\n",
    "                          accuracy_score(y_train, y_pred_train_ent_d5),\n",
    "                          accuracy_score(y_train, y_pred_train_ent_d6)];\n",
    "\n",
    "test_ent_accuracy_lst  = [accuracy_score(y_test, y_pred_test_ent_d1), \n",
    "                         accuracy_score(y_test, y_pred_test_ent_d2), \n",
    "                         accuracy_score(y_test, y_pred_test_ent_d3), \n",
    "                         accuracy_score(y_test, y_pred_test_ent_d4), \n",
    "                         accuracy_score(y_test, y_pred_test_ent_d5), \n",
    "                         accuracy_score(y_test, y_pred_test_ent_d6)];\n",
    "\n",
    "plt.plot(train_gin_accuracy_lst, label  =  \"Train GINI Accuracies\");\n",
    "plt.plot(test_gin_accuracy_lst, label   =  \"Test GINI Accuracies\");\n",
    "\n",
    "plt.plot(train_ent_accuracy_lst, label  =  \"Train ENTROPY Accuracies\");\n",
    "plt.plot(test_gin_accuracy_lst, label   =  \"Test ENTROPY Accuracies\");\n",
    "\n",
    "plt.legend(loc = \"lower right\", frameon =  True);\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the accuracy data, it seems as if increasing the depth increases the accuracy for the Training Datasets whether the `GINI` or `ENTROPY` impurity was used for determining the information gain in the descision tree construction.\n",
    "\n",
    "However, the same cannot be said for the Testing Datasets. It seems that the accuracies peak at a `depth` equal to 2 or 3. This can be seen in both the `GINI` and `ENTROPY` cases.\n",
    "\n",
    "Little difference can be seem between the `GINI` and `ENTROPY` cases in terms of accuracy. The two testing datasets actually overlap each other on the plot and the training dataset plots are very similar. \n",
    "If anything, `GINI` is slighly higher."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Best model from the various tree depths based on test accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the test accuracies the best cases seem to be the GINI impurity at depth 2 and the GINI impurity at depth 3. Both of the accuracies are the same. \n",
    "\n",
    "Since the other accuracies are slightly higher at depth 3 as opposed to 2, I will call the **GINI impurity at depth 3** the best decision tree model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Set Accuracy d = 2 :  0.9649122807017544\n",
      "Test Set Accuracy d = 3 :  0.9649122807017544\n"
     ]
    }
   ],
   "source": [
    "print(\"Test Set Accuracy d = 2 : \", accuracy_score(y_test, y_pred_test_gin_d2));\n",
    "print(\"Test Set Accuracy d = 3 : \", accuracy_score(y_test, y_pred_test_gin_d3));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Compare with other methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1 Take top 10 features from the best decision tree model and subset these features to create a new dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Important Features :  6\n",
      "\r\n",
      "Dictionary of Important Features : \n",
      "\t mean smoothness  :  0.03640379409317912\n",
      "\t mean symmetry  :  0.018404140347107224\n",
      "\t texture error  :  0.010235317781474408\n",
      "\t worst perimeter  :  0.016643728645324384\n",
      "\t worst area  :  0.1446821190899303\n",
      "\t worst concave points  :  0.7736309000429845\n"
     ]
    }
   ],
   "source": [
    "important_features_dict = {};\n",
    "\n",
    "for i in range(len(tree_gin_d3.feature_importances_)) :\n",
    "    if (tree_gin_d3.feature_importances_[i] != 0.0) :\n",
    "        important_features_dict[cancer.feature_names[i]] = tree_gin_d3.feature_importances_[i]\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "print(\"Number of Important Features : \", len(important_features_dict));\n",
    "print(\"\\r\\nDictionary of Important Features : \");\n",
    "for (k,v) in important_features_dict.items() :\n",
    "    print(\"\\t\", k,\" : \", v);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.c_[cancer.data, cancer.target];\n",
    "columns = np.append(cancer.feature_names, [\"target\"]);\n",
    "cancer_df = pd.DataFrame(data, columns = columns);\n",
    "\n",
    "for col in cancer_df.columns :\n",
    "    if col not in important_features_dict.keys() :\n",
    "        cancer_df = cancer_df.drop(columns = col);\n",
    "    else:\n",
    "        pass;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 SVM and logistic regression with just *10 features*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD7CAYAAABnoJM0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3df3RU9Z3/8eedH0nIDwiJMwEDyG9FkB81WEohrG0lCEEwK1890Mb9+i16sHtasGZXpQviqqwczuK6SquH4/brClvyrZoYxUC1i24l1oRSQAQFBIEE8htIJr/mx/3+EZg6JGkSSJgM9/U4x4P387n3zvtzB+Y1996ZzximaZqIiIhl2cJdgIiIhJeCQETE4hQEIiIWpyAQEbE4BYGIiMUpCERELE5BICJicY5wF3A5ams9BAJ/+fpDcnI81dX1Yazoyqj+8FL94aX6e5/NZjBwYFyH/REZBIGAGRIEF9simeoPL9UfXqo/vHRpSETE4hQEIiIWpyAQEbE4BYGIiMUpCERELE5BICJicQoCERGLi8jvEVxr6hpa8DT7QtqinQ4cimkRuQoUBH1AY5OP4oPlIW1Tx6XgiNbTIyK9T+85RUQsTkEgImJxCgIREYtTEIiIWJyCQETE4hQEIiIWpyAQEbE4BYGIiMUpCERELE5BICJicQoCERGLUxCIiFicgkBExOIUBCIiFqcgEBGxOAWBiIjFKQhERCxOQSAiYnFdCoKCggLmzp3L7Nmz2bx5c5v+gwcPkpWVRUZGBitXrsTna/393bKyMpYsWcKcOXNYtmwZHo8HgHPnzrF06VLuuusu7rnnHg4ePNiDQxIRke7oNAjKy8vZsGEDW7ZsIS8vj61bt3LkyJGQdXJycli1ahXbt2/HNE1yc3MBWLNmDYsXL6awsJAJEyawceNGAP7jP/6DsWPH8vbbb/Pwww/z1FNP9cLQRESkKzoNgl27djFt2jQSExOJjY0lIyODwsLCYH9paSlNTU1MnjwZgKysLAoLC/F6vRQXF5ORkRHSDhAIBIJnB42NjcTExPT4wEREpGscna1QUVGBy+UKLrvdbvbt29dhv8vlory8nNraWuLj43E4HCHtAA888AD33nsvM2bMwOPx8Oqrr/bYgEREpHs6DYJAIIBhGMFl0zRDljvqv3Q9ILj8z//8zyxZsoTs7Gz27NnDihUrePfdd4mLi+tS0cnJ8W3aXK6ELm3bF1XUNJAQH3pWFBsbjSspNkwVdV8kH39Q/eGm+sOr0yAYNGgQJSUlweXKykrcbndIf2VlZXC5qqoKt9tNUlISdXV1+P1+7HZ7yHYffPBB8L7AlClTSE5O5ujRo0ycOLFLRVdX1xMImMFllyuBysq6Lm3bJ9nt1NU3hTQ1NDRT6feHqaDuifTjr/rDS/X3PpvNaPcNdLC/sx1Mnz6doqIiampqaGxsZMeOHaSnpwf7U1NTiY6OZvfu3QDk5+eTnp6O0+kkLS2Nbdu2AZCXlxfc7qabbuL9998H4Pjx41RUVDBixIjLH6WIiFy2ToMgJSWFFStWkJ2dzcKFC8nMzGTixIksXbqU/fv3A7B+/XrWrl3LnDlzaGhoIDs7G4DVq1eTm5vL3LlzKSkpYfny5QD8y7/8C2+88QaZmZk88sgjPPfccyQkRPaplYhIpDJM0zQ7X61vudYuDZl2Ox/uPhHSNnVcCnHRnV656xMi/fir/vBS/b3vii8NiYjItU1BICJicQoCERGLUxCIiFicgkBExOIUBCIiFqcgEBGxOAWBiIjFKQhERCxOQSAiYnEKAhERi1MQiIhYnIJARMTiFAQiIhanIBARsTgFgYiIxSkIREQsTkEgImJxCgIREYtTEIiIWJyCQETE4hQEIiIWpyAQEbE4BYGIiMUpCERELE5BICJicQoCERGLUxCIiFicgkBExOIUBCIiFqcgEBGxOAWBiIjFKQhERCxOQSAiYnEKAhERi1MQiIhYnIJARMTiuhQEBQUFzJ07l9mzZ7N58+Y2/QcPHiQrK4uMjAxWrlyJz+cDoKysjCVLljBnzhyWLVuGx+MBoL6+np///OcsXLiQhQsXcuDAgR4ckoiIdEenQVBeXs6GDRvYsmULeXl5bN26lSNHjoSsk5OTw6pVq9i+fTumaZKbmwvAmjVrWLx4MYWFhUyYMIGNGzcCsHbtWgYPHkxeXh6PPPIITz75ZM+PTEREuqTTINi1axfTpk0jMTGR2NhYMjIyKCwsDPaXlpbS1NTE5MmTAcjKyqKwsBCv10txcTEZGRkh7aZpsmPHDh588EEA0tPTefbZZ3tjbCIi0gWdBkFFRQUulyu47Ha7KS8v77Df5XJRXl5ObW0t8fHxOByOkPbq6mqioqLYsmUL9957L9nZ2fj9/p4ck4iIdIOjsxUCgQCGYQSXTdMMWe6o/9L1AAzDwO/3U1VVRUJCAlu3buXjjz/mJz/5CR988EGXi05Ojm/T5nIldHn7vqaipoGE+JiQttjYaFxJsWGqqPsi+fiD6g831R9enQbBoEGDKCkpCS5XVlbidrtD+isrK4PLVVVVuN1ukpKSqKurw+/3Y7fbg9sNHDgQh8NBZmYmAN/97ndpaGigurqa5OTkLhVdXV1PIGAGl12uBCor67q0bZ9kt1NX3xTS1NDQTGWEnClF+vFX/eGl+nufzWa0+wY62N/ZDqZPn05RURE1NTU0NjayY8cO0tPTg/2pqalER0eze/duAPLz80lPT8fpdJKWlsa2bdsAyMvLIz09naioKKZPn867774LwJ///Gf69evHwIEDr2igIiJyeToNgpSUFFasWEF2djYLFy4kMzOTiRMnsnTpUvbv3w/A+vXrWbt2LXPmzKGhoYHs7GwAVq9eTW5uLnPnzqWkpITly5cD8Mwzz/DRRx+RmZnJk08+yYYNG7DZ9JUGEZFwMEzTNDtfrW+51i4NmXY7H+4+EdI2dVwKcdGdXrnrEyL9+Kv+8FL9ve+KLw2JiMi1TUEgImJxCgIREYtTEIiIWJyCQETE4hQEIiIWpyAQEbE4BYGIiMUpCERELE5BICJicQoCERGLUxCIiFicgkBExOIUBCIiFqcgEBGxOAWBiIjFKQhERCxOQSAiYnEKAhERi1MQiIhYnIJARMTiFAQiIhanIBARsTgFgYiIxSkIREQsTkEgImJxCgIREYtTEIiIWJyCQETE4hQEIiIWpyAQEbE4BYGIiMUpCERELE5BICJicQoCERGLUxCIiFicgkBExOK6FAQFBQXMnTuX2bNns3nz5jb9Bw8eJCsri4yMDFauXInP5wOgrKyMJUuWMGfOHJYtW4bH4wnZ7syZM9x2222cOnWqB4YiIiKXo9MgKC8vZ8OGDWzZsoW8vDy2bt3KkSNHQtbJyclh1apVbN++HdM0yc3NBWDNmjUsXryYwsJCJkyYwMaNG4PbBAIBVq5cidfr7eEhiYhId3QaBLt27WLatGkkJiYSGxtLRkYGhYWFwf7S0lKampqYPHkyAFlZWRQWFuL1eikuLiYjIyOk/aJNmzYxffp0Bg4c2NNjEhGRbnB0tkJFRQUulyu47Ha72bdvX4f9LpeL8vJyamtriY+Px+FwhLQDfPbZZ3zyySds2rSp3UtNnUlOjm/T5nIldHs/fUVFTQMJ8TEhbbGx0biSYsNUUfdF8vEH1R9uqj+8Og2CQCCAYRjBZdM0Q5Y76r90PQDDMGhsbGTNmjX827/9Gzbb5d2rrq6uJxAwg8suVwKVlXWXta8+wW6nrr4ppKmhoZlKvz9MBXVPpB9/1R9eqr/32WxGu2+gg/2d7WDQoEFUVlYGlysrK3G73R32V1VV4Xa7SUpKoq6uDv+FF7OL25WUlFBdXc2yZctYsGABFRUVPPjgg3z11VeXNUAREbkynQbB9OnTKSoqoqamhsbGRnbs2EF6enqwPzU1lejoaHbv3g1Afn4+6enpOJ1O0tLS2LZtGwB5eXmkp6czc+ZMfv/735Ofn09+fj5ut5tXXnmFkSNH9tIQRUTkr+k0CFJSUlixYgXZ2dksXLiQzMxMJk6cyNKlS9m/fz8A69evZ+3atcyZM4eGhgays7MBWL16Nbm5ucydO5eSkhKWL1/eu6MREZFuM0zTNDtfrW+51u4RmHY7H+4+EdI2dVwKcdGd3sLpEyL9+Kv+8FL9ve+K7xGIiMi1TUEgImJxCgIREYtTEIiIWJyCQETE4hQEIiIWpyAQEbE4BYGIiMUpCERELE5BICJicQoCERGLUxCIiFicgkBExOIUBCIiFqcgEBGxOAWBiIjFKQhERCxOQSAiYnEKAhERi1MQiIhYnIJARMTiFAQiIhanIBARsTgFgYiIxSkIREQsTkEgImJxjnAXIO0zbAaeZl+b9minA4fiW0R6kIKgj2r2+tn7ZWWb9qnjUnBE62kTkZ6j95YiIhanIBARsTgFgYiIxSkIREQsTkEgImJxCgIREYtTEIiIWJyCQETE4hQEfYQ/EOBURT0155vwB8xwlyMiFtKlr6gWFBTwy1/+Ep/Px/3338+SJUtC+g8ePMjKlSvxeDykpaWxZs0aHA4HZWVl5OTkUF1dzYgRI1i/fj1xcXEcPXqUVatWUV9fT0xMDE8++STjxo3rlQFGgv1Hq3j7D8epa/ACYBiwc08p40ckMSgpNszVici1rtMzgvLycjZs2MCWLVvIy8tj69atHDlyJGSdnJwcVq1axfbt2zFNk9zcXADWrFnD4sWLKSwsZMKECWzcuBGAX/ziFyxdupT8/HyWL1/OP/7jP/bC0Po+T5OXF9/cz/O/2QPArMnXM3PSYMYPT6K5xc/7Jac4UV4X5ipF5FrXaRDs2rWLadOmkZiYSGxsLBkZGRQWFgb7S0tLaWpqYvLkyQBkZWVRWFiI1+uluLiYjIyMkHaARYsWMXPmTABuvPFGTp8+3eMD6+sCpsmmgs/Ze6SKrL8ZzV0zhnPDoARGDO7Pt2508dP/NYmkhGg+3FPG4VPnwl2uiFzDOr00VFFRgcvlCi673W727dvXYb/L5aK8vJza2lri4+NxOBwh7dAaChe98MIL/OAHP+hW0cnJ8W3aXK6Ebu0j3H77+8PsPVrNQ3ffwm03D+JPX1SE9Cf278fdt49me9HXFH12hrh+Udx4w0BiY6Nx9cHLRZF2/C+l+sNL9YdXp0EQCAQwDCO4bJpmyHJH/ZeuB7RZb926dezdu5fXXnutW0VXV9cT+MYNVZcrgcrKyLmE8sWJWv5z20HSbnJz29jrAKirbwpZx+v10dzkZeakwfyu2MeHe04xIM5Bw9ABVPr94Si7Q5F2/C+l+sNL9fc+m81o9w10sL+zHQwaNIjKyr9Mh1xZWYnb7e6wv6qqCrfbTVJSEnV1dfgvvGh9czufz8ejjz7K/v37ee2110hIiOw07Y7znhZ+9fYBrkuM4X/feVObsLyU3WYwfcIgTNOk6LNyTFOfKBKRntVpEEyfPp2ioiJqampobGxkx44dpKenB/tTU1OJjo5m9+7dAOTn55Oeno7T6SQtLY1t27YBkJeXF9zuueeeo76+nldffdVSIQDw5kdHqW/w8vDCCfTr4u8K9I+L4ltjXZRVefjkwJlerlBErKbTIEhJSWHFihVkZ2ezcOFCMjMzmThxIkuXLmX//v0ArF+/nrVr1zJnzhwaGhrIzs4GYPXq1eTm5jJ37lxKSkpYvnw5NTU1bN68mWPHjrFo0SIWLFjAggULeneUfcTpag//s+80t09JZVhK9wLwxmGJpCT1480Pv6L6XFPnG4iIdJFhRuC1hki9R/DSm/v57HgNzz30HfrHRQXbTbudD3efCFl30lhXm18oq2to4d1dXzNp9HUsWzjhqtTcFZFy/Dui+sNL9fe+K75HID3jaNk5dn9ZyZzbhoWEQHckxEbxvbQhFB+q4POva/E0+/A0+/AFerhYEbEUBcFVYJomb+w8Sv9YJ7OnDr2ifc2cfD0xUXb+c/shPv38DMUHy2n2tv2RexGRrlIQXAUHjtVw6MRZ5n93RJdvEHckJsrBxFHJlNc0Ulrl6aEKRcTKFARXwTtFX5PcP5pZk6/vkf2NGZpIQqyTP31RSSDybvGISB+jIOhlR0vP8eXJs8yeOgyHvWcOt91mMGXMdZytb+Gr0vM9sk8RsS4FQS8r/OMJ4mIczJw0uEf3e8OgBJL7x7DvaDU+v+4Wi8jlUxD0ojM1Dfzpy0pu/9YQYqKu7N7ApQzDYPKYZOobvfqSmYhcEQVBL9r+6Qnsdhvfv3VIr+z/+uviuG5ADNv/eAKvPkMqIpdJQdBLztU38/H+M8y4ZRADLvN7A51pPStovVfw0d6yXnkMEbn2KQh6yfu7T+H3B8i4bVivPs7g5FhGpfbnnaLjtHj71qykIhIZFAS9oLnFz849pUwZ6yKll387wDAM5n1nOOfqW9i5p7RXH0tErk0Kgl7wh/2n8TT5mNPLZwMXjRmayLgbBvJO0dc0NutbxiLSPQqCHhYImOwoPsGo6/szesiAq/a4fztrFPWNXnYUn7xqjyki1wYFQQ/bc7iSyrNNvX5v4FIjr+/PrTe6KPz0BOcbWq7qY4tIZFMQ9LDCT0/gSozhW2Ndna/cw7LSR9Li9fPurq+v+mOLSORSEPSgI6XnOFp6ntlTh2Gz/fWfoOwNg5PjmHHLYP57zymqzjVe9ccXkcikIOhB733yNXExDmbc0rPTSXTHghkjAIO3PjoWthpEJLIoCHrIyYp69hyu4gdpQ4mOsoetjqT+MWTcNpSiA2f48uTZsNUhIpFDQdBD3tl1nJgoOz9I653pJLoj8zvDSe4fzes7vsAf0NQTIvLXKQh6QFmVh5JDFXz/1iHExTjDXQ7RUXbu+/5YTlV6+KDkVLjLEZE+TkHQA94tOo7TaeOOK/wZyp70rbHXccvIZPL+cIzauuZwlyMifZiC4ApV1Dbwyefl3D4llf6xvTO53OUwDIMld4zB5zf5r/e/xNQvmYlIBxQEV6hg13HsNttV/wJZV7gHxrJgxnBKvqjkf/adDnc5ItJHKQiuwPEz59m1/wzfvzWVxPjocJfTrju/fQM3Dx/Ilt99yanK+nCXIyJ9kILgMpmmyZb3DxMf62T+9BHhLqdDNpvB0sybiYl28Kv8AzRrqmoRuYSC4DIVH6rgyKlzZKWPJDamZ3+GsqcNiI9m6fybOV3l4T+3f6H7BSISQkFwGZq9fnL/+whD3fHMnHh9uMvpkvHDk1gwYwS7PjvDlvcPKwxEJKhvv5Xtowr/eIKa880szbw5LHMKXa753x1OQ7OPHcUnsdsM7v3eaAwjcuoXkd6hIOimr8rO886u49w2zs2NwwaGu5xuMYzWF39/wGRH8UlshsE9fzMqosJMRHqegqAbGpp8/Cr/MxLjo/hRxo3hLueyGIbB4h+MIWCaFH56guNnzvPjzJtJ6h8T7tJEJEx0j6CLTNPk/xYeouZ8Mw/dNaFPTCVxuQzD4Id3jOX/zBvHsdN1rH71Uz49WK77BiIWpTOCLvpwbxnFhyr421kjr+pPUPYWwzD47i2DGZ06gJffPsCv8g/wbtHX3PntYUwd58Zua/89gi8Azd7Q30U2zjbgueS3kqOdDhx6myESERQEXVB8qILXt3/J+BFJ3DnthnCX06NSkmJ54ke38smBct7749e8UvA5/2/nUW4Zmcz4EUncNCyRhG9MndHs9VF8sDxkH2njB1NySdvUcSk4ovXXSyQS6F9qJz75/AybCg4yKrU/Dy+cgC3CP2XT3jv6aKeDGRMHM/2WQew9UsUf9p2m+FA5H+0tAyC+nxNXYgzJ/WNwOu2crWvGYTeCnziqONtEaWU9pmly8epSaaUHp8OGYYDNMLDbDBx2G06HjSiHjSinnX7RDmKi7EQ5HTgdBrExDmKiHdgMo8Mzio7q19mHyOVTEPwVH+8/zavbDjJmSCLLF00kJiryD1d77+gvvnu3GQZTxriYMsaFPxDg2Ok6Dp86S+XZJirPNnKq0kNjs4+GZh8+X4CLdxT2Ha0GwDDAwMAw4MsTZzEMCJgQCJgEunj/waB1Gu0B8VEMiI0iIS6K/rFRJMQ6GRAfTXSUndKKemKiW4PEYbfp7EPkCulfTzvqG7381/tfUnSgnJuGJfKzeyaF9VfHwsFuszE6dQCjU0Pvh3iaO7g0dCB0Urvbxg/CDPzlxd80TfwBE7DR0NRCs9dPU4ufphYfDU1+Pj9WTYvPT3OLn2avn9gYJw1NPsqqPHzRcJb6Rm+7dTodNgr/eIKB8dEMiI+if1wUifHRDIiLag2TuGj6x0WR0M+pj8mKdEBB8A0B0+RPX1Sy+XdfUt/o5a7vDidz+nAc9mv7uoNhM3r8Zm+z18/eLyvbtE8a6+KLE7Vt2louudwzdVwKcd94l+/zB6hr8FJ+tpHdh8ppbPbT2OKjsdlHvygHnkYvx8/Ucc7TQnNL2/mUDAMS+jlbQ+HCGUb/2CjiY50MdieAP0B8jIO4fk7iYpytl6mi7PrCnVhCl4KgoKCAX/7yl/h8Pu6//36WLFkS0n/w4EFWrlyJx+MhLS2NNWvW4HA4KCsrIycnh+rqakaMGMH69euJi4vj/PnzPProo5w8eZKkpCSef/55XC5XrwywKzxNXj7ed5rf7ymloraRIa54li+axA2DEsJWU3e090LudDjw+nxt1g20c4WmvRftvna5xWG3MTAhmqgoO2eqPSF9l559NLf48TT7qT3fyHlPC+cbWqhr8FLnacHT5KO+sYXjZ5qoa2ihsbnjSfhsRut9i37RdvpFtd6/iImyB/+LctqJctiJcrbe+3DYbTjtrX/a7a33RWyGge3Cn4bRGkitF8C+qfXeiknrmRPmxefpkvYOahxwuo76uiYMm4HD1vq49gt1OOwGTseFezNOe+v9GYddZ0cSotN/6eXl5WzYsIE333yTqKgo7rvvPr797W8zevTo4Do5OTk8/fTTTJ48mSeeeILc3FwWL17MmjVrWLx4MfPmzeOll15i48aN5OTk8Pzzz5OWlsYrr7xCXl4ezzzzDM8//3yvDvQifyBA9flmzlQ3cPjUWb44eZZjZefxB0xGDxnAwpkjSLvRHVFnAe29kE8a6+rwHXkkaC/coOtBNmmsi6OnmgCIjXYQG+0gZWC/NqHh8wdo8pns2ltKs9dPi7f18lRKchwNTV4amnzBS1hNzX5q65ppunD5qsXrx+sLXLjkFVkcdiMYYlFOO9EXQuJiYDjtNhwOW/BPh824EG621qCxGRg2A9uFYAuYZmvY2VrDKcphx2E3gh8UsF0MqAshZbe3hpbDYePMuSbqPc3BDxM47TZiY5z0i7J1+DHmnqQPIHQhCHbt2sW0adNITEwEICMjg8LCQv7+7/8egNLSUpqampg8eTIAWVlZvPDCCyxatIji4mJeeumlYPsPf/hDcnJy2LlzJ5s3bwYgMzOTp556Cq/Xi9PZtS9ptfduprN3OI3Nfl4pOMCZak/wH67NMBjijudvZ41i0ujrSHXFdenxe5ppM4i95Atqjgv/GC7VXntX27q7fXvHtP11e75+f8Dk4LGaNtuPG5F0ReNvb78Tx7pIdcW3eZyOHv/S9ltGX4fX68fvD+ALmPj8Afx+OHSimkDgwkpm67v6G64fwPGycyHbjxmWCKaJgQFG63c8TBOOnDrLxStTF08kRg1J5Oips3/ZJzBmWBJfHq/BxMQMtF7iHJKSwPGyc/gDrfdmAqaJ32+SnBjD6SoPfr95oV7oH+skYJp4vX5a/CZeX4BmX4D6Ji/+gInPbxIImPgDraEXuIrBZzMM7A4Dp83WepZzMZDstmDI2G0GXAglG3R4Oe/iWVXrGdaFPwEzYLa5BxXfz9kadq1PCYZxIfRs3wg3o/WTc/1inPh8PoxvtNuM1mIu/v83zwgvfpKOi/u+8AGLIMMIPWcM/h0wmDBiIMkD+nX/OHby+thpEFRUVIRctnG73ezbt6/DfpfLRXl5ObW1tcTHx+NwOELaL93G4XAQHx9PTU0NKSkpXRrUwIFtX7CTk+PbWTPUUw9N79L+w2HezFFt2kYOaX8uo/bau9rW3XXbM2Rw2y/UDU3p3+OPfzW3v9L62zNlXPt/n2dOGdKl7b99S/sz2942vm371JsHdWmfIu3p9OQnEAiEJKxpmiHLHfVfuh789aS2XYVTQBERaavTV99BgwZRWfmX66+VlZW43e4O+6uqqnC73SQlJVFXV4ff72+zndvtpqqqCgCfz4fH4wleehIRkaur0yCYPn06RUVF1NTU0NjYyI4dO0hPTw/2p6amEh0dze7duwHIz88nPT0dp9NJWloa27ZtAyAvLy+43axZs8jLywNg27ZtpKWldfn+gIiI9CzD7MKUkwUFBbz88st4vV7uueceli5dytKlS/npT3/KLbfcwqFDh/jFL35BfX0948ePZ+3atURFRVFaWspjjz1GdXU1gwcP5l//9V8ZMGAAZ8+e5bHHHuPkyZMkJCSwfv16hgzp2nVTERHpWV0KAhERuXbpDq2IiMUpCERELE5BICJicQoCERGLi6ggeOutt5gxYwYLFixgwYIFbNiwAYDz58/z4IMPcuedd7JkyZLg9xpaWlrIycnhzjvv5O677+bo0aPhLL9dBQUFzJ07l9mzZwen3ehrfvSjHzFv3rzgcd+7dy+7du1i/vz5zJ49O/g8QOsEhFlZWWRkZLBy5Up87Ux8d7XU19eTmZnJqVOnALpdc1lZGUuWLGHOnDksW7YMj8fT7uNcrfoff/xxZs+eHXwefve73/XZ+l988UXmzZvHvHnzWLduHRB5x7+9MUTSc9AtZgR56qmnzIKCgjbta9asMV9++WXTNE3zrbfeMn/2s5+ZpmmamzZtMv/pn/7JNE3T/PTTT81FixZdvWK74MyZM+btt99u1tbWmh6Px5w/f755+PDhcJcVIhAImDNmzDC9Xm+wrbGx0Zw1a5Z54sQJ0+v1mg888IC5c+dO0zRNc968eeaePXtM0zTNxx9/3Ny8eXNY6v7zn/9sZmZmmuPHjzdPnjx5WTU/+OCD5jvvvGOapmm++OKL5rp168JWv2maZmZmplleXt5m3b5W/8cff2zee++9ZnNzs9nS0mJmZ2ebBQUFERZgNyoAAAQFSURBVHX82xvDjh07IuY56K6IOiPYv38/b731FvPnz+fRRx/l3LnWybt27tzJ/PnzgdZJ7D766CO8Xi87d+7krrvuAmDq1KnU1NRQVlYWtvov9c0J/WJjY4MT+vUlX331FQAPPPAAd911F6+//jr79u3jhhtuYOjQoTgcDubPn09hYWG7ExCGazy5ubmsXr06+G327tbs9XopLi4mIyMjLGO5tP7GxkbKysp44oknmD9/Pi+88AKBQKBP1u9yuXjssceIiorC6XQyatQojh8/HlHHv70xlJWVRcxz0F0RFQQul4uHH36Yt99+m8GDB/PUU08BHU9i196EeGfOnAlL7e1pb0K/ixPz9RXnz5/nO9/5Di+99BK//vWv+c1vfkNZWVm7dXc0AWE4PPPMM6SlpQWXOzrWlzNpYjjqr6qqYtq0aTz77LPk5uZSUlLCb3/72z5Z/5gxY4IvisePH+e9997DMIyIOv7tjWHmzJkR8xx0V9/55ZFveO+991i7dm1I28iRI/n1r38dXP7xj3/MHXfc0e725oVJ7MxLJr4z+9jkdp1N6NcXTJkyhSlTpgSX77nnHl544QVuvfXWYNvFuvvyeDqqrScmTbwahg4dGpzSHVrv2+Tl5TFq1Kg+W//hw4d56KGH+Id/+AfsdjvHjx9vU2dfP/7fHMPIkSMj7jnoqr7zqvgNd955Jx999FHIf//+7/8eEgSmaWK3t/6OcEeT2KWkpFBRURHc5uKEeH1FZxP69QUlJSUUFRUFl03TJDU1td26O5qAsC/o6FhfzqSJ4fDFF1+wffv24LJpmjgcjj5b/+7du/m7v/s7fv7zn3P33XdH5PG/dAyR9hx0R58MgvbExsayadMm9u7dC8Drr78ePCPoaBK7WbNmkZ+fD7S+oEVHR3P99e3P8R4OnU3o1xfU1dWxbt06mpubqa+v56233uKRRx7h2LFjfP311/j9ft555x3S09M7nICwL5g0aVK3av5rkyaGg2maPPvss5w7dw6v18vWrVu54447+mT9p0+f5ic/+Qnr169n3rx5QOQd//bGEEnPQXdF1FxDJSUlPPPMMzQ1NTF8+HDWrVtHQkJCh5PYNTc3s2rVKj777DOioqJ4+umnGT9+fLiHEaK9Cf36mueff57t27cTCARYvHgx999/P0VFRaxdu5bm5mZmzZrF448/jmEYHU5AGC7f+973eO211xgyZEi3a+5o0sRw1b9582Y2b96Mz+dj9uzZPProowB9rv6nn36aN954g2HDhgXb7rvvPoYPHx4xx7+jMQQCgYh4DrorooJARER6XsRcGhIRkd6hIBARsTgFgYiIxSkIREQsTkEgImJxCgIREYtTEIiIWJyCQETE4v4/gxijO1eiUdMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Y = cancer.target\n",
    "data_train , data_test, Y_train, Y_test = train_test_split(cancer_df,\n",
    "                                                           Y,\n",
    "                                                           test_size = 0.2, \n",
    "                                                           random_state = 0);\n",
    "\n",
    "import seaborn as sns;\n",
    "sns.set(color_codes = True);\n",
    "sns.distplot(data_test.iloc[:,2:]);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "from sklearn.preprocessing import StandardScaler;\n",
    "sc = StandardScaler();\n",
    "sc.fit(data_train.iloc[:,2:]);\n",
    "data_train_std = sc.transform(data_train.iloc[:,2:]);\n",
    "data_test_std  = sc.transform(data_test.iloc[:,2:]);\n",
    "\n",
    "sns.distplot(data_test_std);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Train Set Accuracy :  0.9626373626373627\n",
      "SVM Test Set Accuracy  :  0.9473684210526315\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import SVC;\n",
    "svm = SVC(kernel = \"rbf\", C = 1.0, random_state = 0);\n",
    "svm.fit(data_train_std, Y_train);\n",
    "\n",
    "Y_pred_train = svm.predict(data_train_std,);\n",
    "print(\"SVM Train Set Accuracy : \", accuracy_score(Y_train, Y_pred_train));\n",
    "\n",
    "Y_pred_test = svm.predict(data_test_std,);\n",
    "print(\"SVM Test Set Accuracy  : \", accuracy_score(Y_test, Y_pred_test));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Train Set Accuracy :  0.9582417582417583\n",
      "LR Test Set Accuracy  :  0.9473684210526315\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "lr = LogisticRegression(penalty = 'l2', solver = \"lbfgs\", C= 1.0, random_state = 0);\n",
    "lr.fit(data_train_std, Y_train);\n",
    "\n",
    "Y_pred_train_LR = lr.predict(data_train_std);\n",
    "print(\"LR Train Set Accuracy : \", accuracy_score(Y_train, Y_pred_train_LR));\n",
    "\n",
    "Y_pred_test_LR  = lr.predict(data_test_std);\n",
    "print(\"LR Test Set Accuracy  : \", accuracy_score(Y_test, Y_pred_test_LR));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Comparative assessment of best decision tree model with the ensemble of decision tree + svm and decision tree + logistic regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCURACY COMPARISON - \r\n",
      "\n",
      "\tDECISION TREE\n",
      "\t\tBest DEC TREE Train Set Accuracy :  0.9516483516483516\n",
      "\t\tBest DEC TREE Test Set Accuracy  :  0.9649122807017544\n",
      "\r\n",
      "\tSVM\n",
      "\t\tSVM Train Set Accuracy :  0.9626373626373627\n",
      "\t\tSVM Test Set Accuracy  :  0.9473684210526315\n",
      "\r\n",
      "\tLOGISTIC REGRESSION\n",
      "\t\tLR Train Set Accuracy  :  0.9582417582417583\n",
      "\t\tLR Test Set Accuracy   :  0.9473684210526315\n",
      "\r\n",
      "\n",
      "MAX Training Accuracy -  SVM ( 0.9626373626373627 )\n",
      "MAX Testing Accuracy  -  DECISION TREE ( 0.9649122807017544 )\n"
     ]
    }
   ],
   "source": [
    "print(\"ACCURACY COMPARISON - \\r\\n\")\n",
    "\n",
    "print(\"\\tDECISION TREE\");\n",
    "print(\"\\t\\tBest DEC TREE Train Set Accuracy : \" , accuracy_score(y_train, y_pred_train_gin_d2));\n",
    "print(\"\\t\\tBest DEC TREE Test Set Accuracy  : \" , accuracy_score(y_test, y_pred_test_gin_d2));\n",
    "\n",
    "print(\"\\r\\n\\tSVM\");\n",
    "print(\"\\t\\tSVM Train Set Accuracy : \" , accuracy_score(Y_train, Y_pred_train));\n",
    "print(\"\\t\\tSVM Test Set Accuracy  : \" , accuracy_score(Y_test, Y_pred_test));\n",
    "\n",
    "print(\"\\r\\n\\tLOGISTIC REGRESSION\");\n",
    "print(\"\\t\\tLR Train Set Accuracy  : \"  , accuracy_score(Y_train, Y_pred_train_LR));\n",
    "print(\"\\t\\tLR Test Set Accuracy   : \"  , accuracy_score(Y_test, Y_pred_test_LR));\n",
    "\n",
    "lst_train = [accuracy_score(y_train, y_pred_train_gin_d2),\n",
    "             accuracy_score(Y_train, Y_pred_train),\n",
    "             accuracy_score(Y_train, Y_pred_train_LR)];\n",
    "\n",
    "lst_test  = [accuracy_score(y_test, y_pred_test_gin_d2), \n",
    "             accuracy_score(Y_test, Y_pred_test), \n",
    "             accuracy_score(Y_test, Y_pred_test_LR)];\n",
    "\n",
    "max_lst_train = max(lst_train);\n",
    "max_lst_test = max(lst_test);\n",
    "\n",
    "print(\"\\r\\n\");\n",
    "print(\"MAX Training Accuracy - \", \"SVM (\", max_lst_train, \")\")\n",
    "print(\"MAX Testing Accuracy  - \", \"DECISION TREE (\", max_lst_test, \")\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After computing the accuracies for both the testing and training data sets for all three methods, it can be seen that the Descision Tree model has the highest accuracy for the testing dataset. Also, the SVM method has the highest accuracy for the training dataset.\n",
    "\n",
    "Comparing the Decision Tree with SVM, the Training accuracy for the SVM was slightly higher. The testing accuracy was higher in the Decision Tree model.\n",
    "\n",
    "Comparing the Decision Tree with the LR, the accuracy of the LR was only a few thousandths higher. The testing accuracy was higher in the Decision Tree model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trying another tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the test accuracy suggested that the Gini Tree with a depth of 3 should be chosen as the best tree model. However this only gave us 6 significant features. For this reason let's choose a tree with a greater depth to see if that changes anything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Important Features :  9\n",
      "\r\n",
      "Dictionary of Important Features : \n",
      "\t mean texture  :  0.046056611470947584\n",
      "\t mean smoothness  :  0.026158870733899654\n",
      "\t mean symmetry  :  0.022654407964988986\n",
      "\t radius error  :  0.02037739568123065\n",
      "\t concave points error  :  0.006498800969681577\n",
      "\t symmetry error  :  0.02101989660291507\n",
      "\t worst texture  :  0.074252797652416\n",
      "\t worst perimeter  :  0.18865332879041974\n",
      "\t worst concave points  :  0.5943278901335006\n"
     ]
    }
   ],
   "source": [
    "important_features_dict = {};\n",
    "\n",
    "for i in range(len(tree_ent_d5.feature_importances_)) :\n",
    "    if (tree_ent_d6.feature_importances_[i] != 0.0) :\n",
    "        important_features_dict[cancer.feature_names[i]] = tree_ent_d6.feature_importances_[i]\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "print(\"Number of Important Features : \", len(important_features_dict));\n",
    "print(\"\\r\\nDictionary of Important Features : \");\n",
    "for (k,v) in important_features_dict.items() :\n",
    "    print(\"\\t\", k,\" : \", v);\n",
    "    \n",
    "data = np.c_[cancer.data, cancer.target];\n",
    "columns = np.append(cancer.feature_names, [\"target\"]);\n",
    "cancer_df = pd.DataFrame(data, columns = columns);\n",
    "\n",
    "for col in cancer_df.columns :\n",
    "    if col not in important_features_dict.keys() :\n",
    "        cancer_df = cancer_df.drop(columns = col);\n",
    "    else:\n",
    "        pass;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So after choosing the entropy tree of depth 6, we were able to get 9 important features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Train Set Accuracy :  0.9802197802197802\n",
      "SVM Test Set Accuracy  :  0.956140350877193\n"
     ]
    }
   ],
   "source": [
    "Y = cancer.target\n",
    "data_train , data_test, Y_train, Y_test = train_test_split(cancer_df,\n",
    "                                                           Y,\n",
    "                                                           test_size = 0.2, \n",
    "                                                           random_state = 0);\n",
    "\n",
    "sns.set(color_codes = True);\n",
    "\n",
    "sc = StandardScaler();\n",
    "sc.fit(data_train.iloc[:,2:]);\n",
    "data_train_std = sc.transform(data_train.iloc[:,2:]);\n",
    "data_test_std  = sc.transform(data_test.iloc[:,2:]);\n",
    "\n",
    "svm = SVC(kernel = \"rbf\", C = 1.0, random_state = 0);\n",
    "svm.fit(data_train_std, Y_train);\n",
    "\n",
    "Y_pred_train = svm.predict(data_train_std,);\n",
    "print(\"SVM Train Set Accuracy : \", accuracy_score(Y_train, Y_pred_train));\n",
    "\n",
    "Y_pred_test = svm.predict(data_test_std,);\n",
    "print(\"SVM Test Set Accuracy  : \", accuracy_score(Y_test, Y_pred_test));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a higher accuracy than the svm model with only 6 features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Train Set Accuracy :  0.9758241758241758\n",
      "LR Test Set Accuracy  :  0.9473684210526315\n"
     ]
    }
   ],
   "source": [
    "lr = LogisticRegression(penalty = 'l2', solver = \"lbfgs\", C= 1.0, random_state = 0);\n",
    "lr.fit(data_train_std, Y_train);\n",
    "\n",
    "Y_pred_train_LR = lr.predict(data_train_std);\n",
    "print(\"LR Train Set Accuracy : \", accuracy_score(Y_train, Y_pred_train_LR));\n",
    "\n",
    "Y_pred_test_LR  = lr.predict(data_test_std);\n",
    "print(\"LR Test Set Accuracy  : \", accuracy_score(Y_test, Y_pred_test_LR));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is also a higher accuracy than the svm model with only 6 features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCURACY COMPARISON - \r\n",
      "\n",
      "\tDECISION TREE\n",
      "\t\tBest DEC TREE Train Set Accuracy :  0.9934065934065934\n",
      "\t\tBest DEC TREE Test Set Accuracy  :  0.9035087719298246\n",
      "\r\n",
      "\tSVM\n",
      "\t\tSVM Train Set Accuracy :  0.9802197802197802\n",
      "\t\tSVM Test Set Accuracy  :  0.956140350877193\n",
      "\r\n",
      "\tLOGISTIC REGRESSION\n",
      "\t\tLR Train Set Accuracy  :  0.9758241758241758\n",
      "\t\tLR Test Set Accuracy   :  0.9473684210526315\n",
      "\r\n",
      "\n",
      "MAX Training Accuracy -  DECISION TREE ( 0.9934065934065934 )\n",
      "MAX Testing Accuracy  -  SVM ( 0.956140350877193 )\n"
     ]
    }
   ],
   "source": [
    "print(\"ACCURACY COMPARISON - \\r\\n\")\n",
    "\n",
    "print(\"\\tDECISION TREE\");\n",
    "print(\"\\t\\tBest DEC TREE Train Set Accuracy : \" , accuracy_score(y_train, y_pred_train_ent_d6));\n",
    "print(\"\\t\\tBest DEC TREE Test Set Accuracy  : \" , accuracy_score(y_test, y_pred_test_ent_d6));\n",
    "\n",
    "print(\"\\r\\n\\tSVM\");\n",
    "print(\"\\t\\tSVM Train Set Accuracy : \" , accuracy_score(Y_train, Y_pred_train));\n",
    "print(\"\\t\\tSVM Test Set Accuracy  : \" , accuracy_score(Y_test, Y_pred_test));\n",
    "\n",
    "print(\"\\r\\n\\tLOGISTIC REGRESSION\");\n",
    "print(\"\\t\\tLR Train Set Accuracy  : \"  , accuracy_score(Y_train, Y_pred_train_LR));\n",
    "print(\"\\t\\tLR Test Set Accuracy   : \"  , accuracy_score(Y_test, Y_pred_test_LR));\n",
    "\n",
    "lst_train = [accuracy_score(y_train, y_pred_train_ent_d6),\n",
    "             accuracy_score(Y_train, Y_pred_train),\n",
    "             accuracy_score(Y_train, Y_pred_train_LR)];\n",
    "\n",
    "lst_test  = [accuracy_score(y_test, y_pred_test_ent_d6), \n",
    "             accuracy_score(Y_test, Y_pred_test), \n",
    "             accuracy_score(Y_test, Y_pred_test_LR)];\n",
    "\n",
    "max_lst_train = max(lst_train);\n",
    "max_lst_test = max(lst_test);\n",
    "\n",
    "print(\"\\r\\n\");\n",
    "print(\"MAX Training Accuracy - \", \"DECISION TREE (\", max_lst_train, \")\")\n",
    "print(\"MAX Testing Accuracy  - \", \"SVM (\", max_lst_test, \")\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the decison tree chosen actually had the lowest test accuracy. As a result, SVM had the highest test accuracy, and the decision tree model had the best training accuracy. It should be noted that having a tree with a greater depth allowed more features to be considered - allowing for the SVM and LR models to be more accurate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}