《机器学习入门与实践-基于scikit-learn和Keras》课后习题答案-第五章

本文链接：https://blog.csdn.net/weixin_45608016/article/details/136000643

1. D

2. C

3. B

4. 信息熵是训练数据集中的类别与某一属性之间的互信息，表示两事件之间信息的重复部分。在决策树算法中，信息熵用于确定分类标准。

5. 一颗决策树的生成过程主要分以下3个部分：

（1）特征选择；（2）决策树生成；（3）剪枝。

6. 决策树算法被广泛应用于商业、农业、气象学、交通、军事、教育等众多领域，如客户群体的分类、农作物的分类、交通数据分析等。

7. Gain(D,饮食习惯)=0.208

Gain(D,胎生动物)=0.689

Gain(D,水生动物)=0.045

Gain(D,会飞)=0.045

比较后可知，胎生动物的信息增益量最大，选择此属性对决策树的根节点进行划分。

计算此题数据的python程序代码如下：

import math
import numpy as np
import pandas as pd

data=pd.read_csv(".\\data\\哺乳动物训练样本集.csv")
N=len(data.values)
title=list(data.head())
classifyProp="哺乳动物"
def prepareData(data): #预处理数据集
    pData={}
    for item in data.head():
        if item!=classifyProp:
           r=list(zip(data[item],data[classifyProp]))
           pData[item]=r
    return pData

def getRootEntropy(): #获取分类属性信息熵
    values=set(data[classifyProp])
    entrophy=0
    for value in values:
        br=data[classifyProp]
        counts=list(br).count(value)
        sg=counts/N
        entrophy+=sg*math.log2(sg)
    return -entrophy

def getSubInformationGain(a):#子属性的信息增益
    rootEntrophy=getRootEntropy()
    aData=list(data[a])
    aValues=set(aData)
    rData=list(data[classifyProp])
    subData=list(zip(aData,rData))
    ig=0
    for item in aValues:
       tvc=aData.count(item)#子集的数量
       iep=0.0
       for result in set(rData):
           trv= [tv[1] for tv in subData if tv[0]==item].count(result)
           sp=trv/tvc
           if sp!=0:
              iep+=sp*math.log2(sp)
           else:
              iep=iep
           #print(trv,sp)
       ig+=-iep*tvc/N
       #print(item,tvc)
    igg=rootEntrophy-ig#子属性增益
    #print(a,"信息增益",igg)
    return igg

result=[]
for item in title[1:len(title)-1]:
   result.append([item,round(getSubInformationGain(item),3)])
rootP=np.array(result)
bv=max(x[1] for x in rootP)
bP=[x[0] for x in rootP if x[1]==bv][0]
print(result)
print(bP)

8. 用scikit-learn中的决策树算法对葡萄酒数据集分类的python程序代码如下：

from sklearn import tree                                                             
from sklearn.datasets import load_wine                                               
import numpy as np                                                                   
import matplotlib.pyplot as pt                                                       
                                                                                     
wine=load_wine()                                                                     
X=wine.data                                                                          
y=wine.target                                                                        
columns=len(X[:1,:][0])                                                              
cValue=len(set(y))                                                                   
                                                                                     
#建模                                                                                  
model=tree.DecisionTreeClassifier(max_depth=4)                                       
                                                                                     
#训练数据                                                                                
i=columns-1                                                                          
result=[]                                                                            
while i>=0:                                                                          
    j=0                                                                              
    while j<i:                                                                       
        X=wine.data[:,[i,j]]                                                         
        bmodel=model.fit(X,y)                                                        
        #预测                                                                          
        x_min,x_max=X[:,0].min()-1,X[:,0].max()+1                                    
        y_min,y_max=X[:,1].min()-1,X[:,1].max()+1                                    
        xx,yy=np.meshgrid(np.arange(x_min,x_max,0.1),np.arange(y_min,y_max,0.1))     
        Z=bmodel.predict(np.c_[xx.ravel(),yy.ravel()])                               
        Z=Z.reshape(xx.shape)                                                        
        result.append([[i,j],[xx,yy,Z],bmodel.score(X,y)])                           
        j=j+1                                                                        
    i-=1                                                                             
                                                                                     
#寻找两个特征的最优组合                                                                         
rs=result                                                                            
bestC=max([x[2] for x in rs ])                                                       
a=[[x[0],x[1]] for x in rs if x[2]==bestC]                                           
print("两个特征的最优组合:",a[0][0])                                                          
print("由最优特征组合训练出的模型的准确率：",bestC)                                                    
xx,yy,Z=a[0][1][0],a[0][1][1],a[0][1][2]                                             
C=pt.contourf(xx,yy,Z,alpha=0.75,cmap=pt.cm.cool)                                    
pt.scatter(X[:,0],X[:,1],c=y,alpha=0.8)                                              
pt.show()

控制台输出的程序运行结果：