Python3 ID3决策树判断申请贷款是否成功的实现代码

1. 定义生成树

# -*- coding: utf-8 -*-
#生成树的函数

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

# 计算数据集的信息熵(Information Gain)增益函数(机器学习实战中信息熵叫香农熵)
def calcInfoEnt(dataSet):#本题中Label即好or坏瓜 #dataSet每一列是一个属性(列末是Label)
 numEntries = len(dataSet) #每一行是一个样本
 labelCounts = {} #给所有可能的分类创建字典labelCounts
 for featVec in dataSet: #按行循环:即rowVev取遍了数据集中的每一行
  currentLabel = featVec[-1] #故featVec[-1]取遍每行最后一个值即Label
  if currentLabel not in labelCounts.keys(): #如果当前的Label在字典中还没有
   labelCounts[currentLabel] = 0 #则先赋值0来创建这个词
  labelCounts[currentLabel] += 1 #计数, 统计每类Label数量(这行不受if限制)
 InfoEnt = 0.0
 for key in labelCounts: #遍历每类Label
  prob = float(labelCounts[key])/numEntries #各类Label熵累加
  InfoEnt -= prob * log(prob,2) #ID3用的信息熵增益公式
 return InfoEnt

### 对于离散特征: 取出该特征取值为value的所有样本
def splitDiscreteDataSet(dataSet, axis, value): #dataSet是当前结点(待划分)集合,axis指示划分所依据的属性,value该属性用于划分的取值
 retDataSet = []  #为return Data Set分配一个列表用来储存
 for featVec in dataSet:
  if featVec[axis] == value:
   reducedFeatVec = featVec[:axis]   #该特征之前的特征仍保留在样本dataSet中
   reducedFeatVec.extend(featVec[axis+1:]) #该特征之后的特征仍保留在样本dataSet中
   retDataSet.append(reducedFeatVec)  #把这个样本加到list中
 return retDataSet

### 对于连续特征: 返回特征取值大于value的所有样本(以value为阈值将集合分成两部分)
def splitContinuousDataSet(dataSet, axis, value):
 retDataSetG = []  #将储存取值大于value的样本
 retDataSetL = []  #将储存取值小于value的样本
 for featVec in dataSet:
  if featVec[axis] > value:
   reducedFeatVecG = featVec[:axis]
   reducedFeatVecG.extend(featVec[axis+1:])
   retDataSetG.append(reducedFeatVecG)
  else:
   reducedFeatVecL = featVec[:axis]
   reducedFeatVecL.extend(featVec[axis+1:])
   retDataSetL.append(reducedFeatVecL)
 return retDataSetG,retDataSetL  #返回两个集合, 是含2个元素的tuple形式

### 根据InfoGain选择当前最好的划分特征(以及对于连续变量还要选择以什么值划分)
def chooseBestFeatureToSplit(dataSet,labels):
 numFeatures = len(dataSet[0])-1
 baseEntropy = calcInfoEnt(dataSet)
 bestInfoGain = 0.0; bestFeature = -1
 bestSplitDict = {}
 for i in range(numFeatures):
  #遍历所有特征:下面这句是取每一行的第i个, 即得当前集合所有样本第i个feature的值
  featList = [example[i] for example in dataSet]
  #判断是否为离散特征
  if not (type(featList[0]).__name__=='float' or type(featList[0]).__name__=='int'):
# 对于离散特征:求若以该特征划分的熵增
   uniqueVals = set(featList)  #从列表中创建集合set(得列表唯一元素值)
   newEntropy = 0.0
   for value in uniqueVals:  #遍历该离散特征每个取值
    subDataSet = splitDiscreteDataSet(dataSet, i, value)#计算每个取值的信息熵
    prob = len(subDataSet)/float(len(dataSet))
    newEntropy += prob * calcInfoEnt(subDataSet)#各取值的熵累加
   infoGain = baseEntropy - newEntropy #得到以该特征划分的熵增
# 对于连续特征:求若以该特征划分的熵增(区别:n个数据则需添n-1个候选划分点, 并选最佳划分点)
  else: #产生n-1个候选划分点
   sortfeatList=sorted(featList)
   splitList=[]
   for j in range(len(sortfeatList)-1): #产生n-1个候选划分点
    splitList.append((sortfeatList[j] + sortfeatList[j+1])/2.0)
   bestSplitEntropy = 10000     #设定一个很大的熵值(之后用)
   #遍历n-1个候选划分点: 求选第j个候选划分点划分时的熵增, 并选出最佳划分点
   for j in range(len(splitList)):
    value = splitList[j]
    newEntropy = 0.0
    DataSet = splitContinuousDataSet(dataSet, i, value)
    subDataSetG = DataSet[0]
    subDataSetL = DataSet[1]
    probG = len(subDataSetG) / float(len(dataSet))
    newEntropy += probG * calcInfoEnt(subDataSetG)
    probL = len(subDataSetL) / float(len(dataSet))
    newEntropy += probL * calcInfoEnt(subDataSetL)
    if newEntropy < bestSplitEntropy:
     bestSplitEntropy = newEntropy
     bestSplit = j
   bestSplitDict[labels[i]] = splitList[bestSplit]#字典记录当前连续属性的最佳划分点
   infoGain = baseEntropy - bestSplitEntropy  #计算以该节点划分的熵增
# 在所有属性(包括连续和离散)中选择可以获得最大熵增的属性
  if infoGain > bestInfoGain:
   bestInfoGain = infoGain
   bestFeature = i
 #若当前节点的最佳划分特征为连续特征,则需根据“是否小于等于其最佳划分点”进行二值化处理
 #即将该特征改为“是否小于等于bestSplitValue”, 例如将“密度”变为“密度<=0.3815”
 #注意:以下这段直接操作了原dataSet数据, 之前的那些float型的值相应变为0和1
 #【为何这样做?】在函数createTree()末尾将看到解释
 if type(dataSet[0][bestFeature]).__name__=='float' or type(dataSet[0][bestFeature]).__name__=='int':
  bestSplitValue = bestSplitDict[labels[bestFeature]]
  labels[bestFeature] = labels[bestFeature] + '<=' + str(bestSplitValue)
  for i in range(shape(dataSet)[0]):
   if dataSet[i][bestFeature] <= bestSplitValue:
    dataSet[i][bestFeature] = 1
   else:
    dataSet[i][bestFeature] = 0
 return bestFeature  

# 若特征已经划分完,节点下的样本还没有统一取值,则需要进行投票:计算每类Label个数, 取max者
def majorityCnt(classList):
 classCount = {}  #将创建键值为Label类型的字典
 for vote in classList:
  if vote not in classCount.keys():
   classCount[vote] = 0  #第一次出现的Label加入字典
  classCount[vote] += 1  #计数
 return max(classCount)

2. 递归产生决策树

# 主程序:递归产生决策树
 # dataSet:当前用于构建树的数据集, 最开始就是data_full,然后随着划分的进行越来越小。这是因为进行到到树分叉点上了. 第一次划分之前17个瓜的数据在根节点,然后选择第一个bestFeat是纹理. 纹理的取值有清晰、模糊、稍糊三种;将瓜分成了清晰(9个),稍糊(5个),模糊(3个),这时应该将划分的类别减少1以便于下次划分。
 # labels:当前数据集中有的用于划分的类别(这是因为有些Label当前数据集没了, 比如假如到某个点上西瓜都是浅白没有深绿了)
 # data_full:全部的数据
 # label_full:全部的类别 

numLine = numColumn = 2 #这句是因为之后要用global numLine……至于为什么我一定要用global

# 我也不完全理解。如果我只定义local变量总报错,我只好在那里的if里用global变量了。求解。

def createTree(dataSet,labels,data_full,labels_full):
 classList = [example[-1] for example in dataSet]
 #递归停止条件1:当前节点所有样本属于同一类;(注:count()方法统计某元素在列表中出现的次数)
 if classList.count(classList[0]) == len(classList):
  return classList[0]

#递归停止条件2:当前节点上样本集合为空集(即特征的某个取值上已经没有样本了):
 global numLine,numColumn
 (numLine,numColumn) = shape(dataSet)
 if float(numLine) == 0:
  return 'empty'

#递归停止条件3:所有可用于划分的特征均使用过了,则调用majorityCnt()投票定Label;
 if float(numColumn) == 1:
  return majorityCnt(classList) 

#不停止时继续划分:
 bestFeat = chooseBestFeatureToSplit(dataSet,labels)#调用函数找出当前最佳划分特征是第几个
 bestFeatLabel = labels[bestFeat]  #当前最佳划分特征
 myTree = {bestFeatLabel:{}}
 featValues = [example[bestFeat] for example in dataSet]
 uniqueVals = set(featValues)
 if type(dataSet[0][bestFeat]).__name__=='str':
  currentlabel = labels_full.index(labels[bestFeat])
  featValuesFull = [example[currentlabel] for example in data_full]
  uniqueValsFull = set(featValuesFull)
 del(labels[bestFeat]) #划分完后, 即当前特征已经使用过了, 故将其从“待划分特征集”中删去

 #【递归调用】针对当前用于划分的特征(beatFeat)的每个取值,划分出一个子树。
 for value in uniqueVals: #遍历该特征【现存的】取值
  subLabels = labels[:]
  if type(dataSet[0][bestFeat]).__name__=='str':
   uniqueValsFull.remove(value)  #划分后删去(从uniqueValsFull中删!)
  myTree[bestFeatLabel][value] = createTree(splitDiscreteDataSet(dataSet,bestFeat,value),subLabels,data_full,labels_full)#用splitDiscreteDataSet()
 #是由于, 所有的连续特征在划分后都被我们定义的chooseBestFeatureToSplit()处理成离散取值了。
 if type(dataSet[0][bestFeat]).__name__=='str': #若该特征离散【更详见后注】
  for value in uniqueValsFull:#则可能有些取值已经不在【现存的】取值中了
 #这就是上面为何从“uniqueValsFull”中删去
 #因为那些现有数据集中没取到的该特征的值,保留在了其中
   myTree[bestFeatLabel][value] = majorityCnt(classList) 

 return myTree 

3. 调用生成树

#生成树调用的语句
df = pd.read_excel(r'E:\BaiduNetdiskDownload\spss\数据\实验data\银行贷款.xlsx')
data = df.values[:,1:].tolist()
data_full = data[:]
labels = df.columns.values[1:-1].tolist()
labels_full = labels[:]
myTree = createTree(data,labels,data_full,labels_full) 

查看数据

data

labels

4. 绘制决策树

#绘决策树的函数
import matplotlib.pyplot as plt
decisionNode = dict(boxstyle = "sawtooth",fc = "0.8") #定义分支点的样式
leafNode = dict(boxstyle = "round4",fc = "0.8") #定义叶节点的样式
arrow_args = dict(arrowstyle = "<-") #定义箭头标识样式

# 计算树的叶子节点数量
def getNumLeafs(myTree):
 numLeafs = 0
 firstStr = list(myTree.keys())[0]
 secondDict = myTree[firstStr]
 for key in secondDict.keys():
  if type(secondDict[key]).__name__=='dict':
   numLeafs += getNumLeafs(secondDict[key])
  else: numLeafs += 1
 return numLeafs

# 计算树的最大深度
def getTreeDepth(myTree):
 maxDepth = 0
 firstStr = list(myTree.keys())[0]
 secondDict = myTree[firstStr]
 for key in secondDict.keys():
  if type(secondDict[key]).__name__=='dict':
   thisDepth = 1 + getTreeDepth(secondDict[key])
  else: thisDepth = 1
  if thisDepth > maxDepth:
   maxDepth = thisDepth
 return maxDepth 

# 画出节点
def plotNode(nodeTxt,centerPt,parentPt,nodeType):
 createPlot.ax1.annotate(nodeTxt,xy = parentPt,xycoords = 'axes fraction',xytext = centerPt,textcoords = 'axes fraction',va = "center", ha = "center",bbox = nodeType,arrowprops = arrow_args) 

# 标箭头上的文字
def plotMidText(cntrPt,parentPt,txtString):
 lens = len(txtString)
 xMid = (parentPt[0] + cntrPt[0]) / 2.0 - lens*0.002
 yMid = (parentPt[1] + cntrPt[1]) / 2.0
 createPlot.ax1.text(xMid,yMid,txtString) 

def plotTree(myTree,parentPt,nodeTxt):
 numLeafs = getNumLeafs(myTree)
 depth = getTreeDepth(myTree)
 firstStr = list(myTree.keys())[0]
 cntrPt = (plotTree.x0ff + (1.0 + float(numLeafs))/2.0/plotTree.totalW,plotTree.y0ff)
 plotMidText(cntrPt,parentPt,nodeTxt)
 plotNode(firstStr,cntrPt,parentPt,decisionNode)
 secondDict = myTree[firstStr]
 plotTree.y0ff = plotTree.y0ff - 1.0/plotTree.totalD
 for key in secondDict.keys():
  if type(secondDict[key]).__name__=='dict':
   plotTree(secondDict[key],cntrPt,str(key))
  else:
   plotTree.x0ff = plotTree.x0ff + 1.0/plotTree.totalW
   plotNode(secondDict[key],(plotTree.x0ff,plotTree.y0ff),cntrPt,leafNode)
   plotMidText((plotTree.x0ff,plotTree.y0ff),cntrPt,str(key))
 plotTree.y0ff = plotTree.y0ff + 1.0/plotTree.totalD 

def createPlot(inTree):
 fig = plt.figure(1,facecolor = 'white')
 fig.clf()
 axprops = dict(xticks = [],yticks = [])
 createPlot.ax1 = plt.subplot(111,frameon = False,**axprops)
 plotTree.totalW = float(getNumLeafs(inTree))
 plotTree.totalD = float(getTreeDepth(inTree))
 plotTree.x0ff = -0.5/plotTree.totalW
 plotTree.y0ff = 1.0
 plotTree(inTree,(0.5,1.0),'')
 plt.show()

5. 调用函数

#命令绘决策树的图
createPlot(myTree)

myTree

总结

到此这篇关于Python3 ID3决策树判断申请贷款是否成功的实现代码的文章就介绍到这了,更多相关python ID3 决策树判断内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Python实现决策树并且使用Graphvize可视化的例子

    一.什么是决策树(decision tree)--机器学习中的一个重要的分类算法 决策树是一个类似于数据流程图的树结构:其中,每个内部节点表示一个属性上的测试,每个分支代表一个属性输出,而每个树叶结点代表类或者类的分布,树的最顶层是根结点 根据天气情况决定出游与否的案例 二.决策树算法构建 2.1决策树的核心思路 特征选择:从训练数据的特征中选择一个特征作为当前节点的分裂标准(特征选择的标准不同产生了不同的特征决策树算法). 决策树生成:根据所选特征评估标准,从上至下递归地生成子节点,直到数据集

  • 基于ID3决策树算法的实现(Python版)

    实例如下: # -*- coding:utf-8 -*- from numpy import * import numpy as np import pandas as pd from math import log import operator #计算数据集的香农熵 def calcShannonEnt(dataSet): numEntries=len(dataSet) labelCounts={} #给所有可能分类创建字典 for featVec in dataSet: currentLa

  • Python决策树之基于信息增益的特征选择示例

    本文实例讲述了Python决策树之基于信息增益的特征选择.分享给大家供大家参考,具体如下: 基于信息增益的特征选取是一种广泛使用在决策树(decision tree)分类算法中用到的特征选取.该特征选择的方法是通过计算每个特征值划分数据集获得信息增益,通过比较信息增益的大小选取合适的特征值. 一.定义 1.1 熵 信息的期望值,可理解为数据集的无序度,熵的值越大,表示数据越无序,公式如下: 其中H表示该数据集的熵值, pi表示类别i的概率, 若所有数据集只有一个类别,那么pi=1,H=0.因此H

  • python使用sklearn实现决策树的方法示例

    1. 基本环境 安装 anaconda 环境, 由于国内登陆不了他的官网 https://www.continuum.io/downloads, 不过可以使用国内的镜像站点: https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/ 添加绘图工具 Graphviz http://www.graphviz.org/Download_windows.php 安装后, 将bin 目录内容添加到环境变量path 即可 参考blog : https://

  • python实现C4.5决策树算法

    C4.5算法使用信息增益率来代替ID3的信息增益进行特征的选择,克服了信息增益选择特征时偏向于特征值个数较多的不足.信息增益率的定义如下: # -*- coding: utf-8 -*- from numpy import * import math import copy import cPickle as pickle class C45DTree(object): def __init__(self): # 构造方法 self.tree = {} # 生成树 self.dataSet =

  • 基于Python实现的ID3决策树功能示例

    本文实例讲述了基于Python实现的ID3决策树功能.分享给大家供大家参考,具体如下: ID3算法是决策树的一种,它是基于奥卡姆剃刀原理的,即用尽量用较少的东西做更多的事.ID3算法,即Iterative Dichotomiser 3,迭代二叉树3代,是Ross Quinlan发明的一种决策树算法,这个算法的基础就是上面提到的奥卡姆剃刀原理,越是小型的决策树越优于大的决策树,尽管如此,也不总是生成最小的树型结构,而是一个启发式算法. 如下示例是一个判断海洋生物数据是否是鱼类而构建的基于ID3思想

  • python实现决策树C4.5算法详解(在ID3基础上改进)

    一.概论 C4.5主要是在ID3的基础上改进,ID3选择(属性)树节点是选择信息增益值最大的属性作为节点.而C4.5引入了新概念"信息增益率",C4.5是选择信息增益率最大的属性作为树节点. 二.信息增益 以上公式是求信息增益率(ID3的知识点) 三.信息增益率 信息增益率是在求出信息增益值在除以. 例如下面公式为求属性为"outlook"的值: 四.C4.5的完整代码 from numpy import * from scipy import * from mat

  • python实现决策树、随机森林的简单原理

    本文申明:此文为学习记录过程,中间多处引用大师讲义和内容. 一.概念 决策树(Decision Tree)是一种简单但是广泛使用的分类器.通过训练数据构建决策树,可以高效的对未知的数据进行分类.决策数有两大优点:1)决策树模型可以读性好,具有描述性,有助于人工分析:2)效率高,决策树只需要一次构建,反复使用,每一次预测的最大计算次数不超过决策树的深度. 看了一遍概念后,我们先从一个简单的案例开始,如下图我们样本: 对于上面的样本数据,根据不同特征值我们最后是选择是否约会,我们先自定义的一个决策树

  • python实现决策树ID3算法的示例代码

    在周志华的西瓜书和李航的统计机器学习中对决策树ID3算法都有很详细的解释,如何实现呢?核心点有如下几个步骤 step1:计算香农熵 from math import log import operator # 计算香农熵 def calculate_entropy(data): label_counts = {} for feature_data in data: laber = feature_data[-1] # 最后一行是laber if laber not in label_counts

  • Python3 ID3决策树判断申请贷款是否成功的实现代码

    1. 定义生成树 # -*- coding: utf-8 -*- #生成树的函数 from numpy import * import numpy as np import pandas as pd from math import log import operator # 计算数据集的信息熵(Information Gain)增益函数(机器学习实战中信息熵叫香农熵) def calcInfoEnt(dataSet):#本题中Label即好or坏瓜 #dataSet每一列是一个属性(列末是La

  • python3射线法判断点是否在多边形内

    本文实例为大家分享了python3射线法判断点是否在多边形内的具体代码,供大家参考,具体内容如下 #!/usr/bin/python3.4 # -*- coding:utf-8 -*- def isPointinPolygon(point, rangelist): #[[0,0],[1,1],[0,1],[0,0]] [1,0.8] # 判断是否在外包矩形内,如果不在,直接返回false lnglist = [] latlist = [] for i in range(len(rangelist

  • Python3实现的判断环形链表算法示例

    本文实例讲述了Python3实现的判断环形链表算法.分享给大家供大家参考,具体如下: 给定一个链表,判断链表中是否有环. 方案一:快慢指针遍历,若出现相等的情况,说明有环 # Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def hasCycle(self,

  • Python3实现的判断回文链表算法示例

    本文实例讲述了Python3实现的判断回文链表算法.分享给大家供大家参考,具体如下: 问题: 请判断一个链表是否为回文链表. 方案一:指针法 class Solution: def isPalindrome(self, head): """ 判断一个链表是否是回文的,很自然的想法就是两个指针,一个指针从前往后走,一个指针从后往前走,判断元素值是否相同,这里要分几个步骤来进行求解: 1.找到链表长度的一半,用追赶法,一个指针一次走两步,一个指针一次走一步 2.将后一半数组转置

  • Python 判断图像是否读取成功的方法

    大批量处理数据时,若因个别图像错误导致代码中断,从头再来比较浪费时间 对未成功读入的图像跳过(读图 import cv2) for i in range(1,1000): image = cv2.imdecode(np.fromfile('xxx.jpg', dtype=np.uint8), -1) try: image.shape except: print('fail to read xxx.jpg') continue ...... 若该图像可能不存在,即没有该图像的文件名,也可用try判

  • 用js判断是否为360浏览器的实现代码

    以下代码在360安全浏览器5 和 6 版本中 可用 <script> var check360browser={ //如果是360 浏览器的话 "ok":function (){ //这里是判断360成功之后的代码 alert('js -> 360'); }, "try360SE":function (callback) { var ret = false, img = new Image(); img.src = 'res://360se.exe

  • C# 循环判断会进来几次的实现代码

    最近有小伙伴告诉我,在循环的判断条件只会计算一次,本金鱼不相信,于是就做了测试,本文记录我做的测试. 先来写一个简单的代码, 就一个循环,循环的判断是从一个函数获取值 class Program { static void Main(string[] args) { var meepeMorcear = new MeepeMorcear(); meepeMorcear.BirmeruLerrayjairbay(); } } class MeepeMorcear { public void Bir

  • Python判断三段线能否构成三角形的代码

    我就废话不多说了,还是直接看代码吧! #!/usr/bin/env python3 #coding = utf-8 def is_triangle(a=0, b=0, c=0): #abc 三条边长 A = [a,b,c] A.sort() #升序排序 if A[2] < A[1] +A[0]: print("{} is triangle".format(A)) else: print("不构成三角") def triangle(f): a = float(i

随机推荐