TreeClassify.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def Set_Leaf(leaf_class, tree_):\n",
    "    tree_.is_leaf = True  \n",
    "    tree_.leaf_class = leaf_class\n",
    "    tree_.feature_name = None\n",
    "    tree_.feature_index = None\n",
    "    tree_.subtree = {}\n",
    "    tree_.impurity = None\n",
    "    tree_.split_value = None\n",
    "    tree_.high = 0  \n",
    "    tree_.leaf_num = 1\n",
    "\n",
    "\n",
    "def val_accuracy_after_split(feature_train, y_train, feature_val, y_val, split_value=None):\n",
    "    if split_value is not None:\n",
    "        def split_fun(x):\n",
    "            if x >= split_value:\n",
    "                return '>= {:.3f}'.format(split_value)\n",
    "            else:\n",
    "                return '< {:.3f}'.format(split_value)\n",
    "\n",
    "        train_split = feature_train.map(split_fun)\n",
    "        val_split = feature_val.map(split_fun)\n",
    "\n",
    "    else:\n",
    "        train_split = feature_train\n",
    "        val_split = feature_val\n",
    "\n",
    "    majority_class_in_train = y_train.groupby(train_split).apply(\n",
    "        lambda x: pd.value_counts(x).index[0]) \n",
    "    right_class_in_val = y_val.groupby(val_split).apply(\n",
    "        lambda x: np.sum(x == majority_class_in_train[x.name])) \n",
    "\n",
    "    return right_class_in_val.sum() / y_val.shape[0]  \n",
    "    \n",
    "def post_pruning(X_train, y_train, X_val, y_val, tree_=None):\n",
    "    if tree_.is_leaf:\n",
    "        return tree_\n",
    "\n",
    "    if X_val.empty:        \n",
    "        return tree_\n",
    "\n",
    "    most_common_in_train = pd.value_counts(y_train).index[0]\n",
    "    current_accuracy = np.mean(y_val == most_common_in_train) \n",
    "\n",
    "\n",
    "    up_part_train = X_train.loc[:, tree_.feature_name] >= tree_.split_value\n",
    "    down_part_train = X_train.loc[:, tree_.feature_name] < tree_.split_value\n",
    "    up_part_val = X_val.loc[:, tree_.feature_name] >= tree_.split_value\n",
    "    down_part_val = X_val.loc[:, tree_.feature_name] < tree_.split_value\n",
    "\n",
    "    up_subtree = post_pruning(X_train[up_part_train], y_train[up_part_train], X_val[up_part_val],\n",
    "                                  y_val[up_part_val],\n",
    "                                  tree_.subtree['>= {:.3f}'.format(tree_.split_value)])\n",
    "    tree_.subtree['>= {:.3f}'.format(tree_.split_value)] = up_subtree\n",
    "    down_subtree = post_pruning(X_train[down_part_train], y_train[down_part_train],\n",
    "                                    X_val[down_part_val], y_val[down_part_val],\n",
    "                                    tree_.subtree['< {:.3f}'.format(tree_.split_value)])\n",
    "    tree_.subtree['< {:.3f}'.format(tree_.split_value)] = down_subtree\n",
    "\n",
    "    tree_.high = max(up_subtree.high, down_subtree.high) + 1\n",
    "    tree_.leaf_num = (up_subtree.leaf_num + down_subtree.leaf_num)\n",
    "\n",
    "    if up_subtree.is_leaf and down_subtree.is_leaf:\n",
    "        def split_fun(x):\n",
    "            if x >= tree_.split_value:\n",
    "                return '>= {:.3f}'.format(tree_.split_value)\n",
    "            else:\n",
    "                return '< {:.3f}'.format(tree_.split_value)\n",
    "\n",
    "        val_split = X_val.loc[:, tree_.feature_name].map(split_fun)\n",
    "        right_class_in_val = y_val.groupby(val_split).apply(\n",
    "            lambda x: np.sum(x == tree_.subtree[x.name].leaf_class))\n",
    "        split_accuracy = right_class_in_val.sum() / y_val.shape[0]\n",
    "\n",
    "        if current_accuracy > split_accuracy:  \n",
    "            Set_Leaf(pd.value_counts(y_train).index[0], tree_)\n",
    "\n",
    "    return tree_\n",
    "\n",
    "\n",
    "\n",
    "decision_node = dict(boxstyle='round,pad=0.3', fc='#FAEBD7')\n",
    "leaf_node = dict(boxstyle='round,pad=0.3', fc='#F4A460')\n",
    "arrow_args = dict(arrowstyle=\"<-\")\n",
    "\n",
    "y_off = None\n",
    "x_off = None\n",
    "total_num_leaf = None\n",
    "total_high = None\n",
    "\n",
    "\n",
    "def plot_node(node_text, center_pt, parent_pt, node_type, ax_):\n",
    "    ax_.annotate(node_text, xy=[parent_pt[0], parent_pt[1] - 0.02], xycoords='axes fraction',\n",
    "                 xytext=center_pt, textcoords='axes fraction',\n",
    "                 va=\"center\", ha=\"center\", size=12,\n",
    "                 bbox=node_type, arrowprops=arrow_args)\n",
    "\n",
    "\n",
    "def plot_mid_text(mid_text, center_pt, parent_pt, ax_):\n",
    "    x_mid = (parent_pt[0] - center_pt[0]) / 2 + center_pt[0]\n",
    "    y_mid = (parent_pt[1] - center_pt[1]) / 2 + center_pt[1]\n",
    "    ax_.text(x_mid, y_mid, mid_text, fontdict=dict(size=5))#fff\n",
    "\n",
    "\n",
    "def plot_tree(my_tree, parent_pt, node_text, ax_):\n",
    "    global y_off\n",
    "    global x_off\n",
    "    global total_num_leaf\n",
    "    global total_high\n",
    "\n",
    "    num_of_leaf = my_tree.leaf_num\n",
    "    center_pt = (x_off + (1 + num_of_leaf) / (2 * total_num_leaf), y_off)\n",
    "\n",
    "    plot_mid_text(node_text, center_pt, parent_pt, ax_)\n",
    "\n",
    "    if total_high == 0:  \n",
    "        plot_node(my_tree.leaf_class, center_pt, parent_pt, leaf_node, ax_)\n",
    "        return\n",
    "    plot_node(my_tree.feature_name, center_pt, parent_pt, decision_node, ax_)\n",
    "\n",
    "    y_off -= 1 / total_high\n",
    "    for key in my_tree.subtree.keys():\n",
    "        if my_tree.subtree[key].is_leaf:\n",
    "            x_off += 1 / total_num_leaf\n",
    "            plot_node(str(my_tree.subtree[key].leaf_class), (x_off, y_off), center_pt, leaf_node, ax_)\n",
    "            plot_mid_text(str(key), (x_off, y_off), center_pt, ax_)\n",
    "        else:\n",
    "            plot_tree(my_tree.subtree[key], center_pt, str(key), ax_)\n",
    "    y_off += 1 / total_high\n",
    "\n",
    "\n",
    "def create_plot(tree_):\n",
    "    global y_off\n",
    "    global x_off\n",
    "    global total_num_leaf\n",
    "    global total_high\n",
    "\n",
    "    total_num_leaf = tree_.leaf_num\n",
    "    total_high = tree_.high\n",
    "    y_off = 1\n",
    "    x_off = -0.5 / total_num_leaf\n",
    "\n",
    "    fig_, ax_ = plt.subplots()\n",
    "    ax_.set_xticks([])  \n",
    "    ax_.set_yticks([])\n",
    "    ax_.spines['right'].set_color('none')  \n",
    "    ax_.spines['top'].set_color('none')\n",
    "    ax_.spines['bottom'].set_color('none')\n",
    "    ax_.spines['left'].set_color('none')\n",
    "    plot_tree(tree_, (0.5, 1), '', ax_)\n",
    "\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pruning\n",
      "45\n",
      "0.9777777777777777\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "class Node(object):\n",
    "    def __init__(self, feature_name = None, feature_index = None):\n",
    "        self.feature_name = feature_name\n",
    "        self.feature_index = feature_index\n",
    "        self.subtree = {}\n",
    "        self.impurity = None\n",
    "        self.is_continuous = False\n",
    "        self.split_value = None\n",
    "        self.is_leaf = False\n",
    "        self.leaf_class = None\n",
    "        self.leaf_num = None\n",
    "        self.high = -1\n",
    "\n",
    "class Tree():\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "class DecisionTree(object):\n",
    "\n",
    "    def __init__(self, prun):\n",
    "        self.prun = prun\n",
    "        #默认采用gini post_pruning\n",
    "\n",
    "    def tester(self, prun, flag):\n",
    "        t = None\n",
    "        if self.prun == prun:\n",
    "            return True\n",
    "        elif flag:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def fit(self, X_train, y_train, X_val=None, y_val=None):\n",
    "        y_train.reset_index(inplace=True, drop=True)\n",
    "        X_train.reset_index(inplace=True, drop=True)\n",
    "        self.tester(self.prun, True)\n",
    "\n",
    "        if X_val is not None:\n",
    "            X_val.reset_index(inplace=True, drop=True)\n",
    "            y_val.reset_index(inplace=True, drop=True)\n",
    "\n",
    "        self.columns = list(X_train.columns) \n",
    "        self.tree_ = self.generate_tree(X_train, y_train)\n",
    "\n",
    "        #post pruning\n",
    "        if self.prun == True:\n",
    "            post_pruning(X_train, y_train, X_val, y_val, self.tree_)\n",
    "            print(\"pruning\")\n",
    "        elif self.prun == False:\n",
    "            print(\"without pruning\")\n",
    "\n",
    "        return self\n",
    "\n",
    "    def generate_tree(self, X, y):\n",
    "        my_tree = Node()\n",
    "        my_tree.leaf_num = 0\n",
    "        if y.nunique() == 1:  \n",
    "            my_tree.is_leaf = True\n",
    "            my_tree.leaf_class = y.values[0]\n",
    "            my_tree.high = 0\n",
    "            my_tree.leaf_num += 1\n",
    "            return my_tree\n",
    "\n",
    "        if X.empty:  \n",
    "            my_tree.is_leaf = True\n",
    "            my_tree.leaf_class = pd.value_counts(y).index[0]\n",
    "            my_tree.high = 0\n",
    "            my_tree.leaf_num += 1\n",
    "            return my_tree\n",
    "\n",
    "        best_feature_name, best_impurity = self.choose_best_feature_gini(X, y)\n",
    "\n",
    "        my_tree.feature_name = best_feature_name\n",
    "        my_tree.impurity = best_impurity[0]\n",
    "        my_tree.feature_index = self.columns.index(best_feature_name)\n",
    "\n",
    "        feature_values = X.loc[:, best_feature_name]\n",
    "\n",
    "        if len(best_impurity) == 1: \n",
    "            if my_tree.is_continuous == True:\n",
    "                my_tree.is_continuous = False \n",
    "\n",
    "            unique_vals = pd.unique(feature_values)\n",
    "            sub_X = X.drop(best_feature_name, axis=1)\n",
    "            my_tree.is_continuous = False\n",
    "\n",
    "            max_high = -1\n",
    "            for value in unique_vals:\n",
    "                my_tree.subtree[value] = self.generate_tree(sub_X[feature_values == value], y[feature_values == value])\n",
    "                if my_tree.subtree[value].high > max_high: \n",
    "                    max_high = my_tree.subtree[value].high\n",
    "                my_tree.leaf_num += my_tree.subtree[value].leaf_num\n",
    "\n",
    "            my_tree.high = max_high + 1\n",
    "\n",
    "        elif len(best_impurity) == 2:  \n",
    "            my_tree.is_continuous = True\n",
    "            my_tree.split_value = best_impurity[1]\n",
    "            up_part = '>= {:.3f}'.format(my_tree.split_value)\n",
    "            down_part = '< {:.3f}'.format(my_tree.split_value)\n",
    "\n",
    "            my_tree.subtree[up_part] = self.generate_tree(X[feature_values >= my_tree.split_value],\n",
    "                                                          y[feature_values >= my_tree.split_value])\n",
    "            my_tree.subtree[down_part] = self.generate_tree(X[feature_values < my_tree.split_value],\n",
    "                                                            y[feature_values < my_tree.split_value])\n",
    "\n",
    "            my_tree.leaf_num += (my_tree.subtree[up_part].leaf_num + my_tree.subtree[down_part].leaf_num)\n",
    "\n",
    "            my_tree.high = max(my_tree.subtree[up_part].high, my_tree.subtree[down_part].high) + 1\n",
    "\n",
    "        return my_tree\n",
    "\n",
    "    def predict(self, X):\n",
    "\n",
    "        if X.ndim == 1:\n",
    "            subtrees = self.tree_\n",
    "            if subtrees.is_leaf:\n",
    "                return subtrees.leaf_class\n",
    "            return self.predict_single(X, subtrees)\n",
    "        else:\n",
    "            return X.apply(self.predict_single, axis=1)\n",
    "\n",
    "    def predict_single(self, x, subtree=None):\n",
    "\n",
    "        if subtree is None:\n",
    "            subtree = self.tree_\n",
    "\n",
    "        if subtree.is_leaf:\n",
    "            return subtree.leaf_class\n",
    "\n",
    "        if subtree.is_continuous: \n",
    "            if x[subtree.feature_index] >= subtree.split_value:\n",
    "                return self.predict_single(x, subtree.subtree['>= {:.3f}'.format(subtree.split_value)])\n",
    "            else:\n",
    "                return self.predict_single(x, subtree.subtree['< {:.3f}'.format(subtree.split_value)])\n",
    "        else:\n",
    "            return self.predict_single(x, subtree.subtree[x[subtree.feature_index]])\n",
    "\n",
    "\n",
    "    def choose_best_feature_gini(self, X, y):\n",
    "        features = X.columns\n",
    "        best_feature_name = None\n",
    "        best_gini = [float('inf')]\n",
    "        for feature_name in features:\n",
    "            gini_idex = self.Gini_index(X[feature_name], y)\n",
    "            if gini_idex[0] < best_gini[0]:\n",
    "                best_feature_name = \"None\"\n",
    "                best_gini = gini_idex\n",
    "                best_feature_name = feature_name\n",
    "\n",
    "        return best_feature_name, best_gini\n",
    "\n",
    "    def Gini_index(self, feature, y):\n",
    "        m = y.shape[0]\n",
    "        unique_value = pd.unique(feature)\n",
    "        \n",
    "        unique_value.sort() \n",
    "        split_point_set = [(unique_value[i] + unique_value[i + 1]) / 2 for i in range(len(unique_value) - 1)]\n",
    "\n",
    "        min_gini = float('inf')\n",
    "        min_gini_point = None\n",
    "        for split_point_ in split_point_set: \n",
    "            Dv1 = y[feature <= split_point_]\n",
    "            Dv2 = y[feature > split_point_]\n",
    "            gini_index = Dv1.shape[0] / m * self.gini(Dv1) + Dv2.shape[0] / m * self.gini(Dv2)\n",
    "\n",
    "            if gini_index < min_gini:\n",
    "                min_gini = gini_index\n",
    "                min_gini_point = split_point_\n",
    "        return [min_gini, min_gini_point]\n",
    "\n",
    "    def gini(self, input):\n",
    "        p = pd.value_counts(input) / input.shape[0]\n",
    "        res = 1.0 - np.sum(p ** 2)\n",
    "        return res\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "\n",
    "    data = pd.read_csv('/home/cyberimpart/cyf/ML_by_hand/iris.csv')\n",
    "    \n",
    "    train = range((np.shape(data)[0])-2)\n",
    "    train = data.sample(frac=0.7).reset_index(drop=True)\n",
    "\n",
    "    X = train.iloc[:, :4]\n",
    "    y = train.iloc[:,4]\n",
    "\n",
    "    test =  data.sample(frac=0.3).reset_index(drop=True)\n",
    "    X_val = test.iloc[:, :4]\n",
    "    y_val = test.iloc[:, 4]\n",
    "\n",
    "    tree = DecisionTree(True)\n",
    "    tree.fit(X, y, X_val, y_val)\n",
    "\n",
    "    print(np.shape(X_val)[0])\n",
    "    print(np.sum(tree.predict(X_val) == y_val)/(np.shape(X_val)[0]))\n",
    "    create_plot(tree.tree_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7333333333333333\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "\n",
    "    data = pd.read_csv('/home/cyberimpart/cyf/ML_by_hand/watermelon_new.csv',encoding='utf8')\n",
    "    \n",
    "    train = range((np.shape(data)[0])-2)\n",
    "    train = data.sample(frac=0.5).reset_index(drop=True)\n",
    "\n",
    "    X = train.iloc[:, :8]\n",
    "    y = train.iloc[:,8]\n",
    "\n",
    "    test =  data.sample(frac=0.9).reset_index(drop=True)\n",
    "    X_val = test.iloc[:, :8]\n",
    "    y_val = test.iloc[:, 8]\n",
    "\n",
    "    tree = DecisionTree(False)\n",
    "    tree.fit(X, y, X_val, y_val)\n",
    "\n",
    "    print(np.sum(tree.predict(X_val) == y_val)/(np.shape(X_val)[0]))\n",
    "    create_plot(tree.tree_)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ailab",
   "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.10.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}