CART决策树的理解及其实现

CART决策树介绍

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

CART回归树

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

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

考虑如何生成回归树。

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

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

当输入空间的划分确定时，可以用平方误差$\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}$$

对固定输入变量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}$$

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

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

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

这里举一个简单的例子，介绍一下连续变量如何切分(和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

李航《统计学习方法》