Tubes_B_v1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import needed library\n",
    "from sklearn.datasets import load_iris\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load iris dataset\n",
    "data_iris = load_iris()\n",
    "iris_X, iris_y = load_iris(return_X_y=True)\n",
    "feature_iris = data_iris['feature_names']\n",
    "\n",
    "#load play tennis dataset\n",
    "play_tennis =  pd.read_csv('play_tennis.csv')\n",
    "play_tennis = play_tennis.drop('day',axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#transform iris into dataframe\n",
    "iris_X=pd.DataFrame(iris_X)\n",
    "iris_y=pd.DataFrame(iris_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create index so be merge\n",
    "iris_X=iris_X.reset_index()\n",
    "iris_y=iris_y.reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris_y.rename(columns = {0:4}, inplace = True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#merge dataset iris\n",
    "iris=iris_X.merge(iris_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#drop index\n",
    "iris.drop(\"index\",axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris.rename(columns = {0:feature_iris[0],1:feature_iris[1],2:feature_iris[2],3:feature_iris[3],4:\"target\"}, inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def entropy(parsed_data, target_attribute):\n",
    "    parsed_value_target = {}\n",
    "    total_value_target = 0\n",
    "  \n",
    "    for i in parsed_data[target_attribute]:\n",
    "        if i is not None:\n",
    "            if i not in parsed_value_target:\n",
    "                parsed_value_target[i] = 1\n",
    "            else:\n",
    "                parsed_value_target[i] += 1\n",
    "\n",
    "            total_value_target += 1\n",
    "  \n",
    "    log_result = 0\n",
    "\n",
    "    for i in parsed_value_target:\n",
    "        log_result += float(parsed_value_target[i])/total_value_target * math.log((float(parsed_value_target[i])/total_value_target), 2)\n",
    "  \n",
    "    return -1 * log_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hasn't handle after universal entropy\n",
    "def information_gain(data, gain_attribute, target_attribute):\n",
    "    gain_result = 0\n",
    "    attribute_entropy_result = 0\n",
    "    parsed_attribute_count = {}\n",
    "    total_attribute_count = 0\n",
    "    \n",
    "    for i in data[gain_attribute]:\n",
    "        if i is not None:\n",
    "            if i not in parsed_attribute_count:\n",
    "                parsed_attribute_count[i] = 1\n",
    "            else:\n",
    "                parsed_attribute_count[i] += 1\n",
    "            \n",
    "            total_attribute_count += 1\n",
    "    \n",
    "    for i in parsed_attribute_count:\n",
    "        parsed_data = data.loc[data[gain_attribute]==i]\n",
    "        attribute_entropy_result += float(parsed_attribute_count[i])/total_attribute_count * entropy(parsed_data, target_attribute)    \n",
    "\n",
    "    gain_result += entropy(data,target_attribute) + (-1 * attribute_entropy_result)\n",
    "    return gain_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def best_attribute(data,target_attribute):\n",
    "    gain_attribute = {\n",
    "        'value': 0,\n",
    "        'name': ''\n",
    "    }\n",
    "    \n",
    "    \n",
    "    for i in data.columns:\n",
    "        if (i != target_attribute):\n",
    "            if information_gain(data, i, target_attribute) > gain_attribute['value']:\n",
    "                gain_attribute['value'] = information_gain(data, i, target_attribute)\n",
    "                gain_attribute['name'] = i\n",
    "\n",
    "    return gain_attribute['name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9402859586706309"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "entropy(play_tennis,\"play\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2467498197744391"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "information_gain(play_tennis, \"outlook\", \"play\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'outlook'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_attribute(play_tennis,'play')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "class Node:\n",
    "    def __init__(self, attribute=None, label=None, vertex=None):\n",
    "        self.attribute = attribute\n",
    "        self.label = label\n",
    "        self.vertex = vertex\n",
    "        self.children = {}\n",
    "        self.most_common_label = None\n",
    "    \n",
    "    def set_most_common_label(self, most_common_label):\n",
    "        self.most_common_label = most_common_label\n",
    "        \n",
    "    def get_most_common_label(self):\n",
    "        return self.most_common_label\n",
    "        \n",
    "    def setAttribute(self, attribute):\n",
    "        self.attribute = attribute\n",
    "\n",
    "    def setLabel(self, label):\n",
    "        self.label = label\n",
    "        \n",
    "    def setVertex(self, vertex):\n",
    "        self.vertex = vertex\n",
    "  \n",
    "    def addChildren(self, attributeValue, node):\n",
    "        self.children[attributeValue] = node\n",
    "    \n",
    "    def getChildren(self):\n",
    "        return self.children\n",
    "    \n",
    "    def getLabel(self):\n",
    "        return self.label\n",
    "    \n",
    "    def getVertex(self):\n",
    "        return self.vertex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_most_common_label(data, target_attribute):\n",
    "    parsed_value_target = {}\n",
    "  \n",
    "    for i in data[target_attribute]:\n",
    "        if i is not None:\n",
    "            if i not in parsed_value_target:\n",
    "                parsed_value_target[i] = 1\n",
    "            else:\n",
    "                parsed_value_target[i] += 1\n",
    "\n",
    "    most_common = {\n",
    "        'value': 0,\n",
    "        'name': ''\n",
    "    }\n",
    "    \n",
    "    for i in parsed_value_target:\n",
    "        if parsed_value_target[i] > most_common['value']:\n",
    "            most_common['value'] = parsed_value_target[i]\n",
    "            most_common['name'] = i\n",
    "    \n",
    "    return most_common['name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'No'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play_tennis['play'].unique()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['No', 'Yes'], dtype=object)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play_tennis['play'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def id3(data, target_attribute, vertex_=None):\n",
    "    node = Node(vertex = vertex_)\n",
    "    if data[target_attribute].nunique()==1:\n",
    "        node.setLabel(data[target_attribute].unique()[0])\n",
    "        return node\n",
    "     \n",
    "    elif len(play_tennis.columns)==1:\n",
    "        node.setLabel(get_most_common_label(data, target_attribute))\n",
    "        return node\n",
    "    \n",
    "    else:\n",
    "        best_attribute_ = best_attribute(data,target_attribute)\n",
    "        node.setAttribute(best_attribute_)\n",
    "        for i in data[best_attribute_].unique():\n",
    "            node.addChildren(i,id3(data.loc[data[best_attribute_]==i],target_attribute, i))\n",
    "            most_comm = None\n",
    "            occ = 0;\n",
    "            for i in data[target_attribute].unique():\n",
    "                if data[data[target_attribute] == i].shape[0] >  occ:\n",
    "                    most_comm = i\n",
    "                    occ = data[data[target_attribute] == i].shape[0]\n",
    "            node.set_most_common_label(most_comm)        \n",
    "            \n",
    "    return node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'No'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play_tennis['play'][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Node at 0x7f1a0116ff98>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id3(play_tennis,\"play\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_tree(node,depth):\n",
    "    if node.label is not None: \n",
    "        print(\"    \"*(depth+1) +node.label)\n",
    "    else:\n",
    "        print(\"    \"*depth + \"[\"+ node.attribute +\"]\")\n",
    "        for i in node.children:\n",
    "            print(\"----\"*(depth+1) +i)\n",
    "            print_tree(node.children[i],depth+1)        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def copy_tree(node):\n",
    "    temp_node = Node()\n",
    "    if node.label is not None: \n",
    "        temp_node.setLabel(node.label)\n",
    "    else:\n",
    "        temp_node.setAttribute(node.attribute)\n",
    "        \n",
    "        \n",
    "    \n",
    "        \n",
    "        for i in node.children:\n",
    "            temp= Node()\n",
    "            temp= node.children[i]\n",
    "            temp_node.addChildren(i, temp)\n",
    "    return temp_node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[outlook]\n",
      "----Sunny\n",
      "    [humidity]\n",
      "--------High\n",
      "            No\n",
      "--------Normal\n",
      "            Yes\n",
      "----Overcast\n",
      "        Yes\n",
      "----Rain\n",
      "    [wind]\n",
      "--------Weak\n",
      "            Yes\n",
      "--------Strong\n",
      "            No\n"
     ]
    }
   ],
   "source": [
    "print_tree(id3(play_tennis, \"play\"),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No\n"
     ]
    }
   ],
   "source": [
    "print(id3(play_tennis, \"play\").children['Sunny'].children['High'].label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "test=play_tennis[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_X = test.drop('play',axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_tree(node,data,index,result, target_attribute):\n",
    "    if node.label is not None: \n",
    "        result.append(node.getLabel())\n",
    "    else:\n",
    "        if data.loc[index, node.attribute] is None:\n",
    "            result.append(node.get_most_common_label())\n",
    "        for i in node.children:\n",
    "            if i==data.loc[index,node.attribute]:\n",
    "                check_tree(node.children[i],data,index,result, target_attribute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pred(data,model,target_attribute):\n",
    "    result = []\n",
    "    for i in range(len(data)):\n",
    "        check_tree(model,data[i:i+1],i,result, target_attribute)\n",
    "    return pd.DataFrame(result)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_X['humidity'] = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "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>outlook</th>\n",
       "      <th>temp</th>\n",
       "      <th>humidity</th>\n",
       "      <th>wind</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Hot</td>\n",
       "      <td>None</td>\n",
       "      <td>Weak</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Hot</td>\n",
       "      <td>None</td>\n",
       "      <td>Strong</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Overcast</td>\n",
       "      <td>Hot</td>\n",
       "      <td>None</td>\n",
       "      <td>Weak</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    outlook temp humidity    wind\n",
       "0     Sunny  Hot     None    Weak\n",
       "1     Sunny  Hot     None  Strong\n",
       "2  Overcast  Hot     None    Weak"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model=id3(play_tennis, \"play\")\n",
    "res = pred(test_X,model, \"play\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0\n",
       "0   No\n",
       "1   No\n",
       "2  Yes"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy(pred,data):\n",
    "    cnt = 0\n",
    "    for i in range(len(pred)):\n",
    "        if pred.loc[i] == data.loc[i]:\n",
    "            cnt+=1\n",
    "    return cnt*100/len(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# accuracy(play_tennis['play'],x,'play')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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>outlook</th>\n",
       "      <th>temp</th>\n",
       "      <th>humidity</th>\n",
       "      <th>wind</th>\n",
       "      <th>play</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Hot</td>\n",
       "      <td>High</td>\n",
       "      <td>Weak</td>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  outlook temp humidity  wind play\n",
       "0   Sunny  Hot     High  Weak   No"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play_tennis.loc[[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play_tennis.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['outlook', 'temp', 'humidity', 'wind', 'play'], dtype='object')"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play_tennis_column = play_tennis.columns\n",
    "play_tennis_column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "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>outlook</th>\n",
       "      <th>temp</th>\n",
       "      <th>humidity</th>\n",
       "      <th>wind</th>\n",
       "      <th>play</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [outlook, temp, humidity, wind, play]\n",
       "Index: []"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_temp = pd.DataFrame(columns=play_tennis_column)\n",
    "data_temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data_validate(data):\n",
    "    data_column = data.columns\n",
    "    data_20 = pd.DataFrame(columns=data_column)\n",
    "    data_80 = pd.DataFrame(columns=data_column)\n",
    "    print(data_column)\n",
    "    count_20 = 0\n",
    "    count_80 = 0\n",
    "    \n",
    "    for i in range(data.shape[0]):\n",
    "        if(i%5 == 0):\n",
    "            # Pass the row elements as key value pairs to append() function \n",
    "            data_20 = data_20.append(data.loc[[i]] , ignore_index=True)\n",
    "        else:\n",
    "            data_80 = data_80.append(data.loc[[i]] , ignore_index=True)\n",
    "    return data_20, data_80"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['outlook', 'temp', 'humidity', 'wind', 'play'], dtype='object')\n"
     ]
    },
    {
     "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>outlook</th>\n",
       "      <th>temp</th>\n",
       "      <th>humidity</th>\n",
       "      <th>wind</th>\n",
       "      <th>play</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Hot</td>\n",
       "      <td>High</td>\n",
       "      <td>Weak</td>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Rain</td>\n",
       "      <td>Cool</td>\n",
       "      <td>Normal</td>\n",
       "      <td>Strong</td>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Mild</td>\n",
       "      <td>Normal</td>\n",
       "      <td>Strong</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  outlook  temp humidity    wind play\n",
       "0   Sunny   Hot     High    Weak   No\n",
       "1    Rain  Cool   Normal  Strong   No\n",
       "2   Sunny  Mild   Normal  Strong  Yes"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data20, data80 = get_data_validate(play_tennis)\n",
    "data20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['outlook', 'temp', 'humidity', 'wind', 'play'], dtype='object')\n"
     ]
    },
    {
     "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>outlook</th>\n",
       "      <th>temp</th>\n",
       "      <th>humidity</th>\n",
       "      <th>wind</th>\n",
       "      <th>play</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Hot</td>\n",
       "      <td>High</td>\n",
       "      <td>Strong</td>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Overcast</td>\n",
       "      <td>Hot</td>\n",
       "      <td>High</td>\n",
       "      <td>Weak</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Rain</td>\n",
       "      <td>Mild</td>\n",
       "      <td>High</td>\n",
       "      <td>Weak</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Rain</td>\n",
       "      <td>Cool</td>\n",
       "      <td>Normal</td>\n",
       "      <td>Weak</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Overcast</td>\n",
       "      <td>Cool</td>\n",
       "      <td>Normal</td>\n",
       "      <td>Strong</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Mild</td>\n",
       "      <td>High</td>\n",
       "      <td>Weak</td>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Cool</td>\n",
       "      <td>Normal</td>\n",
       "      <td>Weak</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Rain</td>\n",
       "      <td>Mild</td>\n",
       "      <td>Normal</td>\n",
       "      <td>Weak</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Overcast</td>\n",
       "      <td>Mild</td>\n",
       "      <td>High</td>\n",
       "      <td>Strong</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Overcast</td>\n",
       "      <td>Hot</td>\n",
       "      <td>Normal</td>\n",
       "      <td>Weak</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Rain</td>\n",
       "      <td>Mild</td>\n",
       "      <td>High</td>\n",
       "      <td>Strong</td>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     outlook  temp humidity    wind play\n",
       "0      Sunny   Hot     High  Strong   No\n",
       "1   Overcast   Hot     High    Weak  Yes\n",
       "2       Rain  Mild     High    Weak  Yes\n",
       "3       Rain  Cool   Normal    Weak  Yes\n",
       "4   Overcast  Cool   Normal  Strong  Yes\n",
       "5      Sunny  Mild     High    Weak   No\n",
       "6      Sunny  Cool   Normal    Weak  Yes\n",
       "7       Rain  Mild   Normal    Weak  Yes\n",
       "8   Overcast  Mild     High  Strong  Yes\n",
       "9   Overcast   Hot   Normal    Weak  Yes\n",
       "10      Rain  Mild     High  Strong   No"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data20, data80 = get_data_validate(play_tennis)\n",
    "data80"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prune_tree(node, attribute, vertex):\n",
    "    if(node.label is not None):\n",
    "        return node,0\n",
    "    elif(node.attribute == attribute and node.vertex == vertex):\n",
    "        node.children = {}\n",
    "        node.attribute = None\n",
    "        node.label = node.most_common_label\n",
    "        \n",
    "        return node,1\n",
    "    else:\n",
    "        for i in node.children:\n",
    "            a,b = prune_tree(node.children[i], attribute, vertex)\n",
    "            \n",
    "        return node,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[outlook]\n",
      "----Sunny\n",
      "    [humidity]\n",
      "--------High\n",
      "            No\n",
      "--------Normal\n",
      "            Yes\n",
      "----Overcast\n",
      "        Yes\n",
      "----Rain\n",
      "    [wind]\n",
      "--------Weak\n",
      "            Yes\n",
      "--------Strong\n",
      "            No\n"
     ]
    }
   ],
   "source": [
    "print_tree(id3(play_tennis, \"play\"),0)\n",
    "# print_tree(prune_tree(id3(play_tennis, \"play\"),\"humidity\"), 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def post_pruning(data, node, current_node, children_node, target_attribute):\n",
    "    if children_node == 0:\n",
    "        return node\n",
    "    else:\n",
    "        for i in current_node.children:\n",
    "            if current_node.vertex is None: \n",
    "                #print(i,1)\n",
    "                post_pruning(data, node, current_node.children[i], children_node-1, target_attribute)\n",
    "            else:\n",
    "                if current_node.attribute is not None:\n",
    "                    data20, data80 = get_data_validate(data)\n",
    "                    #print(current_node.attribute,2)\n",
    "                    save = copy_tree(current_node)\n",
    "                    temp_node,c = prune_tree(node, current_node.attribute, current_node.vertex)\n",
    "                    train=data20.drop(target_attribute,axis=1)\n",
    "                    #print_tree(node,0)\n",
    "                    temp_node_pred = pred(train, node, target_attribute)\n",
    "                    temp_node_accuracy = accuracy(temp_node_pred[0], data20[target_attribute])\n",
    "                    #print(temp_node_pred[0],data20)\n",
    "                    #print(temp_node_accuracy)\n",
    "                    if temp_node_accuracy == 100:\n",
    "                        post_pruning(data, temp_node, current_node, children_node, target_attribute)\n",
    "                    else :\n",
    "                        \n",
    "                        node.addChildren(current_node.vertex, save)\n",
    "                        #print_tree(node,0)\n",
    "\n",
    "\n",
    "                        post_pruning(data, node, save.children[i], children_node, target_attribute)\n",
    "        return node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "node_play_tennis = id3(play_tennis, \"play\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['outlook', 'temp', 'humidity', 'wind', 'play'], dtype='object')\n",
      "Index(['outlook', 'temp', 'humidity', 'wind', 'play'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "node_play_tennis = post_pruning(play_tennis, node_play_tennis,node_play_tennis, len(node_play_tennis.children)+1, 'play')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[outlook]\n",
      "----Sunny\n",
      "    [humidity]\n",
      "--------High\n",
      "            No\n",
      "--------Normal\n",
      "            Yes\n",
      "----Overcast\n",
      "        Yes\n",
      "----Rain\n",
      "    [wind]\n",
      "--------Weak\n",
      "            Yes\n",
      "--------Strong\n",
      "            No\n"
     ]
    }
   ],
   "source": [
    "print_tree(node_play_tennis, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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>outlook</th>\n",
       "      <th>temp</th>\n",
       "      <th>humidity</th>\n",
       "      <th>wind</th>\n",
       "      <th>play</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Hot</td>\n",
       "      <td>High</td>\n",
       "      <td>Weak</td>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Rain</td>\n",
       "      <td>Cool</td>\n",
       "      <td>Normal</td>\n",
       "      <td>Strong</td>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Mild</td>\n",
       "      <td>Normal</td>\n",
       "      <td>Strong</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  outlook  temp humidity    wind play\n",
       "0   Sunny   Hot     High    Weak   No\n",
       "1    Rain  Cool   Normal  Strong   No\n",
       "2   Sunny  Mild   Normal  Strong  Yes"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data20"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}