python中怎么模擬決策樹

本篇文章為大家展示了python中怎么模擬決策樹，內容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細介紹希望你能有所收獲。

1，程序模擬決策樹特征選擇的三個準則。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from collections import Counter
import math
from math import log
import pprint

# 課本例題數據
def createData():
    datasets = [
        ['青年', '否', '否', '一般', '否'],
        ['青年', '否', '否', '好', '否'],
        ['青年', '是', '否', '好', '是'],
        ['青年', '是', '是', '一般', '是'],
        ['青年', '否', '否', '一般', '否'],
        ['中年', '否', '否', '一般', '否'],
        ['中年', '否', '否', '好', '否'],
        ['中年', '是', '是', '好', '是'],
        ['中年', '否', '是', '非常好', '是'],
        ['中年', '否', '是', '非常好', '是'],
        ['老年', '否', '是', '非常好', '是'],
        ['老年', '否', '是', '好', '是'],
        ['老年', '是', '否', '好', '是'],
        ['老年', '是', '否', '非常好', '是'],
        ['老年', '否', '否', '一般', '否']
    ]
    labels = ['年齡', '有工作', '有自己的房子', '信貸情況', '類別']
    return datasets, labels


# 計算經驗熵
def calc_ent(datasets):
    data_length = len(datasets)
    label_count = {}  # 用于記錄不同類別的個數
    for i in range(data_length):
        label = datasets[i][-1]  # 記錄了當前一條數據的最后一維
        if label not in label_count:  # 如果第一次遇到新類別，先初始化
            label_count[label] = 0
        label_count[label] += 1  # 類別個數加一
    # 計算熵。每次取出的p為當前datasets集合的類別的個數
    ent = -sum( (p / data_length) * log(p / data_length, 2) for p in label_count.values() )
    return ent


# 計算條件經驗熵
def cond_ent(datasets, axis=0):  # axis是我們選擇的特征，也及時計算這個特征對集合的條件經驗熵。
    data_length = len(datasets)
    feature_sets = {}
    for i in range(data_length):
        feature = datasets[i][axis]
        if feature not in feature_sets:
            feature_sets[feature] = []
        feature_sets[feature].append(datasets[i])  # 我們按照特征將數據按照字典的格式存儲。
    # 計算條件經驗熵。 （Di/D）*H(Di)。這里每次取出的p為屬于范類別的所有數據。這里的類別是axis指定的特征的分類。
    cond_ent = sum((len(p)/data_length)*calc_ent(p) for p in feature_sets.values())
    return cond_ent


# 計算信息增益
def info_gain(ent, cond_ent):
    return ent - cond_ent


# 計算信息增益
def info_gain_train(datasets):
    count = len(datasets[0]) - 1
    ent = calc_ent(datasets)
    print("當前經驗熵：{:.3f}\n".format(ent))
    best_feature = []
    for c in range(count):
        print("第{}個特征的條件經驗熵為：{:.3f}".format(c+1, cond_ent(datasets, c)))
        c_info_gain = info_gain(ent, cond_ent(datasets, c))
        best_feature.append((c, c_info_gain))
        print("當前特征（{}）的信息增益為：{:.3f}".format(label[c], c_info_gain))
    best = max(best_feature, key=lambda c : c[-1])  # 這里返回的是信息增益最大的元組
    return best


dataset, label = createData()
trainData = pd.DataFrame(dataset, columns=label)
best_feature = info_gain_train(dataset)
print("\n第{}個特征（{}）的信息增益最大，為：{:.3f}".format(best_feature[0]+1, label[best_feature[0]+1], best_feature[1]))

結果

當前經驗熵：0.971

第1個特征的條件經驗熵為：0.888
當前特征（年齡）的信息增益為：0.083
第2個特征的條件經驗熵為：0.647
當前特征（有工作）的信息增益為：0.324
第3個特征的條件經驗熵為：0.551
當前特征（有自己的房子）的信息增益為：0.420
第4個特征的條件經驗熵為：0.608
當前特征（信貸情況）的信息增益為：0.363

第3個特征（信貸情況）的信息增益最大，為：0.420

2，程序實現ID3算法

import pandas as pd
import numpy as np
import math
from math import log


def create_data():
    datasets = [['青年', '否', '否', '一般', '否'],
               ['青年', '否', '否', '好', '否'],
               ['青年', '是', '否', '好', '是'],
               ['青年', '是', '是', '一般', '是'],
               ['青年', '否', '否', '一般', '否'],
               ['中年', '否', '否', '一般', '否'],
               ['中年', '否', '否', '好', '否'],
               ['中年', '是', '是', '好', '是'],
               ['中年', '否', '是', '非常好', '是'],
               ['中年', '否', '是', '非常好', '是'],
               ['老年', '否', '是', '非常好', '是'],
               ['老年', '否', '是', '好', '是'],
               ['老年', '是', '否', '好', '是'],
               ['老年', '是', '否', '非常好', '是'],
               ['老年', '否', '否', '一般', '否'],
               ]
    labels = [u'年齡', u'有工作', u'有自己的房子', u'信貸情況', u'類別']
    # 返回數據集和每個維度的名稱
    return datasets, labels


# 定義節點類 二叉樹
class Node:
    def __init__(self, root=True, label=None, feature_name=None, feature=None):
        self.root = root  # 標記當前節點是否為根節點
        self.label = label  # label記錄當前節點的值
        self.feature_name = feature_name  # 記錄當前特征名
        self.feature = feature  # 記錄當前特征名在特征列表中的序號
        self.tree = {}
        self.result = {
            'label:': self.label,
            'feature': self.feature,
            'tree': self.tree
        }

    def __repr__(self):  # 返回當前節點的信息
        return '{}'.format(self.result)

    def add_node(self, val, node):  # 添加點
        self.tree[val] = node

    def predict(self, features):  # 預測當前節點
        if self.root is True:
            return self.label
        return self.tree[features[self.feature]].predict(features)


class DTree:
    def __init__(self, epsilon=0.1):
        self.epsilon = epsilon  # 閾值，用于判斷當前信息增益是否符合大小。如果信息增益小于閾值，等同于忽略。
        self._tree = {}

    # 熵
    @staticmethod
    def calc_ent(datasets):
        data_length = len(datasets)
        label_count = {}
        for i in range(data_length):
            label = datasets[i][-1]
            if label not in label_count:
                label_count[label] = 0
            label_count[label] += 1
        ent = -sum([(p / data_length) * log(p / data_length, 2)
                    for p in label_count.values()])
        return ent

    # 經驗條件熵
    def cond_ent(self, datasets, axis=0):
        data_length = len(datasets)
        feature_sets = {}
        for i in range(data_length):
            feature = datasets[i][axis]
            if feature not in feature_sets:
                feature_sets[feature] = []
            feature_sets[feature].append(datasets[i])
        cond_ent = sum([(len(p) / data_length) * self.calc_ent(p)
                        for p in feature_sets.values()])
        return cond_ent

    # 信息增益
    @staticmethod
    def info_gain(ent, cond_ent):
        return ent - cond_ent

    def info_gain_train(self, datasets):  # 計算當前數據集中信息增益最大的特征。
        count = len(datasets[0]) - 1
        ent = self.calc_ent(datasets)
        best_feature = []
        for c in range(count):
            c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))
            best_feature.append((c, c_info_gain))
        # 比較大小
        best_ = max(best_feature, key=lambda x: x[-1])
        return best_

    def train(self, train_data):
        """
        input:數據集D(DataFrame格式)，特征集A，閾值eta
        output:決策樹T
        """
        _ = train_data.iloc[:, :-1]  # 除最后一列的所有數據
        y_train = train_data.iloc[:, -1]  # 僅包含最后一列
        features = train_data.columns[:-1]  # 除最后一個特征以外的特征

        # 下面是ID3算法四步。D為訓練數據集，A為特征集。
        # 1 若D中實例屬于同一類Ck，則T為單節點樹，并將類Ck作為結點的類標記，返回T
        if len(y_train.value_counts()) == 1:  # value_counts函數，對數據按照值進行排序，并且按照從大到小排序
            return Node(root=True, label=y_train.iloc[0])

        # 2 若A為空，則T為單節點樹，將D中實例樹最大的類Ck作為該節點的類標記，返回T
        if len(features) == 0:
            return Node(
                root=True,
                label=y_train.value_counts().sort_values(
                    ascending=False).index[0])
            # 沒有特征進行劃分了，所以對當前數據集所有類別進行了歸類，并計數，然后排序，
            # 選擇類別數最大的類別，估計為當前節點代表的類別

        # 3 計算最大信息增益
        # max_feature為信息增益最大特征名字的序號,
        # max_info_gain為最大信息增益
        # max_feature_name為最大信息增益特征名字
        max_feature, max_info_gain = self.info_gain_train(np.array(train_data))
        max_feature_name = features[max_feature]

        # 4 信息增益小于閾值，忽略，置T為單節點樹，并將D中是實例數最大的類Ck作為該節點的類標記，返回T
        if max_info_gain < self.epsilon:
            return Node(
                root=True,
                label=y_train.value_counts().sort_values(
                    ascending=False).index[0])

        # 5 構建最大信息增益點Ag的子集。
        # 按照Ag的每一個可能的取值ai，將數據集D分成一個Di，每個Di中實例數最大的類作為標記，構建子節點。
        # 由當前最大信息增益點及其子節點構成樹，并返回
        node_tree = Node(
            root=False, feature_name=max_feature_name, feature=max_feature)
        # 將train_data按照  當前最大信息增益特征不同值  劃分，index指value_counts后的類別部分
        feature_list = train_data[max_feature_name].value_counts().index
        for f in feature_list:
            # 去掉 最大信息增益這個特征
            sub_train_df = train_data.loc[train_data[max_feature_name] == f].drop([max_feature_name], axis=1)

            # 6 遞歸生成樹
            # 對去掉這個特征的數據繼續進行訓練
            sub_tree = self.train(sub_train_df)
            # 將當前節點加到遞歸上層父節點上。
            # 這個算法不是從根節點，一步一步加點生成樹，
            # 而是從根節點開始找出最大信息增益節點，這個點只是聲明了一下，并沒有建立聯系。然后遞歸向下，到達葉節點之后，
            # 將葉節點添加到上層遞歸的父節點，然后父節點在train另一個子節點，然后將子節點在加入到父節點。
            # 這時最初的根節點仍然是只有一個點，但是最下邊的某個子樹已經建立了父子關系，生成了樹
            node_tree.add_node(f, sub_tree)

        return node_tree

    def fit(self, train_data):
        self._tree = self.train(train_data)
        return self._tree

    def predict(self, X_test):
        return self._tree.predict(X_test)


datasets, labels = create_data()
data_df = pd.DataFrame(datasets, columns=labels)
dt = DTree()
tree = dt.fit(data_df)
print(tree)
print("下邊預測數據：[老年, 否, 否, 一般]，結果為：")
print(dt.predict(['老年', '否', '否', '一般']))

結果：

{'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}
下邊預測數據：[老年, 否, 否, 一般]，結果為：
否

3，sklearn模擬

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import export_graphviz
import graphviz


def create_data():
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['label'] = iris.target
    df.columns = [
        'sepal length', 'sepal width', 'petal length', 'petal width', 'label'
    ]
    data = np.array(df.iloc[:100, [0, 1, -1]])
    # print(data)
    return data[:, :2], data[:, -1]


X, y = create_data()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)


clf = DecisionTreeClassifier()
clf.fit(X_train, y_train,)
print(clf.score(X_test, y_test))

# 為了讓下邊的語句執行，首先要安裝graphviz，官網下載exe或者zip都行，這種方式要配置環境變量
# pycharm安裝失敗時，用命令行安裝pip install graphviz -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com。這種方式直接安裝在了Anaconda下就不用配置環境變量了
# 成功后，在命令行運行dot -v看一下是否成功安裝
# 成功后，現在命令行運行dot - c。執行完后，在運行程序即可。
tree_pic = export_graphviz(clf, out_file="mytree.pdf")  # 生成了畫樹的graphviz語句
with open('mytree.pdf') as f:
    dot_graph = f.read()  # 我們將畫樹的語句取出來
graph = graphviz.Source(dot_graph)  # 將這些語句存儲
graph.view()  # 畫出來

結果：

0.9666666666666667

最初生成的mytree.pdf文件：

通過dot畫出來的文件（自動命名成Source.gv.pdf）：

上述內容就是python中怎么模擬決策樹，你們學到知識或技能了嗎？如果還想學到更多技能或者豐富自己的知識儲備，歡迎關注億速云行業資訊頻道。