决策树

定义

决策树

1. 分类决策树模型是表示基于特征对实例进行分类的树形结构。决策树可以转换成一个if-then规则的集合，也可以看作是定义在特征空间划分上的类的条件概率分布。
2. 决策树学习旨在构建一个与训练数据拟合很好，并且复杂度小的决策树。因为从可能的决策树中直接选取最优决策树是NP完全问题。现实中采用启发式方法学习次优的决策树。决策树学习算法包括3部分：特征选择、树的生成和树的剪枝。常用的算法有ID3、 C4.5和CART。
3. 特征选择的目的在于选取对训练数据能够分类的特征。特征选择的关键是其准则。常用的准则如下：
   • 样本集合 ? 对特征 ? 的信息增益（ID3）
     $$\begin{array}{c}g(D,A)=H(D)-H(D\mid A)\\ H(D)=-\sum _{k=1}^K\frac{\left|C_k\right|}{|D|}{\log }_2\frac{\left|C_k\right|}{|D|}\\ H(D\mid A)=\sum _{i=1}^n\frac{\left|D_i\right|}{|D|}H\left(D_i\right)\end{array}$$
     其中， $H(D)$ 是数据集 $D$ 的樀， $H\left(D_i\right)$ 是数据集 $D_i$ 的熵， $H(D\mid A)$ 是数据集 $D$ 对特征 $A$ 的条件熵。 $D_i$ 是 $D$ 中特征 $A$ 取第 $i$ 个值的样本子集， $C_k$ 是 $D$ 中属于第 $k$ 类 的样本子集。 $n$ 是特征 $A$ 取 值的个数， $K$ 是卖的个数。
     2.样本犨合 $D$ 对特征 $A$ 的信自增益比 (C4.5)
     $$g_R(D,A)=\frac{g(D,A)}{H(D)}$$
     其中， $g(D,A)$ 是信自增益， $H(D)$ 是数据集 $D$ 的熵。
     3.样本集合 $D$ 的基尼指数 (CART)
     $$\mathrm{Gini}(D)=1-\sum _{k=1}^K{\left(\frac{\left|C_k\right|}{|D|}\right)}^2$$
     特征 $A$ 条件下集合 $D$ 的基尼指数:
     $$\mathrm{Gini}(D,A)=\frac{\left|D_1\right|}{|D|}\mathrm{Gini}\left(D_1\right)+\frac{\left|D_2\right|}{|D|}\mathrm{Gini}\left(D_2\right)$$
     4.决策树的生成。通常使用信息增益最大、信息增益比最大或基尼指数最小作为特征选择的准则。决策树的生成往往通过计算信息增益或其他指标，从根结点开 始，递归地产生决策树。这相当于用信自增益或其他准则不断地选取局部最优的特征，或将圳练集分割为能够基本正确分类的子集。
     5.决策树的剪枝。由于生成的决策树存在过拟合问题，需要对它进行剪枝，以简化学到的决策树。决策树的剪枝，往往从已生成的树上剪掉一些叶结点或叶结点 以上的子树，并将其父结点或根结点作为新的叶结点，从而简化生成的决策树。

概念

熵

$$H(p)=H(X)=-\sum _{i=1}^n{p}_i\log p_i$$

熵只与$X$的分布有关，与$X$取值无关**，这句注意理解

定义$0\log 0=0$,熵是非负的。

条件熵

随机变量$(X,Y)$的联合概率分布为

$P(X=x_i,Y=y_j)=p_{ij},i=1,2,\dots ,n;j=1,2,\dots ,m$

条件熵$H(Y|X)$表示在已知随机变量$X$的条件下随机变量$Y$的不确定性
$$H(Y|X)=\sum _{i=1}^n{p}_{i}H(Y|X=x_i)$$
其中$p_i=P(X=x_i),i=1,2,\dots ,n$

经验熵， 经验条件熵

当熵和条件熵中的概率由数据估计(特别是极大似然估计)得到时，所对应的熵与条件熵分别称为经验熵和经验条件熵

就是从已知的数据计算得到的结果。

信息增益

特征$A$对训练数据集$D$的信息增益$g(D|A)$，定义为集合$D$的经验熵$H(D)$与特征$A$给定的条件下$D$的经验条件熵$H(D|A)$之差。
$$g(D,A)=H(D)-H(D|A)$$
熵与条件熵的差称为互信息.
决策树中的信息增益等价于训练数据集中的类与特征的互信息。
考虑ID这种特征， 本身是唯一的。按照ID做划分， 得到的经验条件熵为0, 会得到最大的信息增益。所以， 按照信息增益的准则来选择特征， 可能会倾向于取值比较多的特征。
$$\begin{gathered} g_R(D,A)=\frac{g(D,A)}{H_A(D)} \\ {H}_A(D)=-\sum _{i=1}^n\frac{D_i}{D}lo{g}_2\frac{D_i}{D} \end{gathered}$$

算法

信息增益算法

输入：训练数据集 $D$ 和特征 $A$
输出：特征 $A$ 对训练数据集 $D$ 的信息增益 $g(D,A)$

1. 数据集 $D$ 的经验樀 $H(D)=-{\sum }_{k=1}^K\frac{|C_k|}{|D|}{\log }_2\frac{|C_k|}{|D|}$
2. 特征 $A$ 对数据集 $D$ 的经验条件樀 $H(D\mid A)={\sum }_{i=1}^n\frac{|D_i|}{|D|}H\left(D_i\right)=-{\sum }_{i=1}^n\frac{|D_i|}{|D|}{\sum }_{k=1}^K\frac{|D_{ik}|}{|D_i|}{\log }_2\frac{|D_{ik}|}{|D_i|}$
3. 信息增益 $g(D,A)=H(D)-H(D\mid A)$

ID3算法

输入：训练数据集 $D$, 特征集 $A$ ，阈值 $ϵ$
输出: 决策树 $T$

1. 如果 $D$ 属于同一类 $C_k，T$ 为单节点树，类 $C_k$ 作为该节点的类标记，返回 $T$
2. 如果 $A$ 是空集，置 $T$ 为单节点树，实例数最多的类作为该节点类标记，返回 $T$
3. 计算 $g$, 选择信息增益最大的特征 $A_g$
4. 如果 $A_g$ 的信息增益小于 $ϵ，T$ 为单节点树， $D$ 中实例数最大的类 $C_k$ 作为类标记，返回 $T$
5. $A_g$ 划分若干非空子集 $D_i$ ，
6. $D_i$ 训练集， $A-A_g$ 为特征集，递归调用前面步骤，得到 $T_i$ ，返回 $T_i$

C4.5生成

输入：训练数据集$D$, 特征集$A$，阈值$ϵ$
输出：决策树$T$

1. 如果$D$属于同一类$C_k$，$T$为单节点树，类$C_k$作为该节点的类标记，返回$T$
2. 如果$A$是空集, 置$T$为单节点树，实例数最多的作为该节点类标记，返回$T$
3. 计算$g$, 选择信息增益比最大的特征$A_g$
4. 如果$A_g$的信息增益比小于$ϵ$，$T$为单节点树，$D$中实例数最大的类$C_k$作为类标记，返回$T$
5. $A_g$划分若干非空子集$D_i$，
6. $D_i$训练集，$A-A_g$为特征集，递归调用前面步骤，得到$T_i$，返回$T_i$
   ID3和C4.5在生成上，差异只在准则的差异。

树的剪枝

决策树损失函数摘录如下：

树$T$的叶结点个数为$|T|$，$t$是树$T$的叶结点，该结点有$N_t$个样本点，其中$k$类的样本点有$N_{tk}$个，$H_t(T)$为叶结点$t$上的经验熵， $\alpha ⩾0$为参数，决策树学习的损失函数可以定义为
$$C_{\alpha }(T)=\sum _{i=1}^{|T|}{N}_t{H}_t(T)+\alpha |T|$$
其中
$$H_t(T)=-\sum _k\frac{N_{tk}}{N_t}\log \frac{N_{tk}}{N_t}$$

$$C(T)=\sum _{t=1}^{|T|}{N}_t{H}_t(T)=-\sum _{t=1}^{|T|}\sum _{k=1}^K{N}_{tk}\log \frac{N_{tk}}{N_t}$$

这时有
$$C_{\alpha }(T)=C(T)+\alpha |T|$$
其中$C(T)$表示模型对训练数据的误差，$|T|$表示模型复杂度，参数$\alpha ⩾0$控制两者之间的影响。
上面这组公式中，注意红色部分，下面插入一个图：

这里面没有直接对$H_t(T)$求和，系数$N_t$使得$C(T)$和$|T|$的大小可比拟。这个地方再理解下。

输入：生成算法生成的整个树$T$，参数$\alpha$
输出：修剪后的子树$T_{\alpha }$

1. 计算每个结点的经验熵
2. 递归的从树的叶结点向上回缩
   假设一组叶结点回缩到其父结点之前与之后的整体树分别是$T_B$和$T_A$，其对应的损失函数分别是$C_{\alpha }(T_A)$和$C_{\alpha }(T_B)$，如果$C_{\alpha }(T_A)⩽C_{\alpha }(T_B)$则进行剪枝，即将父结点变为新的叶结点
3. 返回2，直至不能继续为止，得到损失函数最小的子树$T_{\alpha }$

最小二乘回归树生成

输入：训练数据集 $D$
输出: 回归树 $f(x)$
步骤:

1. 遍历变量 $j$ ，对固定的切分变量 $j$ 扫描切分点 $s$ ，得到满足上面关系的 $(j,s)$
   $$\underset{j,s}{\min }\left[\underset{c_1}{\min }\sum _{x_i\in R_1(j,s)}{\left(y_i-c_1\right)}^2+\underset{c_2}{\min }\sum _{x_i\in R_2(j,s)}{\left(y_i-c_2\right)}^2\right]$$
2. 用选定的 $(j,s)$, 划分区域并决定相应的输出值
   $$\begin{array}{rl}{R}_1(j,s)& =\left\{x\mid x^{(j)}\le s\right\},R_2(j,s)=\left\{x\mid x^{(j)}>s\right\}\\ {\hat{c}}_m& =\frac{1}{N}\sum _{x_i\in R_m(j,s)}{y}_j,x\in R_m,m=1,2\end{array}$$
3. 对两个子区域调用(1)(2)步骤，直至满足停止条件
4. 将输入空间划分为 $M$ 个区域 $R_1,R_2,\dots ,R_M$ ，生成决策树:
   $$f(x)=\sum _{m=1}^M{\hat{c}}_{m}I\left(x\in R_m\right)$$

CART分类树生成

策略是基尼系数，所以是分类树的生成算法。
概率分布的基尼指数定义:
$$Gini(p)=\sum _{k=1}^K{p}_k(1-p_k)=1-\sum _{k=1}^K{p}_k^2$$
基尼系数是一个来源于经济学的指标. 范围(0, 1), 有很多中表示形式, 比如衡量收入分布的基尼系数.
$$G=\frac{1}{n-1}\sum _{j=1}^n(2j-n-1)p(i_j)$$

经济学基尼系数的解释,基尼系数为$\frac{A}{A+B}$

实现以及统计学习书上实例

def create_data():
    datasets = [['青年', '否', '否', '一般', '否'],
               ['青年', '否', '否', '好', '否'],
               ['青年', '是', '否', '好', '是'],
               ['青年', '是', '是', '一般', '是'],
               ['青年', '否', '否', '一般', '否'],
               ['中年', '否', '否', '一般', '否'],
               ['中年', '否', '否', '好', '否'],
               ['中年', '是', '是', '好', '是'],
               ['中年', '否', '是', '非常好', '是'],
               ['中年', '否', '是', '非常好', '是'],
               ['老年', '否', '是', '非常好', '是'],
               ['老年', '否', '是', '好', '是'],
               ['老年', '是', '否', '好', '是'],
               ['老年', '是', '否', '非常好', '是'],
               ['老年', '否', '否', '一般', '否'],
               ]
    labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']
    # 返回数据集和每个维度的名称
    return datasets, labels

datasets, labels = create_data()
train_data = pd.DataFrame(datasets, columns=labels)

信息增益

# 定义节点类 二叉树
class Node:
    def __init__(self, root=True, label=None, feature_name=None, feature=None):
        self.root = root
        self.label = label
        self.feature_name = feature_name
        self.feature = feature
        self.tree = {}
        self.result = {
            'label:': self.label,
            'feature': self.feature,
            'tree': self.tree
        }

    def __repr__(self):
        return '{}'.format(self.result)

    def add_node(self, val, node):
        self.tree[val] = node

    def predict(self, features):
        if self.root is True:
            return self.label
        return self.tree[features[self.feature]].predict(features)

算法实现

class DTree:
    def __init__(self, epsilon=0.1):
        self.epsilon = epsilon
        self._tree = {}

    # 熵
    @staticmethod
    def calc_ent(datasets):
        data_length = len(datasets)
        label_count = {}
        for i in range(data_length):
            label = datasets[i][-1]
            if label not in label_count:
                label_count[label] = 0
            label_count[label] += 1
        ent = -sum([(p / data_length) * log(p / data_length, 2)
                    for p in label_count.values()])
        return ent

    # 经验条件熵
    def cond_ent(self, datasets, axis=0):
        data_length = len(datasets)
        feature_sets = {}
        for i in range(data_length):
            feature = datasets[i][axis]
            if feature not in feature_sets:
                feature_sets[feature] = []
            feature_sets[feature].append(datasets[i])
        cond_ent = sum([(len(p) / data_length) * self.calc_ent(p)
                        for p in feature_sets.values()])
        return cond_ent

    # 信息增益
    @staticmethod
    def info_gain(ent, cond_ent):
        return ent - cond_ent

    def info_gain_train(self, datasets):
        count = len(datasets[0]) - 1
        ent = self.calc_ent(datasets)
        best_feature = []
        for c in range(count):
            c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))
            best_feature.append((c, c_info_gain))
        # 比较大小
        best_ = max(best_feature, key=lambda x: x[-1])
        return best_

    def train(self, train_data):
        """
        input:数据集D(DataFrame格式)，特征集A，阈值eta
        output:决策树T
        """
        _, y_train, features = train_data.iloc[:, :
                                               -1], train_data.iloc[:,
                                                                    -1], train_data.columns[:
                                                                                            -1]
        # 1,若D中实例属于同一类Ck，则T为单节点树，并将类Ck作为结点的类标记，返回T
        if len(y_train.value_counts()) == 1:
            return Node(root=True, label=y_train.iloc[0])

        # 2, 若A为空，则T为单节点树，将D中实例树最大的类Ck作为该节点的类标记，返回T
        if len(features) == 0:
            return Node(
                root=True,
                label=y_train.value_counts().sort_values(
                    ascending=False).index[0])

        # 3,计算最大信息增益 同5.1,Ag为信息增益最大的特征
        max_feature, max_info_gain = self.info_gain_train(np.array(train_data))
        max_feature_name = features[max_feature]

        # 4,Ag的信息增益小于阈值eta,则置T为单节点树，并将D中是实例数最大的类Ck作为该节点的类标记，返回T
        if max_info_gain < self.epsilon:
            return Node(
                root=True,
                label=y_train.value_counts().sort_values(
                    ascending=False).index[0])

        # 5,构建Ag子集
        node_tree = Node(
            root=False, feature_name=max_feature_name, feature=max_feature)

        feature_list = train_data[max_feature_name].value_counts().index
        for f in feature_list:
            sub_train_df = train_data.loc[train_data[max_feature_name] ==
                                          f].drop([max_feature_name], axis=1)

            # 6, 递归生成树
            sub_tree = self.train(sub_train_df)
            node_tree.add_node(f, sub_tree)

        # pprint.pprint(node_tree.tree)
        return node_tree

    def fit(self, train_data):
        self._tree = self.train(train_data)
        return self._tree

    def predict(self, X_test):
        return self._tree.predict(X_test)
       

训练数据

datasets, labels = create_data()
data_df = pd.DataFrame(datasets, columns=labels)
dt = DTree()
tree = dt.fit(data_df)

打印树

{'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}

链接: DataWhale.