原理

🌲回归的思路和之前提到的CAR分类器是一样的，那个思路是选择类别的紊乱程度最低的状态进行切分。
在连续的数据判读数据状态的紊乱程度，有方差，我们可以通过切分后其总体方差之和是否会变小来作为数据的紊乱程度是否变小，然后将每一小段数据进行上一节的线性回归方式进行回归。
整体思路就是将树和回归进行结合。当然也可以不跟线形回归结合，这里的选择方式有很多也可以用非线性回归，可以根据实际情况进行选择，本文以线形回归为例。
树回归的好处，可以充分的去理解时间的突然性。在股市预测的时候，股市会受到当下的环境所影响，树回归是可以对其进行识别的，结果通过字典的进行保存。
具体的数学公式及证明在前面的内容都已进行解释说明，这里不进行重复。

代码实现

连续数据的切分方式

def binSplit(data,feature,value):
    mat0 = data[data[:,feature] > value,:]
    mat1 = data[data[:,feature] <= value,:]
    return mat0,mat1

叶子结点的均值及方差，可以通过这种方式进行切分，不进行回归，可以对连续数据进行分类。

def regLef(data):
    return data[:,-1].mean()
def regErr(data):
    return data[:,-1].var()*data.shape[0]

通过遍历数据特征及特征所有的数据值进行选取划分方式，ops中的值是做一个预剪枝的方式进行对叶子结点的一个限制（变化后紊乱程度的变化，叶子结点中数据的个数）防止过拟合。

def chooseBestSplit(data,leafType=regLef,errType=regErr,ops=(1,4)):
    tolS = ops[0]; tolN = ops[1]
    if len(set(data[:,-1])) == 1:
        return None,leafType
    m,n = data.shape
    S = errType(data)
    bestS = np.inf ; bestIndex = 0; bestValue = 0
    for featIndex in range(n-1):
        for splitValue in set(data[:,featIndex]):
            mat0,mat1 = binSplit(data,featIndex,splitValue)
            if(mat0.shape[0]<tolN) or (mat1.shape[0]<tolN): continue
            newS = errType(mat0) + errType(mat1)
            if newS < bestS:
                bestS = newS
                bestIndex = featIndex
                bestValue = splitValue
    if (S - bestS) < tolS:
        return None,leafType(data)
    mat0,mat1 = binSplit(data,bestIndex,bestValue)
    if mat0.shape[0] < tolN or mat1.shape[0] < tolN:
        return None, leafType(data)
    return bestIndex,bestValue

用基础版对叶子结点中的数据进行线性回归

def linearSolve(data):
    m,n = data.shape
    x = np.concatenate([np.ones(m).reshape(-1,1),data[:,0].reshape(-1,1)],axis=1)
    y = data[:,-1]
    xTx= x.T@x
    if np.linalg.det(xTx) == 0:
        raise NameError('x con not be inverse')
    ws = np.mat(xTx).I@(x.T@y)
    return np.array(ws)[0],x,y

叶子结点的状态及误差

def modelLeaf(data):
    w,x,y = linearSolve(data)
    return w
def modelerr(data):
    w,x,y = linearSolve(data)
    yhat = x@w
    return sum((yhat-y)**2)

递归的方式生成树并用字典的方式进行保存

def createTree(data,leafType = regLef, errType = regErr,ops=(1,4)):
    feat,val = chooseBestSplit(data,leafType,errType,ops)
    if feat == None: return val
    retTree = {}
    retTree['spInd'] = feat
    retTree['spVal'] = val
    lSet, rSet = binSplit(data,feat,val)
    retTree['left'] = createTree(lSet,leafType,errType,ops)
    retTree['right'] = createTree(rSet,leafType,errType,ops)
    return retTree

这里举一个例子

d = createTree(data,modelLeaf,modelerr)
"""
字典中的内容
{'spInd': 0,
 'spVal': 0.48813,
 'left': array([ 1.21832215, -0.27389304]),
 'right': array([ 0.00779999, -0.22210371])}
"""



sns.set()
sns.scatterplot(data[:,0][data[:,0]<0.48813],data[:,1][data[:,0]<0.48813])
sns.scatterplot(data[:,0][data[:,0]>=0.48813],data[:,1][data[:,0]>=0.48813])
x_ = np.concatenate([np.ones((50,1)),np.linspace(d['spVal'],1,50).reshape(-1,1)],axis=1)
y_ = x_@d['left']
plt.plot(x_[:,-1],y_)


x_ = np.concatenate([np.ones((50,1)),np.linspace(0,d['spVal'],50).reshape(-1,1)],axis=1)
y_ = x_@d['right']
plt.plot(x_[:,-1],y_)