决策树

决策树是一种二叉树，根据观测数据进行训练，以树状的形式对结果进行分类。

分类方法包括：

1，基尼不纯度

用于衡量数据的混乱程度，用于计算某个数据的误差率。

例如，有三个类，发生的概率为p(x)=2/9、p(y)=3/9、p(z)=4/9，其基尼不纯度为：

2/9*（1-2/9）+3/9*（1-3/9）+4/9（1-4/9）

python代码：

def giniimpurity(rows):
  total=len(rows)//总数
  counts=uniquecounts(rows)//各类数据分类
  imp=0
  for k1 in counts:
    p1=float(counts[k1])/total//各类数据概率
    imp += p1 * (1-p1)
  return imp

2，方差（纯数字时使用）

衡量数据偏离程度，公式为：

，其中X为组合里的某个数，u为平均值，N为总数

python代码：

def variance(rows):
  if len(rows)==0: return 0
  data=[float(row[len(row)-1]) for row in rows]
  mean=sum(data)/len(data)
  variance=sum([(d-mean)**2 for d in data])/len(data)
  return variance

3，熵（绝大多数时候使用）

衡量数据偏离程度，公式为：

，其中fi为当前类发生概率

python代码：

# 熵（-p(x)log2(p(x))结果之和）
def entropy(rows):
   from math import log
   log2=lambda x:log(x)/log(2)
   results=uniquecounts(rows)
   # 开始计算熵
   ent=0.0
   for r in results.keys():
      p=float(results[r])/len(rows)
      ent=ent-p*log2(p)
   return ent

以熵作为分类方法为例。为了确定那个变量更加适合拆分，用信息增益来确定。

信息增益公式为：

上级节点熵-左树概率*左数熵-右树概率*右树熵

Python代码：

#决策树（根据熵进行计算，增益熵最大的值进行向下分配）
def buildtree(rows, scoref=entropy):
    if len(rows) == 0: return decisionnode()
    current_score = scoref(rows)

    # 定义一些变量以记录最佳拆分条件
    best_gain = 0.0
    best_criteria = None
    best_sets = None

    column_count = len(rows[0]) - 1
    for col in range(0, column_count):
        # 在当前列中生成一个由不同值构成的序列
        column_values = {}
        for row in rows:
            column_values[row[col]] = 1
        # 根据这个列中值，尝试对数据集进行拆分
        for value in column_values.keys():
            (set1, set2) = divideset(rows, col, value)

            # 信息增益
            p = float(len(set1)) / len(rows)
            # 信息增益=上级熵-左树概率*熵-右数概率*熵
            gain = current_score - p * scoref(set1) - (1 - p) * scoref(set2)
            if gain > best_gain and len(set1) > 0 and len(set2) > 0:
                best_gain = gain
                best_criteria = (col, value)
                best_sets = (set1, set2)
    # 创建子分支
    if best_gain > 0:
        trueBranch = buildtree(best_sets[0])
        falseBranch = buildtree(best_sets[1])
        return decisionnode(col=best_criteria[0], value=best_criteria[1],
                            tb=trueBranch, fb=falseBranch)
    else:
        return decisionnode(results=uniquecounts(rows))

上述方法可能存在一个问题，当有新的训练集输入时，会产生新的分支，而这些分支发生的概率极低，没必要去产生，这种称为过渡拟合。为了避免过渡拟合，我们可以采取，当熵减少数量小于某个值时，不再对其进行分解。