Python機器學習算法之決策樹算法的實現與優缺點

import numpy as np
import math
from collections import Counter

# 創建數據
def create_data():
    X1 = np.random.rand(50, 1)*100
    X2 = np.random.rand(50, 1)*100
    X3 = np.random.rand(50, 1)*100
    
    def f(x):
        return 2 if x > 70 else 1 if x > 40 else 0
    
    y = X1 + X2 + X3
    Y = y > 150
    Y = Y + 0
    r = map(f, X1)
    X1 = list(r)
    
    r = map(f, X2)
    X2 = list(r)
    
    r = map(f, X3)
    X3 = list(r)
    x = np.c_[X1, X2, X3, Y]
    return x, ['courseA', 'courseB', 'courseC']


# 計算集合信息熵的函數
def calculate_info_entropy(dataset):
    n = len(dataset)
    # 我們用Counter統計一下Y的數量
    labels = Counter(dataset[:, -1])
    entropy = 0.0
    # 套用信息熵公式
    for k, v in labels.items():
        prob = v / n
        entropy -= prob * math.log(prob, 2)
    return entropy

# 實現拆分函數
def split_dataset(dataset, idx):
  	# idx是要拆分的特征下標
    splitData = defaultdict(list)
    for data in dataset:
      	# 這裡刪除瞭idx這個特征的取值，因為用不到瞭
        splitData[data[idx]].append(np.delete(data, idx))
    return list(splitData.values()), list(splitData.keys())

# 實現特征的選擇函數
def choose_feature_to_split(dataset):
    n = len(dataset[0])-1
    m = len(dataset)
    # 切分之前的信息熵
    entropy = calculate_info_entropy(dataset)
    bestGain = 0.0
    feature = -1
    for i in range(n):
      	# 根據特征i切分
        split_data, _ = split_dataset(dataset, i)
        new_entropy = 0.0
        # 計算切分後的信息熵
        for data in split_data:
            prob = len(data) / m
            new_entropy += prob * calculate_info_entropy(data)
        # 獲取信息增益
        gain = entropy - new_entropy
        if gain > bestGain:
            bestGain = gain
            feature = i
    return feature

# 決策樹創建函數
def create_decision_tree(dataset, feature_names):
    dataset = np.array(dataset)
    counter = Counter(dataset[:, -1])
    # 如果數據集值剩下瞭一類，直接返回
    if len(counter) == 1:
        return dataset[0, -1]
    
    # 如果所有特征都已經切分完瞭，也直接返回
    if len(dataset[0]) == 1:
        return counter.most_common(1)[0][0]
    
    # 尋找最佳切分的特征
    fidx = choose_feature_to_split(dataset)
    fname = feature_names[fidx]
    
    node = {fname: {}}
    feature_names.remove(fname)
    
    # 遞歸調用，對每一個切分出來的取值遞歸建樹
    split_data, vals = split_dataset(dataset, fidx)
    for data, val in zip(split_data, vals):
        node[fname][val] = create_decision_tree(data, feature_names[:])
    return node

# 決策樹節點預測函數
def classify(node, feature_names, data):
  	# 獲取當前節點判斷的特征
    key = list(node.keys())[0]
    node = node[key]
    idx = feature_names.index(key)
    
    # 根據特征進行遞歸
    pred = None
    for key in node:
      	# 找到瞭對應的分叉
        if data[idx] == key:
          	# 如果再往下依然還有子樹，那麼則遞歸，否則返回結果
            if isinstance(node[key], dict):
                pred = classify(node[key], feature_names, data)
            else:
                pred = node[key]
                
    # 如果沒有對應的分叉，則找到一個分叉返回
    if pred is None:
        for key in node:
            if not isinstance(node[key], dict):
                pred = node[key]
                break
    return pred