【人工智能】机器学习之使用Python生成ID3决策树及使用sklearn的决策树算法对葡萄酒数据集进行分类

简介: 决策树的思想:给定一个集合,其中的每个样本由若干属性表示,决策树通过贪心的策略不断挑选最优的属性。常见的决策树算法有ID3,C4.5,CART算法等。

❤❤❤ID3算法

✅✅决策树的思想:

给定一个集合,其中的每个样本由若干属性表示,决策树通过贪心的策略不断挑选最优的属性。
常见的决策树算法有ID3,C4.5,CART算法等。

💤💤💤ID3算法:

        baseEntropy = self.calcShannonEnt(dataset) # 基础熵
        num = len(dataset) # 样本总数
        
        #子集中的概率
        subDataSet = self.splitDataSet(dataset, i, val)
        prob = len(subDataSet) / float(num) 
        
        # 条件熵
        newEntropy += prob * self.calcShannonEnt(subDataSet)
        
        # 信息增益
        infoGain = baseEntropy - newEntropy

💯1.先写绘图树方法,函数。

import matplotlib.pyplot as plt

decisionNode = dict(boxstyle="sawtooth", fc="0.8")
leafNode = dict(boxstyle="round4", fc="0.8")
arrow_args = dict(arrowstyle="<-")

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 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 = getTreeDepth(secondDict[key]) + 1
        else:
            thisDepth = 1
        if thisDepth > maxDepth:
            maxDepth = thisDepth
    return maxDepth

def plotMidText(cntrPt, parentPt, txtString):
    xMid = (parentPt[0] - cntrPt[0]) / 2.0 + cntrPt[0]
    yMid = (parentPt[1] - cntrPt[1]) / 2.0 + cntrPt[1]
    createPlot.ax1.text(xMid, yMid, txtString)

def plotTree(myTree, parentPt, nodeTxt):
    numLeafs = getNumLeafs(myTree)
    depth = getTreeDepth(myTree)
    firstStr = list(myTree.keys())[0]
    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs)) / 2.0 / plotTree.totalw, plotTree.yOff)
    plotMidText(cntrPt, parentPt, nodeTxt)
    plotNode(firstStr, cntrPt, parentPt, decisionNode)
    secondDict = myTree[firstStr]
    plotTree.yOff = plotTree.yOff - 1.0 / plotTree.totalD
    for key in secondDict.keys():
        if type(secondDict[key]).__name__ == 'dict':
            plotTree(secondDict[key], cntrPt, str(key))
        else:
            plotTree.xOff = plotTree.xOff + 1.0 / plotTree.totalw
            plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
            plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))
    plotTree.yOff = plotTree.yOff + 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.xOff = -0.5 / plotTree.totalw
    plotTree.yOff = 1.0
    plotTree(inTree, (0.5, 1.0), '')
    plt.show()

💯2.ID3决策树类

class ID3Tree(object):
    def __init__(self):
        self.tree = {}  # ID3 Tree
        self.dataSet = []  # 数据集
        self.labels = []  # 标签集

    def getDataSet(self, dataset, labels):
        self.dataSet = dataset
        self.labels = labels

    def train(self):
        # labels = copy.deepcopy(self.labels)
        labels = self.labels[:]
        self.tree = self.buildTree(self.dataSet, labels)

    def buildTree(self, dataSet, labels):
        classList = [ds[-1] for ds in dataSet]  # 提取样本的类别
        if classList.count(classList[0]) == len(classList):  # 单一类别
            return classList[0]
        if len(dataSet[0]) == 1:  # 没有属性需要划分了
            return self.classify(classList)

        bestFeat = self.findBestSplit(dataSet)  # 选取最大增益的属性序号
        bestFeatLabel = labels[bestFeat]
        tree = {bestFeatLabel: {}}  # 构造一个新的树结点
        del (labels[bestFeat])  # 从总属性列表中去除最大增益属性

        featValues = [ds[bestFeat] for ds in dataSet]  # 抽取最大增益属性的取值列表
        uniqueFeatValues = set(featValues)  # 选取最大增益属性的数值类别

        for value in uniqueFeatValues:  # 对于每一个属性类别
            subLabels = labels[:]
            subDataSet = self.splitDataSet(dataSet, bestFeat, value)  # 分裂结点
            subTree = self.buildTree(subDataSet, subLabels)  # 递归构造子树
            tree[bestFeatLabel][value] = subTree
        return tree

    # 计算出现次数最多的类别标签
    def classify(self, classList):
        items = dict([(classList.count(i), i) for i in classList])
        return items[max(items.keys())]

    # 计算最优特征
    def findBestSplit(self, dataset):
        numFeatures = len(dataset[0]) - 1
        baseEntropy = self.calcShannonEnt(dataset) # 基础熵
        num = len(dataset) # 样本总数
        bestInfoGain = 0.0
        bestFeat = -1  # 初始化最优特征向量轴
        # 遍历数据集各列,寻找最优特征轴
        for i in range(numFeatures):
            featValues = [ds[i] for ds in dataset]
            uniqueFeatValues = set(featValues)
            newEntropy = 0.0
            # 按列和唯一值,计算信息熵
            for val in uniqueFeatValues:
                subDataSet = self.splitDataSet(dataset, i, val)
                prob = len(subDataSet) / float(num) # 子集中的概率
                newEntropy += prob * self.calcShannonEnt(subDataSet)
            infoGain = baseEntropy - newEntropy # 信息增益
            if infoGain > bestInfoGain: # 挑选最大值
                bestInfoGain = baseEntropy - newEntropy
                bestFeat = i
        return bestFeat

    # 从dataset数据集的feat特征中,选取值为value的数据
    def splitDataSet(self, dataset, feat, values):
        retDataSet = []
        for featVec in dataset:
            if featVec[feat] == values:
                reducedFeatVec = featVec[:feat]
                reducedFeatVec.extend(featVec[feat + 1:])
                retDataSet.append(reducedFeatVec)
        return retDataSet

    # 计算dataSet的信息熵
    def calcShannonEnt(self, dataSet):
        num = len(dataSet)  # 样本集总数
        classList = [c[-1] for c in dataSet]  # 抽取分类信息
        labelCounts = {}
        for cs in set(classList):  # 对每个分类进行计数
            labelCounts[cs] = classList.count(cs)

        shannonEnt = 0.0
        for key in labelCounts:
            prob = labelCounts[key] / float(num)
            shannonEnt -= prob * log2(prob)
        return shannonEnt

    # 预测。对输入对象进行ID3分类
    def predict(self, tree, newObject):
        #    判断输入值是否为“dict”
        while type(tree).__name__ == 'dict':
            key = list(tree.keys())[0]
            tree = tree[key][newObject[key]]
        return tree

💲💲💲给出数据集,标签集:

dataSet = [[1, 1, 1, 1,1, 1, 'Yes'],
               [2, 1, 2, 1,1, 1, 'Yes'],
               [2, 1, 1, 1,1, 1, 'Yes'],
               [1, 1, 2, 1,1, 1, 'Yes'],
               [3, 1, 1, 1,1, 1, 'Yes'],
               [1,2, 1, 1,2, 2, 'Yes'],
               [2, 2, 1, 2,2, 2, 'Yes'],
               [2, 2, 1, 1,2, 1, 'Yes'],
               [2, 2, 2, 2,2, 1, 'No'],
               [1,3, 3, 1,3, 2, 'No'],
               [3, 3, 3, 3,3, 1, 'No'],
               [3, 1, 1, 3,3, 2, 'No'],
               [1, 2, 1, 2,1, 1, 'No'],
               [3,2, 2, 2,1, 1, 'No'],
               [2, 2, 1, 1,2, 2, 'No'],
               [3, 1, 1, 3,3, 1, 'No'],
               [1, 1, 2, 2,2, 1, 'No'],]

    #'色泽', '根蒂', '敲声', '纹理','脐部', '触感'
    features = ['seze', 'gendi', 'qiaosheng', 'wenli','qibu', 'chugan'] 

💞💞完整代码

from math import log2
import treePlotter

class ID3Tree(object):
    def __init__(self):
        self.tree = {}  # ID3 Tree
        self.dataSet = []  # 数据集
        self.labels = []  # 标签集

    def getDataSet(self, dataset, labels):
        self.dataSet = dataset
        self.labels = labels

    def train(self):
        # labels = copy.deepcopy(self.labels)
        labels = self.labels[:]
        self.tree = self.buildTree(self.dataSet, labels)

    def buildTree(self, dataSet, labels):
        classList = [ds[-1] for ds in dataSet]  # 提取样本的类别
        if classList.count(classList[0]) == len(classList):  # 单一类别
            return classList[0]
        if len(dataSet[0]) == 1:  # 没有属性需要划分了
            return self.classify(classList)

        bestFeat = self.findBestSplit(dataSet)  # 选取最大增益的属性序号
        bestFeatLabel = labels[bestFeat]
        tree = {bestFeatLabel: {}}  # 构造一个新的树结点
        del (labels[bestFeat])  # 从总属性列表中去除最大增益属性

        featValues = [ds[bestFeat] for ds in dataSet]  # 抽取最大增益属性的取值列表
        uniqueFeatValues = set(featValues)  # 选取最大增益属性的数值类别

        for value in uniqueFeatValues:  # 对于每一个属性类别
            subLabels = labels[:]
            subDataSet = self.splitDataSet(dataSet, bestFeat, value)  # 分裂结点
            subTree = self.buildTree(subDataSet, subLabels)  # 递归构造子树
            tree[bestFeatLabel][value] = subTree
        return tree

    # 计算出现次数最多的类别标签
    def classify(self, classList):
        items = dict([(classList.count(i), i) for i in classList])
        return items[max(items.keys())]

    # 计算最优特征
    def findBestSplit(self, dataset):
        numFeatures = len(dataset[0]) - 1
        baseEntropy = self.calcShannonEnt(dataset) # 基础熵
        num = len(dataset) # 样本总数
        bestInfoGain = 0.0
        bestFeat = -1  # 初始化最优特征向量轴
        # 遍历数据集各列,寻找最优特征轴
        for i in range(numFeatures):
            featValues = [ds[i] for ds in dataset]
            uniqueFeatValues = set(featValues)
            newEntropy = 0.0
            # 按列和唯一值,计算信息熵
            for val in uniqueFeatValues:
                subDataSet = self.splitDataSet(dataset, i, val)
                prob = len(subDataSet) / float(num) # 子集中的概率
                newEntropy += prob * self.calcShannonEnt(subDataSet)
            infoGain = baseEntropy - newEntropy # 信息增益
            if infoGain > bestInfoGain: # 挑选最大值
                bestInfoGain = baseEntropy - newEntropy
                bestFeat = i
        return bestFeat

    # 从dataset数据集的feat特征中,选取值为value的数据
    def splitDataSet(self, dataset, feat, values):
        retDataSet = []
        for featVec in dataset:
            if featVec[feat] == values:
                reducedFeatVec = featVec[:feat]
                reducedFeatVec.extend(featVec[feat + 1:])
                retDataSet.append(reducedFeatVec)
        return retDataSet

    # 计算dataSet的信息熵
    def calcShannonEnt(self, dataSet):
        num = len(dataSet)  # 样本集总数
        classList = [c[-1] for c in dataSet]  # 抽取分类信息
        labelCounts = {}
        for cs in set(classList):  # 对每个分类进行计数
            labelCounts[cs] = classList.count(cs)

        shannonEnt = 0.0
        for key in labelCounts:
            prob = labelCounts[key] / float(num)
            shannonEnt -= prob * log2(prob)
        return shannonEnt

    # 预测。对输入对象进行ID3分类
    def predict(self, tree, newObject):
        #    判断输入值是否为“dict”
        while type(tree).__name__ == 'dict':
            key = list(tree.keys())[0]
            tree = tree[key][newObject[key]]
        return tree

if __name__ == '__main__':
    def createDataSet():
        dataSet = [[1, 1, 1, 1,1, 1, 'Yes'],
                   [2, 1, 2, 1,1, 1, 'Yes'],
                   [2, 1, 1, 1,1, 1, 'Yes'],
                   [1, 1, 2, 1,1, 1, 'Yes'],
                   [3, 1, 1, 1,1, 1, 'Yes'],
                   [1,2, 1, 1,2, 2, 'Yes'],
                   [2, 2, 1, 2,2, 2, 'Yes'],
                   [2, 2, 1, 1,2, 1, 'Yes'],
                   [2, 2, 2, 2,2, 1, 'No'],
                   [1,3, 3, 1,3, 2, 'No'],
                   [3, 3, 3, 3,3, 1, 'No'],
                   [3, 1, 1, 3,3, 2, 'No'],
                   [1, 2, 1, 2,1, 1, 'No'],
                   [3,2, 2, 2,1, 1, 'No'],
                   [2, 2, 1, 1,2, 2, 'No'],
                   [3, 1, 1, 3,3, 1, 'No'],
                   [1, 1, 2, 2,2, 1, 'No'],]

        #'色泽', '根蒂', '敲声', '纹理','脐部', '触感'
        features = ['seze', 'gendi', 'qiaosheng', 'wenli','qibu', 'chugan'] 
        
        return dataSet, features

    id3 = ID3Tree()  # 创建一个ID3决策树
    ds, labels = createDataSet()
    id3.getDataSet(ds, labels)
    id3.train()  # 训练ID3决策树
    print(id3.tree)  # 输出ID3决策树
    print(id3.predict(id3.tree,{'seze':2,'gendi':2,'qiaosheng':1,'wenli':1,'qibu':1,'chugan':1}))
    treePlotter.createPlot(id3.tree)

💥💥生成决策树:

在这里插入图片描述

💌💌💌ID3算法实例

💨💨1.使用sklearn的决策树算法对葡萄酒数据集进行分类,要求:

(1)划分训练集和测试集(测试集占20%)

(2)对测试集的预测类别标签和真实标签进行对比

(3)输出分类的准确率

(4)调整参数比较不同算法(ID3, CART)的分类效果。

🕳🕳2. 利用给定ID3算法,画出下列训练集的决策树。

在这里插入图片描述

🍇🍇🍇1.葡萄酒分类

🚲🚲🚲(1)划分训练集和测试集(测试集占20%)

test_size等于几就是测试集占比
x_train, x_test, y_train, y_test = train_test_split(

   X, Y, test_size=0.2, random_state=0)

🚓🚓(2)对测试集的预测类别标签和真实标签进行对比

预测类别标签
y_predict = clf.predict(x_test)
对比
pd.concat([pd.DataFrame(x_test), pd.DataFrame(y_test), pd.DataFrame(y_predict)], axis=1)

🛹🛹(3)输出分类的准确率

clf.fit(x_train, y_train)
score = clf.score(x_test, y_test)

🏍🛵🏍(4)调整参数比较不同算法(ID3, CART)的分类效果。

采用ID3算法进行计算
clf = tree.DecisionTreeClassifier(criterion="entropy")
采用CART算法进行计算
clf = tree.DecisionTreeClassifier(criterion="gini")

🚀🚀🚀完整代码:

# 导入相关库
from sklearn.model_selection import train_test_split
from sklearn import tree
from sklearn.datasets import load_wine
import pandas as pd
# 导入数据集
wine = load_wine()
X = wine.data
Y = wine.target
features_name = wine.feature_names
print(features_name)
print(pd.concat([pd.DataFrame(X), pd.DataFrame(Y)], axis=1))
# 打印数据
# 划分数据集,数据集划分为测试集占20%;
x_train, x_test, y_train, y_test = train_test_split(
        X, Y, test_size=0.2, random_state=0)

# 采用ID3算法进行计算
clf = tree.DecisionTreeClassifier(criterion="entropy")
# 采用CART算法进行计算
# clf = tree.DecisionTreeClassifier(criterion="gini")
# 获取模型
clf.fit(x_train, y_train)
score = clf.score(x_test, y_test)
y_predict = clf.predict(x_test)
print('准确率为:', score)
# 对测试集的预测类别标签和真实标签进行对比
print(pd.concat([pd.DataFrame(x_test), pd.DataFrame(y_test), pd.DataFrame(y_predict)], axis=1))

🚀🚀🚀结果:

在这里插入图片描述

🛰🛰🌌2.只需修改数据集,标签集即可

🚩🚩部分代码:

if __name__ == '__main__':
    def createDataSet():
        dataSet = [[1, 1, 1, 1, 'No'],
                   [1, 1, 1, 2,  'No'],
                   [2, 1, 1, 1,  'Yes'],
                   [3, 2, 1, 1,  'Yes'],
                   [3, 3, 2, 1,  'Yes'],
                   [3, 3, 2, 2,  'No'],
                   [2, 3, 2, 2,  'Yes'],
                   [1, 2, 1, 1,  'No'],
                   [1, 3, 2, 1,  'Yes'],
                   [3, 2, 2, 1,  'Yes'],
                   [1, 2, 2, 2,  'Yes'],
                   [2, 2, 1, 2,  'Yes'],
                   [2, 1, 2, 1,  'Yes'],
                   [3, 2, 1, 2,  'No'], ]
        features = ['outlook', 'temp', 'humidity', 'windy']

        return dataSet, features


    id3 = ID3Tree()  # 创建一个ID3决策树
    ds, labels = createDataSet()
    id3.getDataSet(ds, labels)
    id3.train()  # 训练ID3决策树
    print(id3.tree)  # 输出ID3决策树
    print(id3.predict(id3.tree, {'outlook': 2, 'temp': 2, 'humidity': 1, 'windy': 1}))
    treePlotter.createPlot(id3.tree)

🍽🍽🌼🌼结果:

在这里插入图片描述
在这里插入图片描述

目录
相关文章
|
5月前
|
机器学习/深度学习 算法 PyTorch
【从零开始学习深度学习】38. Pytorch实战案例:梯度下降、随机梯度下降、小批量随机梯度下降3种优化算法对比【含数据集与源码】
【从零开始学习深度学习】38. Pytorch实战案例:梯度下降、随机梯度下降、小批量随机梯度下降3种优化算法对比【含数据集与源码】
|
3月前
|
数据采集 机器学习/深度学习 算法
【python】python客户信息审计风险决策树算法分类预测(源码+数据集+论文)【独一无二】
【python】python客户信息审计风险决策树算法分类预测(源码+数据集+论文)【独一无二】
|
5月前
|
机器学习/深度学习 算法 Python
介绍文本分类的基本概念、常用方法以及如何在Python中使用机器学习库进行文本分类
【6月更文挑战第13天】文本分类是机器学习在数字化时代的关键应用,涉及文本预处理、特征提取和模型训练等步骤。常见方法包括基于规则、关键词和机器学习,其中机器学习(如朴素贝叶斯、SVM、深度学习)是主流。在Python中,可使用scikit-learn进行文本分类,例如通过TF-IDF和朴素贝叶斯对新闻数据集进行处理和预测。随着技术发展,未来将深入探索深度学习和多模态数据在文本分类中的应用。
104 2
|
5月前
|
存储 算法 Java
Java数据结构与算法:用于高效地存储和检索字符串数据集
Java数据结构与算法:用于高效地存储和检索字符串数据集
|
6月前
|
机器学习/深度学习 PyTorch TensorFlow
【Python机器学习专栏】Python环境下的机器学习库概览
【4月更文挑战第30天】本文介绍了Python在机器学习中的重要性及几个主流库:NumPy用于数值计算,支持高效的数组操作;Pandas提供数据帧和序列,便利数据处理与分析;Matplotlib是数据可视化的有力工具;Scikit-learn包含多种机器学习算法,易于使用;TensorFlow和Keras是深度学习框架,Keras适合初学者;PyTorch则以其动态计算图和调试工具受到青睐。这些库助力机器学习研究与实践。
89 2
|
6月前
|
机器学习/深度学习 数据采集 算法
深度解析Python中的机器学习库:Scikit-learn
深度解析Python中的机器学习库:Scikit-learn
137 0
|
6月前
|
机器学习/深度学习 分布式计算 并行计算
【机器学习】怎样在非常大的数据集上执行K-means算法?
【5月更文挑战第13天】【机器学习】怎样在非常大的数据集上执行K-means算法?
|
6月前
|
算法 搜索推荐 数据挖掘
MATLAB模糊C均值聚类FCM改进的推荐系统协同过滤算法分析MovieLens电影数据集
MATLAB模糊C均值聚类FCM改进的推荐系统协同过滤算法分析MovieLens电影数据集
|
1天前
|
机器学习/深度学习 人工智能 算法
人工智能在医疗诊断中的应用及其挑战
【10月更文挑战第22天】人工智能技术正逐渐渗透到我们生活的方方面面,尤其是在医疗领域,它展现出了巨大的潜力。从辅助医生进行疾病诊断到预测患者病情的发展,AI的应用正在改变着传统的医疗模式。然而,随之而来的是一系列挑战,包括数据隐私、算法偏见以及医患关系的重新定位等问题。本文将探讨AI在医疗诊断中的应用实例,并分析面临的主要挑战,以期对未来的医疗AI应用提供深入的见解和建议。
|
1天前
|
传感器 人工智能 自动驾驶
人工智能在自动驾驶汽车中的应用
【10月更文挑战第31天】人工智能在自动驾驶汽车中的应用是科技进步与汽车产业转型的产物。通过计算机视觉、雷达、LiDAR和超声波传感器等技术,自动驾驶汽车实现了精准感知;借助复杂AI算法,实现决策与控制、路径规划与导航。尽管面临技术成熟度、法规与伦理、公众接受度等挑战,但未来自动驾驶汽车有望在全球范围内实现商业化普及,彻底改变出行方式,提高道路安全,减少交通拥堵,促进绿色出行。

热门文章

最新文章