模型树
观察下图的数据分布，很容易发现可以用两条直线来拟合数据，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。
可以看到，该方法不如前面两种树回归方法。所以，树回归方法在预测复杂数据时会比简单的线性模型要更有效。
