深入解析CART回归决策树：原理、实现与生产环境优化

1次阅读

没有评论

共计 2949 个字符，预计需要花费 8 分钟才能阅读完成。

CART（Classification and Regression Trees）回归决策树是一种广泛应用的机器学习算法，特别适合解决回归问题。与分类树不同，回归树的目标是预测连续值。CART 回归树的优势在于：

能够处理非线性关系
对异常值不敏感
不需要特征缩放
结果易于解释

在实际应用中，CART 回归树常用于房价预测、销量预测、金融风险评估等场景。它的树形结构可以直观展示决策过程，这在业务解释性要求高的领域尤为重要。

CART 回归树使用平方误差最小化准则来选择最优特征和分割点。对于任意划分特征 A 和分割点 s，定义两个区域：

R1(A,s) = {X|X_A ≤ s}
R2(A,s) = {X|X_A > s}

寻找最优分割的准则是最小化两个区域的平方误差之和：

min_{A,s} [min_{c1} Σ_{x_i∈R1}(y_i – c1)^2 + min_{c2} Σ_{x_i∈R2}(y_i – c2)^2]

其中 c1 和 c2 分别是 R1 和 R2 区域内的输出均值。

树的构建采用递归二分法：

遍历所有特征和可能的分割点
选择使平方误差最小的分割
将数据分为两个子集
对子集递归执行上述步骤，直到满足停止条件

停止条件通常包括：

节点样本数小于阈值
所有样本目标值相同
深度达到限制
误差减少不明显

预测时，样本从根节点开始，根据特征值逐步向下移动，直到到达叶节点，叶节点的均值即为预测值。

以下是完整的 CART 回归树实现，包含节点类和树构建方法：

import numpy as np

class TreeNode:
    """决策树节点类"""
    def __init__(self, feature_idx=None, threshold=None,
                 left=None, right=None, value=None):
        self.feature_idx = feature_idx  # 分割特征索引
        self.threshold = threshold      # 分割阈值
        self.left = left                # 左子树
        self.right = right              # 右子树
        self.value = value              # 叶节点值

class CARTRegressor:
    """CART 回归树实现"""
    def __init__(self, max_depth=None, min_samples_split=2):
        self.max_depth = max_depth
        self.min_samples_split = min_samples_split
        self.root = None

    def _best_split(self, X, y):
        """寻找最佳分割"""
        m, n = X.shape
        if m <= 1:
            return None, None

        best_var = np.inf
        best_idx, best_thr = None, None

        for idx in range(n):
            thresholds = np.unique(X[:, idx])
            for thr in thresholds:
                left_mask = X[:, idx] <= thr
                right_mask = ~left_mask
                if np.sum(left_mask) == 0 or np.sum(right_mask) == 0:
                    continue

                left_var = np.var(y[left_mask])
                right_var = np.var(y[right_mask])
                total_var = left_var + right_var

                if total_var < best_var:
                    best_var = total_var
                    best_idx = idx
                    best_thr = thr

        return best_idx, best_thr

    def _build_tree(self, X, y, depth=0):
        """递归构建树"""
        n_samples = X.shape[0]

        # 停止条件
        if (self.max_depth is not None and depth >= self.max_depth) or \
           (n_samples < self.min_samples_split) or \
           (np.unique(y).size == 1):
            return TreeNode(value=np.mean(y))

        # 寻找最佳分割
        idx, thr = self._best_split(X, y)
        if idx is None:
            return TreeNode(value=np.mean(y))

        # 分割数据
        left_mask = X[:, idx] <= thr
        right_mask = ~left_mask

        # 递归构建子树
        left = self._build_tree(X[left_mask], y[left_mask], depth+1)
        right = self._build_tree(X[right_mask], y[right_mask], depth+1)

        return TreeNode(feature_idx=idx, threshold=thr, left=left, right=right)

    def fit(self, X, y):
        """训练模型"""
        self.root = self._build_tree(X, y)
        return self

    def _predict_single(self, x, node):
        """单个样本预测"""
        if node.value is not None:
            return node.value

        if x[node.feature_idx] <= node.threshold:
            return self._predict_single(x, node.left)
        else:
            return self._predict_single(x, node.right)

    def predict(self, X):
        """批量预测"""
        return np.array([self._predict_single(x, self.root) for x in X])

过拟合是决策树的常见问题，剪枝是主要解决方案：