[Python]实现简单决策树

基本思路：

　　通过香农熵来决定每一层使用哪一种标签做分类，分类后，通过多数表决法来决定该层两个节点的类别。每次消耗一个标签，所以一共需要递归“标签个数”层。

# -*- coding:utf-8 -*-
import math
import operator
from collections import Counter

def shannon_ent(dat):
  siz = len(dat)
  return 0.0 - reduce(lambda x, y: x + y,
    map(lambda each: float(each)/siz * math.log(float(each)/siz, 2),
    Counter(map(lambda each: each[-1], dat)).values()))

def split_dataset(dat, axis, val):
  ret = filter(lambda each: each[axis] == val, dat)
  return map(lambda each: each[:axis]+each[axis+1:], ret)

def choose_best_feature(dat):
  feature_num = len(dat[0]) - 1
  base_ent = shannon_ent(dat)
  best_info_gain = 0.0
  best_feature = -1
  for i in range(feature_num):
    feature_list = set([each[i] for each in dat])
    cur_ent = reduce(lambda x, y: x + y,
              map(lambda val: len(split_dataset(dat, i, val))/float(len(dat))*shannon_ent(split_dataset(dat, i, val)),
              feature_list))
    info_gain = base_ent - cur_ent
    if info_gain > best_info_gain:
      best_info_gain, best_feature = info_gain, i
  return best_feature

def majority_count(class_list):
  class_dict = sorted(dict(Counter(class_list)).iteritems(), key=operator.itemgetter(1))
  return class_dict[-1][0]

def create_tree(dat, label):
  class_list = map(lambda each: each[-1], dat)
  if class_list.count(class_list[0]) == len(class_list):
    return class_list[0]
  if len(dat[0]) == 1:
    return majority_count(class_list)
  best_feature = choose_best_feature(dat)
  best_label = label[best_feature]
  d_tree = {best_label:{}}
  del(label[best_feature])
  feature_val = map(lambda each: each[best_feature], dat)
  val_set = set(feature_val)
  def _update_tree(val):
    sub_label = label[:]
    d_tree[best_label][val] = create_tree(split_dataset(dat, best_feature, val), sub_label)
  map(_update_tree, val_set)
  return d_tree

d = [[1,1,'y'], [1,1,'y'], [1,0,'n'], [0,1,'n'], [0,1,'n']]
l = ['no surfacing', 'flippers']

print create_tree(d, l)