4.2.1decision tree-初始版.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8724"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import numpy as np\n",
    "np.random.seed(0)\n",
    "from treePlotter import createPlot\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import gc\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "watermelon_data = np.array([[0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0],\n",
    "                                         [1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0],\n",
    "                                         [2, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 1],\n",
    "                                         [1, 1, 0, 1, 1, 1], [1, 1, 0, 0, 1, 0],\n",
    "                                         [1, 1, 1, 1, 1, 0], [0, 2, 2, 0, 2, 1],\n",
    "                                         [2, 2, 2, 2, 2, 0], [2, 0, 0, 2, 2, 1],\n",
    "                                         [0, 1, 0, 1, 0, 0], [2, 1, 1, 1, 0, 0],\n",
    "                                         [1, 1, 0, 0, 1, 1], [2, 0, 0, 2, 2, 0],\n",
    "                                         [0, 0, 1, 1, 1, 0]])\n",
    "\n",
    "label = np.array([1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
    "X_test=np.array([[0, 0, 1, 0, 0, 0], [1, 0, 1, 0, 0, 0],\n",
    "                        [1, 1, 0, 1, 1, 0], [1, 0, 1, 1, 1, 0],\n",
    "                        [1, 1, 0, 0, 1, 1], [2, 0, 0, 2, 2, 0],\n",
    "                        [0, 0, 1, 1, 1, 0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class DecisionTreeClassifier:\n",
    "    def __init__(self):\n",
    "        self.tree = None\n",
    "    \n",
    "    def fit(self, X, Y):\n",
    "        #图4.2 对应输入格式 训练集D 属性集A\n",
    "        D = {}\n",
    "        D['X'] = X  \n",
    "        D['Y'] = Y\n",
    "        A = np.arange(X.shape[1])\n",
    "        self.tree = self.TreeGenerate(D, A)   # self.TreeGenerate这种用法？？？？\n",
    "        \n",
    "    def TreeGenerate(self, D, A):\n",
    "        #情形1\n",
    "        classes = np.unique(D['Y']) #统计有几种label\n",
    "        n_class = len(classes) #统计类别数\n",
    "        if n_class==1:\n",
    "            return classes[0] #选择该特征\n",
    "\n",
    "        #情形2\n",
    "        flag = True #判断所有样本在所有属性上值是否相同\n",
    "        for a in A:\n",
    "            if len(np.unique(D['X'][:,a])) > 1:\n",
    "                flag = False\n",
    "                break\n",
    "        if len(A)==0 or flag:\n",
    "            return np.argmax(np.bincount(D['Y'])) #选择类别数最多的特征\n",
    "\n",
    "        #情形3\n",
    "\n",
    "        #划分\n",
    "\n",
    "        #当前节点 根结点ent \n",
    "        pk = np.bincount(D['Y']) / len(D['Y'])\n",
    "        Ent = 0\n",
    "        for p in range(len(pk)):\n",
    "            Ent -= pk[p] * np.log2(pk[p]) #公式4.1\n",
    "\n",
    "        \n",
    "        Gain = [] #总\n",
    "        for a in A: #a 为总节点下一个特征  以下计算公式4.2\n",
    "            unique = np.unique(D['X'][:, a]) #a字段特征共有多少不同类别的值\n",
    "            Gain_D = Ent #每一个子类的gain\n",
    "            Dv_leaf = [] # dv / D\n",
    "            Ent_leaf = [] #每一个子类的ent\n",
    "            for u in unique:\n",
    "                Ent_ = 0\n",
    "                slices = np.where(D['X'][:, a]==u)  #该值对应样本索引\n",
    "                Dv_D = len(slices[0]) / len(D['X']) #每个类别所占整体比例为多少 D1 / D\n",
    "                Dv_leaf.append(Dv_D)\n",
    "\n",
    "                ps =np.bincount(D['Y'][slices]) / len(D['Y'][slices])  #每个leaf中固定值对应label比例\n",
    "                for p in ps:\n",
    "                    if p != 0:  #ps 由np.bincount计算，可能会包含无值的0，在下式计算中会出现nan\n",
    "                        Ent_ -= p * np.log2(p) #公式4.1\n",
    "\n",
    "                Ent_leaf.append(Ent_)\n",
    "\n",
    "            for u in range(len(unique)):\n",
    "                Gain_D -= Dv_leaf[u] * Ent_leaf[u] #公式4.2\n",
    "                \n",
    "            Gain.append(Gain_D)\n",
    "        \n",
    "        best_attr = A[np.argmax(Gain)] #选择信息增益最大的特征(要在特征集字段A里选择！！！) 图4.2 第8行\n",
    "        tree={best_attr:{}}  #每一个结点都创建这样的dict\n",
    "\n",
    "        subA = np.delete(A, np.argmax(Gain))  #去除best_attr后的属性集\n",
    "        \n",
    "        a_best_attr = np.unique(D['X'][:, best_attr])\n",
    "\n",
    "        for a in a_best_attr: #图4.2 第9行\n",
    "            slices = np.where(D['X'][:, best_attr]==a)  #该值对应样本索引\n",
    "            \n",
    "            #Dv 用来存储其余样本\n",
    "            Dv = {}\n",
    "            Dv['X'] = D['X'][slices]  #line 10\n",
    "            Dv['Y'] = D['Y'][slices]\n",
    "            if len(Dv['Y']) == 0:\n",
    "                tree[best_attr][a]=np.argmax(np.bincount(D['Y'])) #为最佳属性 赋值，作为树的判断\n",
    "            else:\n",
    "                tree[best_attr][a] = self.TreeGenerate(Dv, subA)\n",
    "                \n",
    "        return tree\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dt = DecisionTreeClassifier()\n",
    "dt.fit(watermelon_data, label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3: {0: {1: {0: 1, 1: {0: {0: 1, 1: {5: {0: 1, 1: 0}}}}, 2: 0}}, 1: {5: {0: 0, 1: 1}}, 2: 0}}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(dt.tree)\n",
    "createPlot(dt.tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}