决策树总结

决策树模型根据当前数据集$D$和属性集$A$不断选定最优划分属性$a_{\ast }$，根据最优属性$a_{\ast }$的每个取值$a_{\ast }^v$产生一个分支子决策树，直到：

• 样本全部属于同一类别，产生叶节点，标记为这个类别
• 属性集$A$为空或者剩下的数据集$D$在任何属性上取值都一样，产生叶节点，标记为$D$中最多的类别
• 数据集$D$为空，产生叶节点，标记为父节点$D$中最多的类别

每个节点包含两个集合当前数据集$D$和属性集$A$，为了产生最优属性，一般希望$D$尽可能属于同一类别，即纯度高，信息熵$E(D)=-\sum p_{k}lo{g}_2{p}_k$（其中$p_k$是第$k$类样本的比例）小。利用属性$a$来划分数据集得到取值为$a^v$的数据集$D^v$，可以计算信息增益$Gain(D,a)=E(D)-{\sum }_{v=1}^V\frac{|D^v|}{|D|}E(D^v)$（$V$是$a$取值的个数），$ID3$决策树就是每次取信息增益最大的属性来划分。实际上信息增益对取值数目较多的属性有偏好（因为取值较多的那个属性产生的分支多，每个分支的类别更有可能纯度更高），这使得决策树不具有泛化能力，$C4.5$还依据增益率选择划分属性$Gain\_radio(D,a)=\frac{Gain(D,a)}{IV(a)}$，其中$IV(a)$是属性$a$的固有值（intrinsic value），定义为$IV(a)=-{\sum }_{v=1}^V\frac{|D^v|}{|D|}lo{g}_2\frac{|D^v|}{|D|}$，$a$的取值数目越多这个值越大，信息增益率对取值数目较少的属性有偏好。实际$C4.5$使用了启发式：从$A$中找到信息增益高于平均水平的属性，再从这些属性中找增益率最高的。$CART$决策树利用基尼指数来选择属性：$Gini(D)=1-\sum p_k^2$，基尼值越小，数据集纯度越高，$CART$决策树使用基尼指数$Gini\_index(D,a)={\sum }_{v=1}^V\frac{|D^v|}{|D|}Gini(D^v)$最大的那个属性作为最优属性。

决策树的分支太多会过拟合，通过决策树生成过程的预剪枝（结点划分不能提升泛化性能就不再分支）和后剪枝（自底向上对非叶结点考察，如果替换成叶节点泛化性能提升，就替换为叶结点）。预剪枝是在每次分支之前判断用验证集判断一下评估指标，如果有提高就分支，否则直接定为叶结点，预剪枝基于当下的“贪心”策略，可能导致欠拟合，因为这次分支可能不能提升性能，但这次分支后再分支可能使性能大大提升。后剪枝通过自底向上尝试替换非叶结点，如果验证集精度提高就进行替换，这样做欠拟合风险很小，泛化能力也优于预剪枝，但后剪枝操作的训练时间大大多余预剪枝和决策树生成。

对于有连续值的属性，可以对$D$中$a$的取值排序，尝试每个划分点$T_a=\{\frac{a^i+a^{i+1}}{2}|1\le i\le n-1\}$，其中$n$是连续值属性$a$在数据集$D$上的取值个数，根据划分点二分离散化$D$后，即可根据离散值的判断方法来选择最优属性，当前结点划分属性为连续属性，该属性还可以作为后代结点的划分属性，只是分割点不同

若某些样本的某些属性有缺失值，可以定义$\tilde{D}$表示$D$在属性$a$上没有缺失的那些样本子集，${\tilde{D}}^v$表示取值为$a=v$的$\tilde{D}$的样本子集，${\tilde{D}}_k$表示分类为第$k$类的$\tilde{D}$的样本子集，为每个样本$x$定义一个权重$w_x$（初始化为1），并定义三个比例：
$$\begin{gathered} \rho =\frac{{\sum }_{x\in \tilde{D}}{w}_x}{{\sum }_{x\in D}{w}_x} \\ {\tilde{p}}_k=\frac{{\sum }_{x\in {\tilde{D}}_k}{w}_x}{{\sum }_{x\in \tilde{D}}{w}_x} \\ {\tilde{r}}_v=\frac{{\sum }_{x\in {\tilde{D}}^v}{w}_x}{{\sum }_{x\in \tilde{D}}{w}_x} \end{gathered}$$
即$\rho$代表无缺失值样本的比例，${\tilde{p}}_k$代表无缺失值样本中第$k$类的比例，${\tilde{r}}^v$代表无缺失值样本$a=a^v$的比例，信息增益即可推广为$Gain(D,a)=\rho \times Gain(\tilde{D},a)=\rho \times (E(\tilde{D})-{\sum }_{v=1}^V{\tilde{r}}^v({\tilde{D}}^v))$，信息熵推广为$E(\tilde{D})=-\sum {\tilde{p}}_{k}lo{g}_2{\tilde{p}}_k$，这样即可在有缺失值的属性集上选择任意属性，若已经选择到了最优属性，分割数据集的时候$x$在最优属性上没有缺失，就正常划分，若缺失了值，就把$x$划分到所有分支数据集中，并且调整$x$在这些取值为$v$的分支中的权重为$w_x={\tilde{r}}_v{w}_x$，直观上看，这就是让同一个样本以不同的概率划分到不同子结点中

直观上看，这就是让同一个样本以不同的概率划分到不同子结点中 不理解什么意思

如果把每个属性视为一个维度坐标轴，$d$个属性描述的样本就对应了$d$维空间中的一个点，每次产生分支实际是在寻找一个分类边界，而这个分类边界一定是与坐标轴平行的，对于复杂的问题，这样以坐标轴平行的分段来做出分割边界会导致时间开销很大，如果能采用斜的划分边界，就能使决策树模型大大简化，这样的决策树就是“多变量决策树”。这样的决策树每次划分数据集并不是以某个维度（即某个属性）的平行于坐标轴的横线（即具体取值）来做的，而是根据某些维度的线性组合来分割的，这样每个非叶结点是一个${\sum }_{i=1}^d{w}_i{a}_i=t$的线性分类器，根据这个分类器来划分节点就能产生斜的决策边界，其中$w_i$和$t$也是由训练得到的

    for i in range(numFeatures):        #iterate over all the features
        featList = [example[i] for example in dataSet]#create a list of all the examples of this feature
        uniqueVals = set(featList)       #get a set of unique values
        newEntropy = 0.0
        for value in uniqueVals:
            subDataSet = splitDataSet(dataSet, i, value)
            prob = len(subDataSet)/float(len(dataSet))
            newEntropy += prob * calcShannonEnt(subDataSet)     
        infoGain = baseEntropy - newEntropy     #calculate the info gain; ie reduction in entropy
        if (infoGain > bestInfoGain):       #compare this to the best gain so far
            bestInfoGain = infoGain         #if better than current best, set to best
            bestFeature = i

《机器学习实战》第三章利用信息熵增益选择最优特征，下面的代码递归创建决策树

def createTree(dataSet,labels):
    classList = [example[-1] for example in dataSet]
    if classList.count(classList[0]) == len(classList): 
        return classList[0]#stop splitting when all of the classes are equal
    if len(dataSet[0]) == 1: #stop splitting when there are no more features in dataSet
        return majorityCnt(classList)
    bestFeat = chooseBestFeatureToSplit(dataSet)
    bestFeatLabel = labels[bestFeat]
    myTree = {bestFeatLabel:{}}
    del(labels[bestFeat])
    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)
    for value in uniqueVals:
        subLabels = labels[:]       #copy all of labels, so trees don't mess up existing labels
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)
    return myTree                            

《机器学习实战》第九章构建$CART$决策树，根据切分的误差最小来选择最优特征和阈值

    bestS = inf; bestIndex = 0; bestValue = 0
    for featIndex in range(n-1):
        for splitVal in set(dataSet[:,featIndex]):
            mat0, mat1 = binSplitDataSet(dataSet, featIndex, splitVal)
            if (shape(mat0)[0] < tolN) or (shape(mat1)[0] < tolN): continue
            newS = errType(mat0) + errType(mat1)
            if newS < bestS: 
                bestIndex = featIndex
                bestValue = splitVal
                bestS = newS

没有实现预剪枝，而实现了后剪枝

def prune(tree, testData):
    if shape(testData)[0] == 0: return getMean(tree) #if we have no test data collapse the tree
    if (isTree(tree['right']) or isTree(tree['left'])):#if the branches are not trees try to prune them
        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 they are now both leafs, see if we can merge them
    if not isTree(tree['left']) and not isTree(tree['right']):
        lSet, rSet = binSplitDataSet(testData, tree['spInd'], tree['spVal'])
        errorNoMerge = sum(power(lSet[:,-1] - tree['left'],2)) +\
            sum(power(rSet[:,-1] - tree['right'],2))
        treeMean = (tree['left']+tree['right'])/2.0
        errorMerge = sum(power(testData[:,-1] - treeMean,2))
        if errorMerge < errorNoMerge: 
            print "merging"
            return treeMean
        else: return tree
    else: return tree

对于回归树，可以在叶节点用线性模型代替常数，这样是“模型树”

def linearSolve(dataSet):   #helper function used in two places
    m,n = shape(dataSet)
    X = mat(ones((m,n))); Y = mat(ones((m,1)))#create a copy of data with 1 in 0th postion
    X[:,1:n] = dataSet[:,0:n-1]; Y = dataSet[:,-1]#and strip out Y
    xTx = X.T*X
    if linalg.det(xTx) == 0.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):#create linear model and return coeficients
    ws,X,Y = linearSolve(dataSet)
    return ws

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