第三章 决策树-隐形眼镜

from math import log
import operator
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import random
#导入相应的包
from sklearn import tree
from sklearn.tree import DecisionTreeClassifier
# import graphviz



#导入数据集
lenses=pd.read_table('../MLinAction_source/lensens.txt',header=None)
lenses.columns=['age','prescript','astigmatic','tearRate','class']

print(lenses)

def calEnt(dataSet):
    n = dataSet.shape[0] #数据集总行数
    iset = dataSet.iloc[:,-1].value_counts() #标签的所有类别
    p = iset/n #每一类标签所占比
    ent = (-p*np.log2(p)).sum() #计算信息熵
    return ent

#选择最优的列进行切分
def bestSplit(dataSet):
    baseEnt = calEnt(dataSet) #计算原始熵
    bestGain = 0 #初始化信息增益
    axis = -1 #初始化最佳切分列，标签列
    for i in range(dataSet.shape[1]-1): #对特征的每一列进行循环
        levels= dataSet.iloc[:,i].value_counts().index #提取出当前列的所有取值
        ents = 0 #初始化子节点的信息熵
        for j in levels: #对当前列的每一个取值进行循环
            childSet = dataSet[dataSet.iloc[:,i]==j] #某一个子节点的dataframe
            ent = calEnt(childSet) #计算某一个子节点的信息熵
            ents += (childSet.shape[0]/dataSet.shape[0])*ent #计算当前列的信息熵
            #print(f'第{i}列的信息熵为{ents}')
        infoGain = baseEnt-ents #计算当前列的信息增益
        #print(f'第{i}列的信息增益为{infoGain}')
        if (infoGain > bestGain):
            bestGain = infoGain #选择最大信息增益
            axis = i #最大信息增益所在列的索引
    return axis

def mySplit(dataSet,axis,value):
    col = dataSet.columns[axis]
    redataSet = dataSet.loc[dataSet[col]==value,:].drop(col,axis=1)
    return redataSet


def createTree(dataSet):
    featlist=list(dataSet.columns) #提取出数据集所有的列
    classlist=dataSet.iloc[:,-1].value_counts() #获取最后一列类标签
    #判断最多标签数目是否等于数据集行数，或者数据集是否只有一列
    if classlist[0]==dataSet.shape[0] or dataSet.shape[1] ==1:
        return classlist.index[0] #如果是，返回类标签
    axis=bestSplit(dataSet) #确定出当前最佳切分列的索引
    bestfeat=featlist[axis] #获取该索引对应的特征
    myTree={bestfeat:{}} #采用字典嵌套的方式存储树信息
    del featlist[axis] #删除当前特征
    valuelist=set(dataSet.iloc[:,axis])    #提取最佳切分列所有属性值
    for value in valuelist: #对每一个属性值递归建树
        myTree[bestfeat][value]=createTree(mySplit(dataSet,axis,value))
    return myTree

def classify(inputTree,labels, testVec):
    firstStr = next(iter(inputTree)) #获取决策树第一个节点
    secondDict = inputTree[firstStr] #下一个字典
    featIndex = labels.index(firstStr) #第一个节点所在列的索引
    for key in secondDict.keys():
        if testVec[featIndex] == key:
            if type(secondDict[key]) == dict :
                classLabel = classify(secondDict[key], labels, testVec)
            else:
                classLabel = secondDict[key]
    return classLabel

def acc_classify(train,test):
    inputTree = createTree(train) #根据测试集生成一棵树
    labels = list(train.columns) #数据集所有的列名称
    result = []
    for i in range(test.shape[0]): #对测试集中每一条数据进行循环
        testVec = test.iloc[i,:-1] #测试集中的一个实例
        classLabel = classify(inputTree,labels,testVec) #预测该实例的分类
        result.append(classLabel) #将分类结果追加到result列表中
    test['predict']=result #将预测结果追加到测试集最后一列
    acc = (test.iloc[:,-1]==test.iloc[:,-2]).mean() #计算准确率
    print(f'模型预测准确率为{acc}')
    return test

#划分训练集和测试集
'''
参数说明:
dataSet:输入的数据集
rate:训练集所占比例
train,test:切分好的训练集和测试集
'''
def randSplit(dataSet,rate):
    l=list(dataSet.index) #提取出索引
    random.shuffle(l) #随机打乱索引 索引后面的值并没有改变
    dataSet.index=l #将打乱后的索引重新赋值给原数据集
    n=dataSet.shape[0] #总行数
    m=int(n*rate) #训练集的数量
    train=dataSet.loc[range(m),:] #提取前m个记录作为训练集
    test=dataSet.loc[range(m,n),:] #剩下的作为测试集
    dataSet.index=range(dataSet.shape[0]) #更新数据集的索引 把dataset前面的索引更新为从0开始 前面已经打乱了索引值
    test.index=range(test.shape[0]) #更新测试集的索引  把test前面的索引更新为从0开始
    return  train,test

dataSet=lenses
train1,test1=randSplit(lenses,0.8)

print("训练集:\n",train1)
print("测试集:\n",test1)

lensesTree=createTree(train1)
print(lensesTree)

print(acc_classify(train1,test1))