机器学习：CART
CART（Classification And Regression Trees，分类回归树）算法既可以用于分类也可以用于回归
优点：可以对复杂和非线性的数据建模
缺点：结果不易理解
线性回归需要拟合所有的样本（局部加权线性回归除外），当特征众多并且特征之间关系十分复杂时，构建全局模型的想法就显得太难了，也略显笨拙，而且，实际生活中很多问题都是非线性的，不可能使用全局线性模型来拟合，一种可行的方法是将数据集切分成很多份易建模的数据，然后利用线性回归来建模，如果切分后仍然难以拟合线性模型就继续切分，直到样本数太少，切分增益太小，或样本 Y 值一样，等情况出现
前面介绍过另一种树 ID3 算法，这个算法存在以下问题
1. 按某特征切分后，该特征在之后的过程中将不再起作用，有观点认为这种切分过于迅速
2. 不能直接处理连续型特征，只有事先将连续型特征转换成离散型才能使用
ID3 算法每个特征节点可以有 2 个以上的分叉，而 CART 算法只做二元切分
CART 树有两种
回归树：叶子节点是一个常数
模型树：叶子节点是一个分段线性回归函数，模型树的可解释性和准确度优于回归树
算法
找到最佳切分特征及特征值（按该特征及特征值切分使得方差或误差最小）
如不能再分（方差或误差改进小、样本数不够、所有样本 Y 值相同），将节点存为叶节点
叶子节点的值取分到该节点的样本的均值或回归系数
如可以再分，将节点存为非叶子节点，保存用于切分的特征和特征值
将大于切分特征值的样本分到右子树，将小于切分特征值的样本分到左子树
递归调用右子树，递归调用左子树
预测时将待预测样本的特征值和节点的切分特征值比较
按比较结果，大于则走右子树，小于则走左子树，直到叶子节点
如果是回归树，返回叶子节点的 W 值，如果是模型树，返回 XW
代码
# coding=utf-8
import numpy as np
def binSplitDataSet(dataSet, feature, value):
"""
给定特征和特征值，通过数组过滤方式将数据集合切分得到两个子集并返回
dataSet - 样本数据, 每一行的最后一个值是 Y
feature - 要切分的特征
value - 用于切分的特征值
"""
# nonzero(dataSet[:,feature] > value) 返回两数组
# 第1个的值表示行数，第2个的值表示列数，就是几行几列 > value，加上[0]取出所有满足条件的行
mat0 = dataSet[np.nonzero(dataSet[:, feature] > value)[0], :]
mat1 = dataSet[np.nonzero(dataSet[:, feature] <= value)[0], :]
return mat0, mat1
def chooseBestSplit(dataSet, leafType, errType, tolS, tolN):
"""
寻找最佳切分点
dataSet - 样本数据, 每一行的最后一个值是 Y
leafType - 建立叶节点的函数
errType - 误差计算函数
tolS - 如果切分后的增益小于该值就不要切分
tolN - 如果切分后的样本小于该值就不要切分
返回 (最佳切分特征，最佳切分特征值) 或 (None, 叶子节点)
"""
if len(set(dataSet[:, -1].T.tolist()[0])) == 1:
# 如果数据集的所有值都相同，返回 None 表示不需要继续按特征划分，同时构建并返回叶子节点
return None, leafType(dataSet)
m, n = np.shape(dataSet)
# 计算切分前的误差
S = errType(dataSet)
# 最佳的切分特征，切分特征值，切分增益，左子树的样本，右子树的样本
bestIndex = 0
bestValue = 0
bestS = np.inf
# 遍历每一个特征
for featIndex in range(n - 1):
# 遍历每一个特征值
for splitVal in set(dataSet[:, featIndex]):
# 切分
mat0, mat1 = binSplitDataSet(dataSet, featIndex, splitVal)
# 切分后的样本数不够
if (np.shape(mat0)[0] < tolN) or (np.shape(mat1)[0] < tolN):
continue
# 切分后的误差
newS = errType(mat0) + errType(mat1)
# 如果切分后的误差更小，保存特征、特征值、误差
if newS < bestS:
bestIndex = featIndex
bestValue = splitVal
bestS = newS
# 如果误差的改进太小，就不切分了，构建并返回叶子节点
if (S - bestS) < tolS:
return None, leafType(dataSet)
# 返回用于切分的特征、特征值
return bestIndex, bestValue
def createTree(dataSet, leafType, errType, tolS, tolN):
"""
创建 CART 树
dataSet - 样本数据, 每一行的最后一个值是 Y
leafType - 建立叶节点的函数
errType - 误差计算函数
tolS - 如果切分后的增益小于该值就不要切分
tolN - 如果切分后的样本小于该值就不要切分
"""
# 选择最适合用于切分的特征、特征值
feat, val = chooseBestSplit(dataSet, leafType, errType, tolS, tolN)
if feat is None:
# 无法切分, 返回叶子节点
return val
# 切分特征、切分特征值
retTree = {'spInd': feat, 'spVal': val}
# 按切分特征、切分特征值将数据集分为两个子集
lSet, rSet = binSplitDataSet(dataSet, feat, val)
# 递归生成左子树
retTree['left'] = createTree(lSet, leafType, errType, tolS, tolN)
# 递归生成右子树
retTree['right'] = createTree(rSet, leafType, errType, tolS, tolN)
return retTree
def regLeaf(dataSet):
"""
用于构建回归树的叶子节点：所有样本 Y 值的平均值
dataSet - 样本值，最后一位是 Y 值
"""
return np.mean(dataSet[:, -1])
def regErr(dataSet):
"""
用于计算回归树的误差：所有样本 Y 值均方差乘以样本数
dataSet - 样本值，最后一位是 Y 值
"""
return np.var(dataSet[:, -1]) * np.shape(dataSet)[0]
def linearSolve(dataSet):
"""
计算最佳线性回归系数
dataSet - 样本值，最后一位是 Y 值
"""
m, n = np.shape(dataSet)
# 取每一行除最后一位之外的数据，并且第一个值取 1
X = np.mat(np.ones((m, n)))
X[:, 1:n-1] = dataSet[:, 0:n-2]
Y = dataSet[:, -1]
xTx = X.T * X
if np.linalg.det(xTx) == 0.0:
# 没有逆矩阵无法计算
raise ValueError('（X.T * X） 没有逆矩阵，无法求解')
# 计算最佳回归系统 w
ws = xTx.I * (X.T * Y)
return ws, X, Y
def modelLeaf(dataSet):
"""
用于构建模型树的叶子节点：计算最佳回归系数
"""
ws, _, _ = linearSolve(dataSet)
return ws
def modelErr(dataSet):
"""
用于计算模型树的误差：预测值与实际值的平方差
"""
ws, X, Y = linearSolve(dataSet)
yHat = X * ws
return sum(np.power(Y - yHat, 2))
def createRegTree(dataSet):
"""
创建 CART 回归树
dataSet - 样本值，最后一位是 Y 值
"""
return createTree(dataSet, leafType=regLeaf, errType=regErr, tolS=1, tolN=4)
def createModelTree(dataSet):
"""
创建 CART 回归树
dataSet - 样本值，最后一位是 Y 值
"""
return createTree(dataSet, leafType=modelLeaf, errType=modelErr, tolS=1, tolN=4)
def regTreeEval(model, _):
"""
根据回归树的叶子节点预测结果
model - 叶子节点的值 (切分到该叶子节点的样本数据的均值)
"""
return float(model)
def modelTreeEval(model, inDat):
"""
根据模型树的叶子节点预测结果
model - 叶子节点的值 (切分到该叶子节点的样本数据的最佳回归系数)
inDat - 要预测的数据
"""
# 将第一个 X0 值取为 1
n = np.shape(inDat)[1]
X = np.mat(np.ones((1, n + 1)))
X[:, 1:n + 1] = inDat
# 预测 Y = XW
return float(X * model)
def isTree(obj):
"""
判断节点是否叶子节点
"""
return type(obj).__name__ == 'dict'
def predict(tree, inData, modelEval):
"""
预测
tree - CART 树
inData - 要预测的数据
modelEval - 用于处理叶子节点的函数
"""
if not isTree(tree):
# 已经是叶子节点，处理叶子节点，返回预测结果
return modelEval(tree, inData)
if inData[tree['spInd']] > tree['spVal']:
# 走左子树
if isTree(tree['left']):
# 递归左子树
return predict(tree['left'], inData, modelEval)
else:
# 左子树已经是叶子节点
return modelEval(tree['left'], inData)
else:
# 走右子树
if isTree(tree['right']):
# 递归右子树
return predict(tree['right'], inData, modelEval)
else:
# 右子树已经是叶子节点
return modelEval(tree['right'], inData)
def regPredict(tree, testData):
"""
回归树预测
tree - CART 回归树
testData - 要预测的数据
"""
m = len(testData)
yHat = np.mat(np.zeros((m, 1)))
for i in range(m):
yHat[i, 0] = predict(tree, np.mat(testData[i]), regTreeEval)
return yHat
def modelPredict(tree, testData):
"""
模型树预测
tree - CART 模型树
testData - 要预测的数据
"""
m = len(testData)
yHat = np.mat(np.zeros((m, 1)))
for i in range(m):
yHat[i, 0] = predict(tree, np.mat(testData[i]), modelTreeEval)
return yHat
计算实际结果和预测结果的相关系数
可以看到，模型树比回归树效果好，回归树比一般的线性回归好
corrcoef(yHat, testMat[:,1], rowvar=0)
树剪枝
一棵树如果节点过多，说明可能对数据进行了过拟合
通过降低决策树的复杂度（即减少节点）来避免过拟合的过程称为剪枝（pruning）
预剪枝（prepruning）
生成树的过程中进行剪枝
上面 chooseBestSplit() 中停止切分的条件既是，不足的是对参数 tolS 和 tolN 敏感
后剪枝（postpruning）
对已生成的树进行剪枝
用测试集对 CART 进行测试，取预测结果和实际结果的方差
对比叶子节点合并后的预测结果和实际结果的方差
合并后的方差更小则合并叶子节点，新的叶子节点继续看能不能合并
后剪枝代码
def getMean(tree):
"""
对树进行塌陷处理 (即返回树平均值)
"""
if isTree(tree['right']):
# 递归右子树
tree['right'] = getMean(tree['right'])
if isTree(tree['left']):
# 递归左子树
tree['left'] = getMean(tree['left'])
# 取平均值
return (tree['left'] + tree['right']) / 2.0
def prune(tree, testData):
"""
对树进行后剪枝, 这里的树是回归树
tree - 已经生成的树
testData - 测试集
"""
if np.shape(testData)[0] == 0:
# 已经没有测试数据了，进行塌陷处理
return getMean(tree)
if isTree(tree['right']) or isTree(tree['left']):
# 切分测试数据
lSet, rSet = binSplitDataSet(testData, tree['spInd'], tree['spVal'])
if isTree(tree['left']):
# 递归剪枝左子树
tree['left'] = prune(tree['left'], lSet)
if isTree(tree['right']):
# 递归剪枝右子树
tree['right'] = prune(tree['right'], rSet)
if not isTree(tree['left']) and not isTree(tree['right']):
# 如果经过剪枝后，左右都是叶子节点
# 切分测试数据
lSet, rSet = binSplitDataSet(testData, tree['spInd'], tree['spVal'])
# 计算测试数据切分后，和叶子节点之间的方差和
errorNoMerge = sum(np.power(lSet[:, -1] - tree['left'], 2)) \
+ sum(np.power(rSet[:, -1] - tree['right'], 2))
# 合并左右叶子节点
treeMean = (tree['left'] + tree['right']) / 2.0
# 用合并后的叶子节点计算切分前测试数据的方差和
errorMerge = sum(np.power(testData[:, -1] - treeMean, 2))
if errorMerge < errorNoMerge:
# 合并叶子节点后的方差和更小，返回合并后的叶子节点
return treeMean
else:
# 否则返回合并前的树
return tree
else:
# 左右子树有一个不是叶子节点，不合并
return tree
