CART决策树的理解及其实现

时间 2021-02-18

标签算法 app dom 学习测试 spa code blog 排序栏目 HTML 繁體版

原文原文链接

CART决策树介绍

使用CART(Classification and regression tree)算法构建的决策树是二叉树，它对特征进行二分，迭代生成决策树。算法

CART回归树

假设X与Y分别为输入和输出变量，而且Y是连续变量，给定训练数据集app

$$D=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\}$$dom

考虑如何生成回归树。学习

一个回归树对应着输入空间(即特征空间)的一个划分以及在划分的单元上的输出值。假设已将输入空间划分为M个单元$R_1|R_2,...,R_M$,而且在每一个单元$R_m$上有一个固定的输出值$c_m$，因而回归树模型可表示为测试

$$f(x)=\sum_{m=1}^Mc_mI(x\in R_m)\tag{1}$$ui

当输入空间的划分肯定时，能够用平方偏差$\sum_{x_i\in R_m}(y_i-f(x_i))^2$来表示回归树对于训练数据的预测偏差，用平方偏差最小的准则求解每一个单元上的最优输出值。易知，单元$R_m$上的$c_m$的最优值$\hat{c_m}$是$R_m$上的全部输入实例$x_i$对应的输出$y_i$的均值，即
$$\hat{c_m}=ave(y_i|x_i\in R_m)\tag{2}$$
这里选择第j个遍历$x^{j}$和它的取值s，做为切分遍历和切分点，并定义两个区域(左右结点)
$$\begin{cases} R_1(j,s)=\{x|x^{j}\leq s\}\\ R_2(j,s)=\{x|x^{j}> s\} \end{cases} \tag{3}$$
而后寻找最优切分变量j个最优切分点s。具体地，求解
$$min_{j,s}[min_{c_1}\sum_{x_i\in R_1(j,s)}(y_i-c_1)^2+min_{c_2}\sum_{x_i\in R_2(j,s)}(y_i-c_2)^2]\tag{4}$$spa

对固定输入变量j能够找到最优切分点s
$$\begin{cases}\hat{c_1}=ave(y_i|x_j\in R_1(j,s))\\ \hat{c_2}=ave(y_i|x_i\in R_2(j, s))\end{cases} \tag{5}$$code

遍历全部输入变量，找到最优的切分变量j，构成一对(j,s)。以此将输入空间划分为两个区域。接着，对每一个区域重复上述划分过程，知道知足中止条件为止(能够是知足叶子结点个数或偏差阈值等条件)。这样就生成一颗回归树。这样的树一般称为最小二乘回归树。blog

具体过程以下
输入：训练数据集D(N,J)
输出：回归树f(x)排序

选择最优切分变量(特征)和切分点遍历全部特征。对该特征，按照式（3）依次计算第j个特征下的每一个取值对应的平方偏差。选择最小的特征和特征切分点对。
使用上一步获得的最佳的特征和特征切分对数据集D进行切分，获得左子树(知足条件进入)和右子树(不知足条件进入)。
继续执行步骤1和2(生成子树)，直至知足中止条件。
获得回归树。

这里举一个简单的例子，介绍一下连续变量如何切分(和C4.5的处理方式是同样的)。
下表是一个数据集，包含了一个特征x，x为连续变量。y为类别标签。如今利用这个数据集来构建一个CART回归树。

x	1	2	3	4	5	6	7	8	9
y	0.3	0.5	0.7	0.8	0.95	1.3	1.5	1.6	1.9

首先须要选择特征和特征切分点
特征x包含了9个元素，长度为9，这里x已经排序好了，直接以$\frac{x_i+x_{i+1}}{2},i\in \{1,2,..., 9\}$做为切分点(一种经常使用的切分方式)。

从第一个切分点开始，第一个切分点为$\frac{1 + 2}{2}=1.5$。小于1.5则归到$R_1$(左子树)，大于1.5则归为$R_2$(右子树)。
根据式（3）可得，$R_1=\{1\}$,$R_1=\{2,3,4,5,6,7,8,9\}$,根据式（5）可得，$c_1=0.3$,$c_2=\frac{0.5+0.7+0.8+0.95+1.3+1.5+1.6+1.9}{8}$,因此根据式（4）,第一个切分点对应平方偏差为$0+0.21=0.21$。按照这种方式依次计算每一个切分点对应的偏差，选择具备最小偏差的切分点。

CART分类树

CART分类树使用最小基尼指数（Gini）准则来选择特征,同时决定最优切分点。
基尼指数的定义以下
$$G(p)=\sum_{k=1}^Kp_k(1-p_k)=1-\sum_{k=1}^Kp_k^2\tag{6}$$
对于指定的数据集D，其基尼系数为：
$$G(D)=\sum_{k=1}^K\frac{|C_k|}{|D|}(1-\frac{|C_k|}{|D|})\tag{6}$$
$|C_k|$表示第k类的样本数目。

设特征A的取值将数据集D分红两部分$D_1$和$D_2$。在特征A的条件下，数据集D的基尼系数定义为：
$$G(D,A)=\sum_{k=1}^K\frac{|D_1|}{|D|}G(D_1)+\sum_{k=1}^K\frac{|D_2|}{|D|}G(D_2)$$

G(D)表示数据集D的不肯定性，基尼指数越大，不肯定性越大。这点和熵比较类似。

CART分类决策树和上一节中的ID3和C4.5构建决策树的差异不大，这里就不细说。下面直接给出CART分类树构建的代码。

代码实现

结点

class Node:
    def __init__(self, val, tag=None):
        """
        Params:
            val: 特征名(内部节点)或类别标签(叶子节点)
            tag: 切分点
            left: 左子树
            right: 左子树
        """
        self.val = val
        self.left = None
        self.right = None
        self.tag = tag
        
    def __str__(self):
        return f'val: {self.val}, tag: {self.tag}'

CART分类树

class CARTClassifier:
    def __init__(self, thresh=1e-3, feat_names=None):
        self.tree = None
        self.feat_names = feat_names
        self.thresh = thresh
    
    def fit(self, x_train, y_train):
        """
        构建决策树
        """
        self.tree = self._build(x_train, y_train)
        print('Finish train...')

    def predict(self, x_test, y_test=None):
        """
        预测
        """
        if self.tree == None:
            return 
        
        y_pred = []
        for x in x_test:
            y_pred.append(self._search(x))
            
        y_pred = np.array(y_pred)
        if y_test is not None:
            self._score(y_test, y_pred)
            
        return y_pred
         
    
    def _search(self, x):
        """
        根据特征取值进行搜索
        """
        root = self.tree
        tag = root.tag
        while tag is not None:
            idx = self.feat_names.index(root.val)
            if isinstance(x[idx], str):
                root = root.left if x[idx] == root.tag else root.right
            else:
                root = root.left if x[idx] < root.tag else root.right
            tag = root.tag
            
        return root.val
    
    
    
    def _score(self, y_test, y_pred):
        """
        计算预测得分(准确率)
        """
        self.score = np.count_nonzero(y_test == y_pred) / len(y_test)
        
    def _build(self, x, y):
        """
        Params:
            x(pandas.DataFrame): 特征features
            y(pandas.DataFrame or numpy.array): 标签labels
        """
        cks, cnts = np.unique(y, return_counts=True)
        if len(cks) == 1:
            return Node(cks[0])
        
        if x.shape[0] == 0:
            return None
        
        self.feat_names = list(x.columns)
        best_gini = float('inf')
        best_split = None
        best_feat = 0
#         特征选择
        for i in range(x.shape[1]):
            if x.iloc[:, i].dtypes != 'object':
                gini, split = self.calc_cond_gini_continuous(x.iloc[:, i], y)
            else:
                gini, split = self.calc_cond_gini(x.iloc[:, i], y)
            if gini < best_gini:
                best_gini = gini
                best_split = split
                best_feat = i
                
        if best_gini < self.thresh:
            return Node(cks[cnts.argmax(0)])
        
        tree = Node(self.feat_names[best_feat], best_split)
#       连续特征处理
        if x.iloc[:, best_feat].dtypes != 'object':
            fmask = x.iloc[:, best_feat] < best_split
            bmask = x.iloc[:, best_feat] > best_split
#       离散特征处理
        else:
            fmask = x.iloc[:, best_feat] == best_split
            bmask = x.iloc[:, best_feat] != best_split
        
        tree.left = self._build(x[fmask], y[fmask])
        tree.right = self._build(x[bmask], y[bmask])
        
        return tree
        
    #     计算基尼系数
    def calc_gini(self, label):
        gini = 0
        
        for (ck, cnt) in zip(*np.unique(label, return_counts=True)):
            prob_ck = cnt / len(label) 
            gini += prob_ck * (1 - prob_ck)  
        return gini
    

    #     处理离散特征
    def calc_cond_gini(self, feat, label):
        cks = np.unique(feat)
        best_gini = float('inf')
        best_split = 0
        for ck in cks:
            fmask = feat == ck
            bmask = feat != ck
            cond_gini = sum(fmask) * self.calc_gini(label[fmask])/ len(label) + sum(bmask) * self.calc_gini(label[bmask])/ len(label)

            if cond_gini < best_gini:
                best_gini = cond_gini
                best_split = ck

        return best_gini, best_split

        
        
    #     处理连续特征
    def calc_cond_gini_continuous(self, feat, label):
    #   对特征进行升序排序
        sorted_feat = np.sort(feat, axis=0)
        sorted_feat = np.unique(sorted_feat)
    #    肯定可能的划分点 
        split_pos = (sorted_feat[:-1] + sorted_feat[1:]) / 2
        best_gini = float('inf')
        best_split = 0
        for pos in split_pos:
            lmask = feat < pos
            rmask = feat > pos
            
            cond_gini = sum(lmask) * self.calc_gini(label[lmask])/ len(label) + sum(rmask) * self.calc_gini(label[rmask])/ len(label)

            if cond_gini < best_gini:
                best_gini = cond_gini
                best_split = pos

        return best_gini, best_split

            
    def pruning(self, tree, x_test, y_test):
        """
        后剪枝
        
        根据测试集, 对建立好的决策树进行剪枝
        
        """
#         TODO
        pass
    
    def preorder(self):
        """
        决策树前序遍历
        """
        print('--- PreOrder ---')
        tree = self.tree
        self._preorder(tree)
        
    def _preorder(self, tree):
        if tree == None:
            return 
        print(tree)
        self._preorder(tree.left)
        self._preorder(tree.right)

构建CART决策树并执行分类，这里仍是以Iris数据集为例

# 读取数据
data = load_iris()
x, y = data['data'], data['target']

# 分割成训练集和测试集
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=20190320, test_size=0.1)


x_train = pd.DataFrame(x_train, columns=data.feature_names, index=None)

# 构建决策树
tree = CARTClassifier()
tree.fit(x_train, y_train)

# CART决策树前序遍历
tree.preorder()

# 执行预测
y_pred = tree.predict(x_test, y_test)
print(tree.score)

代码实现结果

总结

本节主要介绍了CART回归树和分类树的构建过程，决策树的剪枝以后再讨论吧，就这样吧。

Reference

李航《统计学习方法》