决策树python看图_[python] 决策树的python实现方法

这篇文章主要介绍了决策树的python实现方法,详细分析了决策树的优缺点及算法思想并以完整实例形式讲述了Python实现决策树的方法,具有一定的借鉴价值,需要的朋友可以参考下

本文实例讲述了决策树的python实现方法。分享给大家供大家参考。具体实现方法如下:

决策树算法优缺点:

优点:计算复杂度不高,输出结果易于理解,对中间值缺失不敏感,可以处理不相关的特征数据

缺点:可能会产生过度匹配的问题

适用数据类型:数值型和标称型

算法思想:

1.决策树构造的整体思想:

决策树说白了就好像是if-else结构一样,它的结果就是你要生成这个一个可以从根开始不断判断选择到叶子节点的树,但是呢这里的if-else必然不会是让我们认为去设置的,我们要做的是提供一种方法,计算机可以根据这种方法得到我们所需要的决策树。这个方法的重点就在于如何从这么多的特征中选择出有价值的,并且按照最好的顺序由根到叶选择。完成了这个我们也就可以递归构造一个决策树了

2.信息增益

划分数据集的最大原则是将无序的数据变得更加有序。既然这又牵涉到信息的有序无序问题,自然要想到想弄的信息熵了。这里我们计算用的也是信息熵(另一种方法是基尼不纯度)。公式如下:

数据需要满足的要求:

① 数据必须是由列表元素组成的列表,而且所有的列白哦元素都要具有相同的数据长度

② 数据的最后一列或者每个实例的最后一个元素应是当前实例的类别标签

函数:

calcShannonEnt(dataSet)

计算数据集的香农熵,分两步,第一步计算频率,第二部根据公式计算香农熵

splitDataSet(dataSet, aixs, value)

划分数据集,将满足X[aixs]==value的值都划分到一起,返回一个划分好的集合(不包括用来划分的aixs属性,因为不需要)

chooseBestFeature(dataSet)

选择最好的属性进行划分,思路很简单就是对每个属性都划分下,看哪个好。这里使用到了一个set来选取列表中唯一的元素,这是一中很快的方法

majorityCnt(classList)

因为我们递归构建决策树是根据属性的消耗进行计算的,所以可能会存在最后属性用完了,但是分类还是没有算完,这时候就会采用多数表决的方式计算节点分类

createTree(dataSet, labels)

基于递归构建决策树。这里的label更多是对于分类特征的名字,为了更好看和后面的理解。

复制代码 代码如下:

#coding=utf-8

import operator

from math import log

import time

def createDataSet():

dataSet=[[1,1,'yes'],

[1,1,'yes'],

[1,0,'no'],

[0,1,'no'],

[0,1,'no']]

labels = ['no surfaceing','flippers']

return dataSet, labels

#计算香农熵

def calcShannonEnt(dataSet):

numEntries = len(dataSet)

labelCounts = {}

for feaVec in dataSet:

currentLabel = feaVec[-1]

if currentLabel not in labelCounts:

labelCounts[currentLabel] = 0

labelCounts[currentLabel] += 1

shannonEnt = 0.0

for key in labelCounts:

prob = float(labelCounts[key])/numEntries

shannonEnt -= prob * log(prob, 2)

return shannonEnt

def splitDataSet(dataSet, axis, value):

retDataSet = []

for featVec in dataSet:

if featVec[axis] == value:

reducedFeatVec = featVec[:axis]

reducedFeatVec.extend(featVec[axis+1:])

retDataSet.append(reducedFeatVec)

return retDataSet

def chooseBestFeatureToSplit(dataSet):

numFeatures = len(dataSet[0]) - 1#因为数据集的最后一项是标签

baseEntropy = calcShannonEnt(dataSet)

bestInfoGain = 0.0

bestFeature = -1

for i in range(numFeatures):

featList = [example[i] for example in dataSet]

uniqueVals = set(featList)

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

if infoGain > bestInfoGain:

bestInfoGain = infoGain

bestFeature = i

return bestFeature

#因为我们递归构建决策树是根据属性的消耗进行计算的,所以可能会存在最后属性用完了,但是分类

#还是没有算完,这时候就会采用多数表决的方式计算节点分类

def majorityCnt(classList):

classCount = {}

for vote in classList:

if vote not in classCount.keys():

classCount[vote] = 0

classCount[vote] += 1

return max(classCount)

def createTree(dataSet, labels):

classList = [example[-1] for example in dataSet]

if classList.count(classList[0]) ==len(classList):#类别相同则停止划分

return classList[0]

if len(dataSet[0]) == 1:#所有特征已经用完

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[:]#为了不改变原始列表的内容复制了一下

myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet,

bestFeat, value),subLabels)

return myTree

def main():

data,label = createDataSet()

t1 = time.clock()

myTree = createTree(data,label)

t2 = time.clock()

print myTree

print 'execute for ',t2-t1

if __name__=='__main__':

main()

希望本文所述对大家的Python程序设计有所帮助。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,下面是关于决策树的CART算法的Python实现示例。 首先,我们需要导入相关的库: ```python 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.metrics import accuracy_score ``` 接下来,我们需要加载数据集: ```python iris = load_iris() X = pd.DataFrame(iris.data, columns=iris.feature_names) y = pd.DataFrame(iris.target, columns=['target']) ``` 然后,我们将数据集分成训练集和测试集: ```python X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) ``` 接下来,我们定义一个函数来计算基尼不纯度: ```python def gini_impurity(y): _, counts = np.unique(y, return_counts=True) probabilities = counts / len(y) return 1 - np.sum(probabilities ** 2) ``` 然后,我们定义一个函数来计算基尼不纯度的加权平均值: ```python def weighted_gini_impurity(groups): total_size = sum(len(group) for group in groups) gini = 0 for group in groups: size = len(group) if size == 0: continue score = gini_impurity(group['target']) gini += score * (size / total_size) return gini ``` 接下来,我们定义一个函数来拆分数据集: ```python def test_split(index, value, X, y): left_mask = X.iloc[:, index] < value right_mask = X.iloc[:, index] >= value left = {'X': X[left_mask], 'y': y[left_mask]} right = {'X': X[right_mask], 'y': y[right_mask]} return left, right ``` 然后,我们定义一个函数来选择最佳的数据集拆分: ```python def get_best_split(X, y): best_index, best_value, best_score, best_groups = None, None, float('inf'), None for index in range(X.shape[1]): for value in X.iloc[:, index]: groups = test_split(index, value, X, y) score = weighted_gini_impurity(list(groups.values())) if score < best_score: best_index, best_value, best_score, best_groups = index, value, score, groups return {'feature_index': best_index, 'feature_value': best_value, 'groups': best_groups} ``` 接下来,我们定义一个函数来创建一个叶节点: ```python def create_leaf_node(y): return y['target'].mode()[0] ``` 然后,我们定义一个函数来创建一个决策树: ```python def create_decision_tree(X, y, max_depth, min_size, depth): best_split = get_best_split(X, y) left, right = best_split['groups'].values() del(best_split['groups']) if not left or not right: return create_leaf_node(pd.concat([left, right], axis=0)) if depth >= max_depth: return create_leaf_node(y) if len(left) < min_size: left = create_leaf_node(left) else: left = create_decision_tree(left['X'], left['y'], max_depth, min_size, depth+1) if len(right) < min_size: right = create_leaf_node(right) else: right = create_decision_tree(right['X'], right['y'], max_depth, min_size, depth+1) return {'left': left, 'right': right, **best_split} ``` 最后,我们定义一个函数来进行预测: ```python def predict(node, row): if row[node['feature_index']] < node['feature_value']: if isinstance(node['left'], dict): return predict(node['left'], row) else: return node['left'] else: if isinstance(node['right'], dict): return predict(node['right'], row) else: return node['right'] ``` 现在我们已经定义了所有必要的函数,我们可以用以下代码来创建并测试我们的决策树模型: ```python tree = create_decision_tree(X_train, y_train, max_depth=5, min_size=10, depth=1) y_pred = np.array([predict(tree, row) for _, row in X_test.iterrows()]) print('Accuracy:', accuracy_score(y_test, y_pred)) ``` 这就是一个基于CART算法的决策树Python实现示例。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值