模型树

观察下图的数据分布，很容易发现可以用两条直线来拟合数据，0.0 ~ 0.3是一条直线，0.3 ~ 1.0是一条直线，可以得到两个线性模型，这就是所谓的分段线性模型。

可以用树生成算法对数据进行切分，然后将线性模型保存在叶节点。

回顾树回归（一）的createTree()函数，里面有两个参数leafType和errType还没有改变过。这里略作修改，就可以实现模型树。

def linearSolve(dataSet):
    m,n = dataSet.shape
    X = np.mat(np.ones((m,n)))
    Y = np.mat(np.ones((m,1)))
    X[:, 1:n] = dataSet[:, 0:n-1]
    Y = dataSet[:, -1]
    xTx = X.T * X
    if np.linalg.det(xTx) == 0:
        raise NameError('This matrix is singular, cannot do inverse,\n\
        try increasing the second value of ops')
    ws = xTx.I * (X.T * Y)
    return ws, X, Y

def modelLeaf(dataSet):
    ws, X, Y = linearSolve(dataSet)
    return ws

def modelErr(dataSet):
    ws, X, Y = linearSolve(dataSet)
    yHat = X * ws
    return sum(np.power(Y - yHat, 2))

linearSolve()函数主要功能是将数据集格式化成目标变量Y和自变量X，并计算系数。
modelLeaf()与regLeaf()类似，这里是负责生成叶节点的模型。
modelErr()与regErr()类似，用于计算误差。
到这里，模型树的构建代码就完成了。只需要将参数换成modelLeaf和modelErr就可以了。

myMat = np.mat(loadDataSet('exp2.txt'))
createTree(myMat, modelLeaf, modelErr, (1, 10))

运行结果如下：

{'spInd': 0, 'spVal': 0.285477, 'left': matrix([[1.69855694e-03],
         [1.19647739e+01]]), 'right': matrix([[3.46877936],
         [1.18521743]])}

下面看一下拟合效果。

import matplotlib.pyplot as plt
import numpy as np

# 构建模型树
myMat = np.mat(loadDataSet('exp2.txt'))
modelTree = createTree(myMat, modelLeaf, modelErr, (1, 10))

X = np.linspace(0, 1, num=100)
# 直线1
ws1 = modelTree['left']
Y1 = X * float(ws1[1]) + float(ws1[0])
# 直线2
ws2 = modelTree['right']
Y2 = X * float(ws2[1]) + float(ws2[0])

plt.scatter(myMat[:,0].T.tolist()[0], myMat[:,1].T.tolist()[0])
plt.plot(X, Y1, color = 'red')
plt.plot(X, Y2, color = 'yellow')
plt.show()

结果如下

可以看到两条直线都很好的拟合数据，并且模型树的切分点0.285477也很符合数据的实际情况。

树回归与标准回归的比较

接下来将用一份非线性的数据测试模型树、回归树和一般的回归方法，比较哪个最好。

# 回归树预测方法
def regTreeEval(model, inDat):
    return float(model)

# 模型树预测方法
def modelTreeEval(model, inDat):
    n = inDat.shape[1]
    X = np.mat(np.ones((1, n+1)))
    X[:, 1:n+1] = inDat
    return float(X*model)

def treeForeCast(tree, inData, modelEval = regTreeEval):
    if not isTree(tree):
        return modelEval(tree, inData)
    if inData[tree['spInd']] > tree['spVal']:
        if isTree(tree['left']):
            return treeForeCast(tree['left'], inData, modelEval)
        else:
            return modelEval(tree['left'], inData)
    else:
        if isTree(tree['right']):
            return treeForeCast(tree['right'], inData, modelEval)
        else:
            return modelEval(tree['right'], inData)

def createForeCast(tree, testData, modelEval=regTreeEval):
    m = len(testData)
    yHat = np.mat(np.zeros((m,1)))
    for i in range(m):
        yHat[i, 0] = treeForeCast(tree, np.mat(testData[i]), modelEval)
    return yHat

用到的数据集的数据分布如下。

# 加载数据集
trainMat = np.mat(loadDataSet('bikeSpeedVsIq_train.txt'))
testMat = np.mat(loadDataSet('bikeSpeedVsIq_test.txt'))
# 构建回归树
regTree = createTree(trainMat, ops=(1,20))
# 预测
regHat = createForeCast(regTree, testMat[:,0])
# 计算相关系数
np.corrcoef(regHat, testMat[:,1], rowvar=0)[0,1]

结果为0.964。

# 构建模型树
modelTree = createTree(trainMat, modelLeaf, modelErr, ops=(1,20))
# 预测
modelHat = createForeCast(modelTree, testMat[:,0], modelTreeEval)
# 计算相关系数
np.corrcoef(modelHat, testMat[:,1], rowvar=0)[0,1]

结果为0.976。
从上面的结果来看，模型树的效果要比回归树好。接下来看看一般的线性回归效果如何。

simpleRegHat = np.mat(np.zeros((testMat.shape[0],1)))
ws, X, Y = linearSolve(trainMat)
for i in range(testMat.shape[0]):
    simpleRegHat[i] = testMat[i,0]*ws[1,0] + ws[0,0]
np.corrcoef(simpleRegHat, testMat[:,1], rowvar=0)[0,1]

这里用前面已经实现的linearSolve()函数来求解线性方程。然后循环计算预测值，最后计算得到的相关系数为0.943。
可以看到，该方法不如前面两种树回归方法。所以，树回归方法在预测复杂数据时会比简单的线性模型要更有效。