{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import datasets\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_iris(ratio=0.8, binarization=True):\n",
    "    features, target = datasets.load_iris(True)\n",
    "    \n",
    "    if binarization:\n",
    "        # 将连续特征离散化 -- 根据每个特征的均值作一个简单的二分类\n",
    "        num_feature = features.shape[-1]\n",
    "        feature_mean = np.mean(features, axis=0)\n",
    "        for i in range(num_feature):\n",
    "            features[:, i] = features[:, i] <= feature_mean[i]\n",
    "    \n",
    "    num_samples = len(target)\n",
    "    num_train = math.ceil(num_samples * ratio)\n",
    "    \n",
    "    # 随机打乱数据\n",
    "    idx = np.random.permutation(np.arange(num_samples))\n",
    "    traindata = features[idx[:num_train]], target[idx[:num_train]]\n",
    "    validdata = features[idx[num_train:]], target[idx[num_train:]]\n",
    "    \n",
    "    return traindata, validdata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 作业三\n",
    "\n",
    "## 三、决策树分类器\n",
    "\n",
    "使用C4.5算法和信息增益比来构造决策树\n",
    "\n",
    "前置需求：需要掌握递归的概念\n",
    "\n",
    "请按顺序实现以下几个功能：\n",
    "\n",
    "1. 仿造信息增益的代码，实现信息增益比(IGR) -- 2分 (ETA: ~2小时)\n",
    "2. 从相对的特征下标还原出绝对下标 -- 1分 (ETA: ~1小时)\n",
    "3. 补充完整树的递归构造部分 -- 2分 (ETA: 3~5小时)\n",
    "4. 实现剪枝部分的代码 -- 4分 (ETA: unknown)\n",
    "\n",
    "ETA：>10 hours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "读取数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "(X_train, Y_train), (X_valid, Y_valid) = load_iris()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 一、定义信息增益(IG)与信息增益比(IGR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 不需要修改\n",
    "def IG(features, targets, index=None):\n",
    "    \"\"\"\n",
    "    计算信息增益 (information gain) -- equation (5.9)\n",
    "    \n",
    "    Inputs:\n",
    "      index: None or int\n",
    "        关于features[idx]的信息增益比；若idx为None则计算关于所有特征的信息增益比\n",
    "      features: array of shape (N, C) or (C, )\n",
    "        输入特征\n",
    "      targets : array of shape (N, )\n",
    "        类别\n",
    "    \n",
    "    Outputs:\n",
    "      gains: array of shape (N, C) or number\n",
    "    \"\"\"\n",
    "    \n",
    "    def H(targets):\n",
    "        \"\"\"estimate entropy -- equation (5.7)\"\"\"\n",
    "        target_labels = np.unique(targets)\n",
    "        K = len(target_labels)\n",
    "        num_D = len(targets) # |D|\n",
    "        num_Ck = np.array([np.sum(targets == ck) for ck in target_labels])\n",
    "        \n",
    "        return -np.sum(num_Ck/num_D * np.log2(num_Ck/num_D))\n",
    "    \n",
    "    \n",
    "    def H_cond(feature, targets):\n",
    "        \"\"\"estimate entropy conditional on feature -- equation (5.8)\"\"\"\n",
    "        # equation (5.8)\n",
    "        feature_labels = np.unique(feature)\n",
    "        num_Di = np.array([np.sum(feature == di) for di in feature_labels])\n",
    "        num_D = np.sum(num_Di)\n",
    "        \n",
    "        H_Di = np.array([H(targets[feature == di]) for di in feature_labels])\n",
    "        return np.sum(num_Di/num_D * H_Di)\n",
    "    \n",
    "    \n",
    "    assert features.shape[0] == targets.shape[0]\n",
    "    \n",
    "    # if no idx is provided, calcuate IG with regard to all features\n",
    "    if index is None:\n",
    "        num_features = features.shape[-1]\n",
    "        return np.array([IG(X_train, Y_train, idx) for idx in range(num_features)])\n",
    "    \n",
    "    # equation (5.9)\n",
    "    feature = features[:, index]\n",
    "    return H(targets) - H_cond(feature, targets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "测试IG是否正常工作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.48732446, 0.23328937, 0.7896989 , 0.75985393])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IG(X_train, Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.48732446329948775"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IG(X_train, Y_train, index=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def IGR(features, targets, index=None):\n",
    "    \"\"\"\n",
    "    计算信息增益比 (information gain ratio) -- equation (5.10)\n",
    "    \n",
    "    Inputs:\n",
    "      index : None or int\n",
    "        关于features[idx]的信息增益比；若idx为None则计算关于所有特征的信息增益比\n",
    "      features : array of shape (N, C) or (C, )\n",
    "        输入特征\n",
    "      targets : array of shape (N, )\n",
    "        类别\n",
    "    \n",
    "    Outputs:\n",
    "      gains: array of shape (N, C) or number\n",
    "    \"\"\"\n",
    "    \n",
    "    # 实现它\n",
    "    # 大约30行代码\n",
    "    raise(NotImplementedError())\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "测试IGR是否正常工作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.6006873 ,       -inf, 0.97340096,       -inf])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IGR(X_train, Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6006872965105275"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IGR(X_train, Y_train, index=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 二、决策树的构造"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 计算当前训练集中实例数最大的类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 不需要修改\n",
    "def find_largest_class(targets):\n",
    "    target_labels = np.unique(targets)\n",
    "    idx = [targets==ai for ai in target_labels]\n",
    "    Ck_i = [np.sum(i) for i in idx]\n",
    "    label_idx = np.argmax(Ck_i)\n",
    "    label = target_labels[label_idx]\n",
    "    return label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_largest_class(Y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 从相对的特征下标还原出绝对下标"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为在递归构造决策树的时候涉及到特征集的划分，因此要解决的一个问题是：\n",
    "\n",
    "假设原先为4维数组，依次删除它的第`3, 2, 1`维，则最后剩下的第`0, 1`维分别是原先数组中的第几维？(0, 4)\n",
    "\n",
    "* ori: [a0, a1, a2, a3, a4]\n",
    "* 3  : [a0, a1, a2, a4]\n",
    "* 2  : [a0, a1, a4]\n",
    "* 1  : [a0, a4]\n",
    "\n",
    "依次删除它的第`1, 2, 2`维， 那么剩下的第`0`维是原先数组中的第几维？ (0, 2)\n",
    "\n",
    "* ori: [a0, a1, a2, a3, a4]\n",
    "* 1  : [a0, a2, a3, a4]\n",
    "* 2  : [a0, a2, a4]\n",
    "* 2  : [a0, a2]\n",
    "\n",
    "如果是`0, 0, 0`维，那么剩下的第`0`维是原先数组的第几维？(3, 4)\n",
    "\n",
    "* ori: [a0, a1, a2, a3, a4]\n",
    "* 3  : [a1, a2, a3, a4]\n",
    "* 2  : [a2, a3, a4]\n",
    "* 1  : [a3, a4]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def absolute_index(relative_idx, removed_indices=None):\n",
    "    # 实现它\n",
    "    # 大约10行代码\n",
    "    raise(NotImplementedError())\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n",
      "0\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(absolute_index(0, [3, 2, 1]))\n",
    "print(absolute_index(1, [3, 2, 1]))\n",
    "print(absolute_index(0, [1, 2, 2]))\n",
    "print(absolute_index(1, [1, 2, 2]))\n",
    "print(absolute_index(0, [0, 0, 0]))\n",
    "print(absolute_index(1, [0, 0, 0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecisionTree:\n",
    "    \"\"\"\n",
    "    Attributes:\n",
    "      label : int or None\n",
    "        当前节点对应的分类标签; 只有叶节点才具有标签\n",
    "      children : array of DecisionTree\n",
    "        子树；若为空，则代表当前节点为叶节点，不再向下细分\n",
    "      decision_rule : function\n",
    "        从当前节点向下细分时调用的决策函数\n",
    "      feature_idx : int\n",
    "        当前节点作分类时所判断的特征下标 -- 绘图用\n",
    "      feature_value : array of number\n",
    "        当前节点作分类时所判断的特征的对应值 -- 绘图用\n",
    "    \"\"\"\n",
    "    def __init__(self, eps = 0.1, gain_method = IG):\n",
    "        \"\"\"\n",
    "        Inputs:\n",
    "          eps : number\n",
    "            Alg. 5.2 与 5.3中第四步的阈值，用来避免构造“过细”的节点（默认为0.1）\n",
    "          gain_method : function\n",
    "            增益计算函数，默认为 IG (信息增益)\n",
    "        \"\"\"\n",
    "        self.gain_method = gain_method\n",
    "        self.eps = eps # Alg. 5.1 与 Alg. 5.3 中的阈值\n",
    "        \n",
    "        self.label = None\n",
    "        self.feature_value = None\n",
    "        self.feature_idx = None\n",
    "        self.decision_rule = None\n",
    "        self.children = [] # 子树\n",
    "        \n",
    "        \n",
    "    def __call__(self, features):\n",
    "        return self.predict(features)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return str(self.label) # required by networkX\n",
    "    \n",
    "    def fit(self, features, targets):\n",
    "        self._generate_tree(features, targets)\n",
    "        self._prune_tree(features, targets)\n",
    "        \n",
    "        \n",
    "    def _generate_tree(self, features, targets, removed_indices=None):\n",
    "        # 以算法5.2及5.3中描述的过程构造决策树\n",
    "        # 该算法为递归结构：\n",
    "        # 第 (1)-(3) 步为递归的终止条件\n",
    "        # 第 (4)-(5) 构造当前分支的结构\n",
    "        # 第 (6) 通过递归调用来实现完整的树的构造\n",
    "        \n",
    "        # 在递归过程中特征集会被不断压缩与裁剪，因此当前分支构造时的特征下标并等于训练集中的下标\n",
    "        # 因此这里需要记录之前的特征下标，从而还原出当前特征在原训练集中的位置\n",
    "        if removed_indices is None:\n",
    "            removed_indices = []\n",
    "        \n",
    "        ### 终止条件\n",
    "        # step (1) -- early stop if all targets are of the same class\n",
    "        target_labels = np.unique(targets)\n",
    "        if target_labels.size == 1:\n",
    "            self.label = target_labels[0]\n",
    "            return None\n",
    "        \n",
    "        # step (2) -- early stop if it's an empty feature set\n",
    "        if features.size == 0:\n",
    "            self.label = find_largest_class(targets)\n",
    "            return None\n",
    "        \n",
    "        # step (3) -- find the most significant feature\n",
    "        gains = self.gain_method(features, targets)\n",
    "        feature_idx = np.argmax(gains)\n",
    "        \n",
    "        # step (4) -- early stop if all features are insignificant\n",
    "        if gains[feature_idx] < self.eps:\n",
    "            self.label = find_largest_class(targets)\n",
    "            return None\n",
    "        \n",
    "        ### 递归过程\n",
    "        cur_feature = features[:, feature_idx]\n",
    "        cur_feature_labels = np.unique(cur_feature)\n",
    "        \n",
    "        # 1. generate a decision rule for current node\n",
    "        \n",
    "        if self.label is None:\n",
    "            # self.label is assigned by its parent node -- root node has no parent node\n",
    "            # so we manually generate one label for it\n",
    "            self.label = find_largest_class(targets)\n",
    "        self.feature_value = cur_feature_labels\n",
    "        self.feature_idx = absolute_index(feature_idx, removed_indices)\n",
    "        self.decision_rule = lambda x: x[feature_idx] == cur_feature_labels # onehot encoding\n",
    "        removed_indices.append(feature_idx)\n",
    "        \n",
    "        # recusively label all children nodes\n",
    "        self.children = [DecisionTree(self.eps, self.gain_method) for _ in cur_feature_labels]\n",
    "        # 实现它\n",
    "        # 大约10行代码\n",
    "        raise(NotImplementedError())\n",
    "            \n",
    "    \n",
    "    def _prune_tree(self, features, targets):\n",
    "        # 实现它\n",
    "        pass\n",
    "    \n",
    "    \n",
    "    def predict(self, features):\n",
    "        # 预测单个数据\n",
    "        if len(features.shape) == 1:\n",
    "            return np.array([self._predict_single(features)])\n",
    "        # 批量预测\n",
    "        elif len(features.shape) == 2:\n",
    "            N = features.shape[0]\n",
    "            out = np.zeros((N, ))\n",
    "            for i in range(N):\n",
    "                out[i] = self._predict_single(features[i, :])\n",
    "            return out\n",
    "        else:\n",
    "            raise(ValueError(\"Unsupported features size, should be 1 or 2 dimensional\"))\n",
    "    \n",
    "    \n",
    "    def _predict_single(self, feature):\n",
    "        if len(self.children) == 0:\n",
    "            return self.label\n",
    "        else:\n",
    "            child_idx = np.argmax(self.decision_rule(feature))\n",
    "            child = self.children[child_idx]\n",
    "            return child._predict_single(feature)\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 三、决策树的绘制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 不需要修改\n",
    "def plot_tree(tree: DecisionTree):\n",
    "    G = generate_graph(tree)\n",
    "    pos = generate_position(tree)\n",
    "    edge_labels = generate_labels(tree)\n",
    "    color = generate_color(tree, G)\n",
    "    \n",
    "    nx.draw(G, pos, with_labels=True,\n",
    "            node_size=200, linewidths=5,\n",
    "            node_color=color, vmax=np.max(color)*1.5, cmap=plt.cm.Blues)\n",
    "    \n",
    "    nx.draw_networkx_edge_labels(G, pos=pos, edge_labels = edge_labels)\n",
    "    \n",
    "    \n",
    "def generate_graph(tree):\n",
    "    \"\"\"从DecisionTree中生成一个有向图\"\"\"\n",
    "    \n",
    "    def _generate_graph(graph, tree):\n",
    "        for child in tree.children:\n",
    "            G.add_edge(tree, child, len=40)\n",
    "\n",
    "        for child in tree.children:\n",
    "            _generate_graph(graph, child)\n",
    "    \n",
    "    G = nx.DiGraph()\n",
    "    _generate_graph(G, tree)\n",
    "    return G\n",
    "\n",
    "\n",
    "def generate_labels(tree):\n",
    "    \"\"\"从DecisionTree中生成一个每条边的决策信息\"\"\"\n",
    "    def _generate_labels(labels, tree):\n",
    "        if len(tree.children) == 0:\n",
    "            return None\n",
    "\n",
    "        for (child, value) in zip(tree.children, tree.feature_value):\n",
    "            labels[(tree, child)] = f\"X[{tree.feature_idx}] == {value}\"\n",
    "\n",
    "        for child in tree.children:\n",
    "            _generate_labels(labels, child)\n",
    "            \n",
    "    labels = {}\n",
    "    _generate_labels(labels, tree)\n",
    "    return labels\n",
    "\n",
    "\n",
    "def generate_position(tree):\n",
    "    \"\"\"生成一个树状的位置信息\"\"\"\n",
    "    def _generate_position(pos, tree, level=1, max_level=20):\n",
    "\n",
    "        if tree not in pos:\n",
    "            pos[tree] = np.array([0, 0])\n",
    "\n",
    "        y_offset = -1\n",
    "        x_offsets = np.arange(len(tree.children))\n",
    "        x_offsets = x_offsets - np.mean(x_offsets)\n",
    "        for (child, x_offset) in zip(tree.children, x_offsets):\n",
    "            # offsets are scaled wrt current level to avoid overlap of nodes\n",
    "            pos[child] = pos[tree] + np.array([x_offset, y_offset]) * (max_level-level)/max_level\n",
    "\n",
    "        for child in tree.children:\n",
    "            _generate_position(pos, child, level+1)\n",
    "    \n",
    "    \n",
    "    pos = {}\n",
    "    _generate_position(pos, tree)\n",
    "    return pos\n",
    "\n",
    "\n",
    "def generate_color(tree, graph, max_level=20):\n",
    "    def _generate_color(color, tree, level=1):\n",
    "        if tree not in color:\n",
    "            color[tree] = level\n",
    "\n",
    "        for child in tree.children:\n",
    "            color[child] = level + 1\n",
    "            _generate_color(color, child, level+1)\n",
    "    \n",
    "    \n",
    "    color = {}\n",
    "    _generate_color(color, tree)\n",
    "    return np.array([color[x] for x in graph.nodes])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 四、测试算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy(model):\n",
    "    return np.sum(model.predict(X_valid) == Y_valid)/Y_valid.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对数据特征进行二分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy:0.8000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/pt-stable/lib/python3.7/site-packages/numpy/core/fromnumeric.py:3257: RuntimeWarning: Mean of empty slice.\n",
      "  out=out, **kwargs)\n",
      "/opt/conda/envs/pt-stable/lib/python3.7/site-packages/numpy/core/_methods.py:161: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/opt/conda/envs/pt-stable/lib/python3.7/site-packages/networkx/drawing/nx_pylab.py:579: MatplotlibDeprecationWarning: \n",
      "The iterable function was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use np.iterable instead.\n",
      "  if not cb.iterable(width):\n",
      "/opt/conda/envs/pt-stable/lib/python3.7/site-packages/networkx/drawing/nx_pylab.py:676: MatplotlibDeprecationWarning: \n",
      "The iterable function was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use np.iterable instead.\n",
      "  if cb.iterable(node_size):  # many node sizes\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(X_train, Y_train), (X_valid, Y_valid) = load_iris(binarization=True)\n",
    "\n",
    "model = DecisionTree(gain_method=IGR)\n",
    "model.fit(X_train, Y_train)\n",
    "\n",
    "print(f\"accuracy:{accuracy(model):.4f}\")\n",
    "\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(20, 10)\n",
    "plot_tree(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不对数据特征进行二分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy:0.8000\n"
     ]
    }
   ],
   "source": [
    "(X_train, Y_train), (X_valid, Y_valid) = load_iris(binarization=False)\n",
    "\n",
    "model = DecisionTree(gain_method=IGR)\n",
    "model.fit(X_train, Y_train)\n",
    "\n",
    "print(f\"accuracy:{accuracy(model):.4f}\")\n",
    "\n",
    "# fig = plt.gcf()\n",
    "# fig.set_size_inches(20, 10)\n",
    "# plot_tree(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "AI-Course",
   "language": "python",
   "name": "ai-course"
  },
  "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": 4
}