机器学习实验-贝叶斯分类器

已于 2023-04-11 21:33:56 修改
阅读量1k 收藏 19
点赞数 4
分类专栏： 机器学习 文章标签： 机器学习 人工智能 深度学习
于 2023-04-11 21:11:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JaneZ0206/article/details/130093385
版权

山东大学软件学院机器学习基础课程实验报告

文章目录

一、前期准备

鸢尾花数据集

iris以鸢尾花的特征作为数据来源，常用在分类操作中。该数据集由3种不同类型的鸢尾花的各50个样本数据构成。其中的一个种类与另外两个种类是线性可分离的，后两个种类是非线性可分离的。

该数据集包含了4个属性：

& Sepal.Length（花萼长度），单位是cm;

& Sepal.Width（花萼宽度），单位是cm;

& Petal.Length（花瓣长度），单位是cm;

& Petal.Width（花瓣宽度），单位是cm;

种类：Iris Setosa（山鸢尾）、Iris Versicolour（杂色鸢尾），以及Iris Virginica（维吉尼亚鸢尾）

数据集可以从网上下载

需要手动分割训练集和数据集。我将五分之四的数据集作为训练集对贝叶斯分类器进行训练，将剩余数据集作为测试集，采用训练好的贝叶斯分类器模型对其进行预测。训练集与测试集的数据是随机选取的。

贝叶斯分类器

下面只是写一个目录，只把用到的朴素贝叶斯分类器的核心思想记录了一下，其它详见西瓜书。

贝叶斯准则
基于最小错误率的贝叶斯决策
极大似然估计
朴素贝叶斯分类器

简化：“属性条件独立性假设”

分类过程：

  1. 估计类先验概率
    • 拉普拉斯修正 “平滑”
  2. 估计类条件概率
    • 离散属性：拉普拉斯修正 “平滑”
    • 连续属性：高斯函数
  3. 估计后验概率
    • 后验概率 = 类先验概率*所有的类条件概率
    • 后验概率最大的即为所属类别
    • 常通过取对数的方式将“连乘”转化为“连加”，以避免数值下溢
半朴素贝叶斯分类器

二、实验过程

1.分割数据集

数据集是从网上下载的.csv文件，直接放在了项目里。

首先以4 : 1（训练集：测试集）的比例分割数据集：

因为每个类别都有50条数据，我初始是按照每个类别随机取10条数据作为测试集的想法做的，代码如下：

def split_dataset(data: pd.DataFrame):
    """
    分割训练集和测试集
    :param data: iris dataset
    :return: trainSet, testSet
    """
    # 随机采样 每个品种各取1/5作为测试集
    test_index = random.sample(range(50), 10)
    test_index.extend(random.sample(range(50, 100), 10))
    test_index.extend(random.sample(range(100, 150), 10))
    print("测试集包括：")
    print(test_index)
    testSet = data.iloc[test_index]
    train_index = list(range(150))
    for index in test_index:
        train_index.remove(index)
    trainSet = data.iloc[train_index]
    return trainSet, testSet

后来考虑了一下，为了使随机采样更具随机性，我选择了直接随机取样。把随机采样改为：

test_index = random.sample(range(150), 30)

2.计算类先验概率

	# 类先验概率
    # 拉普拉斯修正
    num = train.shape[0]
    prior_0 = np.log((train.loc[train.Species == Species[0]].shape[0]+1)/(num+3))
    prior_1 = np.log((train.loc[train.Species == Species[1]].shape[0]+1)/(num+3))
    prior_2 = np.log((train.loc[train.Species == Species[2]].shape[0]+1)/(num+3))

在这里，采用了拉普拉斯修正，进行“平滑”处理。

同时，为了避免数值下溢，对数值进行取对数处理。

使用train.loc[train.Species == Species[0]]获得训练集中品种为"setosa"的数据，使用.shape[0]取得行数。

3.计算所有列的类条件概率

首先，因为鸢尾花数据集都是连续数据，所以要用高斯函数计算类条件概率，函数代码如下：

def continuous_attr_p(value, mean, var):
    """

    :param value: xi
    :param mean: 均值
    :param var: 方差
    :return: 类条件概率p
    """
    p = 1 / ((2 * PI * var) ** 0.5) * math.exp(-(value - mean)**2 / (2 * var))
    # print("p:")
    # print(p)
    return p

计算所有类条件概率的思路：根据物种类型，取出训练集中同属于一类的数据。对于这些数据中的每一列，计算它们的均值和方差，代入测试集数据x该列的值，计算类条件概率，判断这些数据属于哪个物种类型，将每列的类条件概率存放在定义好的字典中。属于"setosa"就存放在storage0中，以此类推。为了避免数值下溢，对数值进行取对数处理。

Species = ["setosa", "versicolor", "virginica"]

定义字典的代码：

storage0 = {"Sepal.Length": 0, "Sepal.Width": 0, "Petal.Length": 0, "Petal.Width": 0}
storage1 = {"Sepal.Length": 0, "Sepal.Width": 0, "Petal.Length": 0, "Petal.Width": 0}
storage2 = {"Sepal.Length": 0, "Sepal.Width": 0, "Petal.Length": 0, "Petal.Width": 0}

该思路实现的代码为：

for spes in Species:
    train_dic = train.loc[train.Species == spes]
    for column in train_dic.columns:
        if column != 'Species':  # 去除预测标签的影响
            mean = np.mean(train_dic[column])
            var = np.var(train_dic[column])
            p = np.log(continuous_attr_p(x[column], mean, var))
            if spes == Species[0]:
                storage0[column] = p
            elif spes == Species[1]:
                storage1[column] = p
            elif spes == Species[2]:
                storage2[column] = p

4.计算后验概率

定义一个后验概率数组，存放三个品种的后验概率。

post_p = np.zeros(3, np.float64)
post_p[0] = prior_0
post_p[1] = prior_1
post_p[2] = prior_2

因为先验概率和所有的类条件概率都取了对数，所以后验概率=类先验概率+所有的类条件概率之和。

for column in train.columns:
    if column != 'Species':
        post_p[0] = post_p[0] + storage0[column]
        post_p[1] = post_p[1] + storage1[column]
        post_p[2] = post_p[2] + storage2[column]

返回三者中的最大值的索引，索引与Species数组相对应，得到的即为该测试数据所属的类别：

post_p_i = np.argmax(post_p, axis=0)
print("post_p_i", post_p_i)
return post_p_i

主函数

贝叶斯分类器的实现
	Data = pd.read_csv('iris.csv')
    # 划分数据集
    train_set, test_set = split_dataset(Data)

    # 存放分类器对测试集的分类结果
    classify_result = []
    for index, row in test_set.iterrows():
        classify_result.append(Species[classifier(row, train_set)])
    # 将分类结果添加到测试集中
    test_set.insert(test_set.shape[1], 'forecast', classify_result)
可视化方式

使用seaborn绘图工具

①以Species为x轴，使用sns.countplot()绘制条形图，显示训练集中各物种的个数：

colors = sns.color_palette('pastel')
sns.countplot(x="Species", palette='pastel', data=train_set)
plt.show()

②统计测试集中分类正确和分类错误的数目：

# 分类正确的数目
df1 = test_set[['Species']]
df2 = test_set[['forecast']]
df = pd.concat([df1, df2], axis=1)
df['result'] = np.where(df['Species'] == df['forecast'], 'true', 'false')
colors = sns.color_palette('pastel')
sns.countplot(x="result", palette='pastel', data=df)
plt.show()

③以Sepal.Length为x轴，以Petal.Length为y轴绘制回归图，对比以Species列为分类标准和以forecast列为分类标准的图像的差异。

sns.lmplot(x='Sepal.Length', y='Petal.Length', hue='Species',
           data=test_set, markers=['*', 'o', '+'])
plt.show()

sns.lmplot(x='Sepal.Length', y='Petal.Length', hue='forecast',
           data=test_set, markers=['*', 'o', '+'])
plt.show()
评估方式

采用准确率：分类正确的样本数/总样本数进行评估

TP = 0
for index, row in comparison.iterrows():
    if row["Species"] == row['forecast']:
        TP += 1

Accuracy = TP / 30
print('正确率: {:.2%}'.format(Accuracy))

三、输出截屏

注：下列输出结果为使用jupyter运行后得到的结果。

1.测试集选取

随机选取的测试集标号：
请添加图片描述

2.训练集各物种个数

可视化显示训练集中各物种的个数：
请添加图片描述

3.各测试数据计算出的后验概率与种类选取

输出后验概率：post_p[0]为setosa物种的后验概率，post_p[1]为versicolor物种的后验概率，post_p[2]为virginica物种的后验概率。取三者的最大值作post_p_i，即预测的类别，0为setosa物种，1为versicolor物种，2为virginica物种。

下图仅为部分数据：
请添加图片描述

4.测试集正确分类与贝叶斯分类结果对比

①统计测试集中分类正确和分类错误的数目：
请添加图片描述
②

应该得到的正确分类：
请添加图片描述
实际上得到的结果：
请添加图片描述

5.正确率

请添加图片描述

四、全部代码

import numpy as np
import random
import math
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# from torcheval.metrics import functional as TMF

PI = math.pi
Species = ["setosa", "versicolor", "virginica"]


def split_dataset(data: pd.DataFrame):
    """
    分割训练集和测试集
    :param data: iris dataset
    :return: trainSet, testSet
    """
    # 随机采样
    test_index = random.sample(range(150), 30)
    print("测试集包括：")
    print(test_index)
    testSet = data.iloc[test_index]
    train_index = list(range(150))
    for index in test_index:
        train_index.remove(index)
    trainSet = data.iloc[train_index]
    return trainSet, testSet


def continuous_attr_p(value, mean, var):
    """

    :param value: xi
    :param mean: 均值
    :param var: 方差
    :return: 类条件概率p
    """
    p = 1 / ((2 * PI * var) ** 0.5) * math.exp(-(value - mean) ** 2 / (2 * var))
    # print("p:")
    # print(p)
    return p


storage0 = {"Sepal.Length": 0, "Sepal.Width": 0, "Petal.Length": 0, "Petal.Width": 0}
storage1 = {"Sepal.Length": 0, "Sepal.Width": 0, "Petal.Length": 0, "Petal.Width": 0}
storage2 = {"Sepal.Length": 0, "Sepal.Width": 0, "Petal.Length": 0, "Petal.Width": 0}


def classifier(x, train: pd.DataFrame):
    """
     朴素贝叶斯分类
     鸢尾花数据集都是连续数据
    :param x: 测试集的一条数据
    :param train: 训练集模型
    :return: 预测结果
    """
    # 类先验概率
    # 拉普拉斯修正
    num = train.shape[0]
    prior_0 = np.log((train.loc[train.Species == Species[0]].shape[0] + 1) / (num + 3))
    prior_1 = np.log((train.loc[train.Species == Species[1]].shape[0] + 1) / (num + 3))
    prior_2 = np.log((train.loc[train.Species == Species[2]].shape[0] + 1) / (num + 3))

    # 计算所有列的类条件概率
    for spes in Species:
        train_dic = train.loc[train.Species == spes]
        for column in train_dic.columns:
            if column != 'Species':  # 去除预测标签的影响
                mean = np.mean(train_dic[column])
                var = np.var(train_dic[column])
                p = np.log(continuous_attr_p(x[column], mean, var))
                if spes == Species[0]:
                    storage0[column] = p
                elif spes == Species[1]:
                    storage1[column] = p
                elif spes == Species[2]:
                    storage2[column] = p

    post_p = np.zeros(3, np.float64)
    post_p[0] = prior_0
    post_p[1] = prior_1
    post_p[2] = prior_2
    for column in train.columns:
        if column != 'Species':
            post_p[0] = post_p[0] + storage0[column]
            post_p[1] = post_p[1] + storage1[column]
            post_p[2] = post_p[2] + storage2[column]

    print("post_p[0]", post_p[0])
    print("post_p[1]", post_p[1])
    print("post_p[2]", post_p[2])
    post_p_i = np.argmax(post_p, axis=0)
    print("post_p_i", post_p_i)
    return post_p_i


if __name__ == '__main__':

    Data = pd.read_csv('iris.csv')
    # 划分数据集
    train_set, test_set = split_dataset(Data)

    # 显示训练集物种分布情况
    #     a=[]
    #     for index, row in train_set.iterrows():
    #         if row["Species"] == Species[0]:
    #             a.append(1)
    #         elif  row["Species"] == Species[1]:
    #             a.append(2)
    #         else:
    #             a.append(3)
    #     train_set.insert(train_set.shape[1], 'digit',a)
    colors = sns.color_palette('pastel')
    sns.countplot(x="Species", palette='pastel', data=train_set)
    plt.show()

    # 存放分类器对测试集的分类结果
    classify_result = []
    for index, row in test_set.iterrows():
        classify_result.append(Species[classifier(row, train_set)])

    # 将分类结果添加到测试集中
    test_set.insert(test_set.shape[1], 'forecast', classify_result)

    sns.lmplot(x='Sepal.Length', y='Petal.Length', hue='Species',
               data=test_set, markers=['*', 'o', '+'])
    plt.show()

    sns.lmplot(x='Sepal.Length', y='Petal.Length', hue='forecast',
               data=test_set, markers=['*', 'o', '+'])
    plt.show()

    # 分类正确的数目
    df1 = test_set[['Species']]
    df2 = test_set[['forecast']]
    df = pd.concat([df1, df2], axis=1)
    df['result'] = np.where(df['Species'] == df['forecast'], 'true', 'false')
    colors = sns.color_palette('pastel')
    sns.countplot(x="result", palette='pastel', data=df)
    plt.show()

    TP = 0
    for index, row in test_set.iterrows():
        if row["Species"] == row['forecast']:
            TP += 1

    Accuracy = TP / 30

    print('正确率: {:.2%}'.format(Accuracy))

五、心得体会

​ 通过本次实验，我对贝叶斯分类器有了更深刻的了解，清楚了朴素贝叶斯分类的基本流程，加深了对机器学习基本方法的理解与应用，提高了自身的代码技能和分析并解决问题的能力，为之后的实验和学习奠定了基础，受益匪浅。

JaneZ0206
关注
  • 4
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习贝叶斯分类器
DHYYYYYY的博客
12-16 999
6.1.1 背景知识 贝叶斯方法分析的特点是用概率表示不确定性。 贝叶斯决策论是在概率框架下试试决策的基本方法。 在分类问题情况下，在所有相关概率都已知的理想情形下，贝叶斯决策考虑如何基于这些概率和误判损失来选择最优的类别标记。 概率基本概念： 先验概率(P(Y)):即根据往年经验及其他因素预测的事件的概率。 后验概率(P(Y|X))：即在先验概率的情况下根据其他因素推测的概率。 联合概率：表示两个事件共同发生的概率。 6.1.2 贝叶斯决策论 贝叶斯定理： 估计后验概率P(c|x)主要困难:类条件概率P
机器学习——贝叶斯分类器
11-26
机器学习——贝叶斯分类器 贝叶斯分类器是机器学习中的一种常用算法，它基于贝叶斯定理和条件独立性假设，旨在对数据进行分类和预测。贝叶斯分类器的主要思想是通过训练数据集学习联合概率分布，然后使用后验概率...
机器学习之贝叶斯分类
isi_1的博客
05-14 775
​贝叶斯分类算法是统计学中的一种概率分类方法，朴素贝叶斯分类是贝叶斯分类中最简单的一种。其分类原理就是利用贝叶斯公式根据某特征的先验概率计算出其后验概率，然后选择具有最大后验概率作为该特征所属的类。
机器学习实验 - 朴素贝叶斯分类器
qq_41626672的博客
10-25 5031
西南交通大学 机器学习实验2 朴素贝叶斯分类器 （1）了解朴素贝叶斯与半朴素贝叶斯的区别与联系，掌握高斯分布、多项式分布和伯努利分布的朴素贝叶斯计算方法。（2）编程实现朴素贝叶斯分类器，基于多分类数据集，使用朴素贝叶斯分类器实现多分类预测，通过精确率、召回率和F1值度量模型性能。
机器学习--贝叶斯分类器
SHUA_y的博客
07-25 986
贝叶斯决策论，贝叶斯分类器与贝叶斯学习，朴素贝叶斯分类器
机器学习-贝叶斯分类器（附Python代码）
热门推荐
gao_的博客
08-24 2万+
通过贝叶斯定理的理解，运用贝叶斯分类器处理分类问题
机器学习—— 朴素贝叶斯分类器
qq_52669357的博客
03-30 7450
朴素贝叶斯分类器简述条件概率贝叶斯公式拉普拉斯平滑文本向量化MultinomialNB 条件概率 在进入朴素贝叶斯分类算法的学习之前，我们需要先了解一些概率论的知识，首先来看看条件概率吧。 条件概率是指某一事件A发生的可能性，表示P(A)。而条件概率指的是某一事件A已经发生了条件下，另一事件B发生的可能性，表示为P(B|A)。 怎么计算条件概率呢？设A,B是两个独立事件，且P(A)>0，称P(B|A)=P(AB)/P(A)为在事件A发生的条件下，事件B发生的条件概率。P(AB)表示事件A和B同时发生的
机器学习-贝叶斯分类实验
贰十二的博客
08-15 2776
机器学习-贝叶斯分类1. 中文文本分类介绍2. 文本分类的一般步骤：3. 具体操作4. 实验步骤5. 实验完整代码python 1. 中文文本分类介绍 文本挖掘是指从大量的文本数据中抽取事先未知的、可理解的、最终可用的知识的过程，同时运用这些知识更好的组织信息以便将来参考。 主要有以下几个方面的应用： 搜索和信息检索（IR）：存储和文本文档的检索，包括搜索引擎个关键字搜索。 文本聚类：使用聚类方法，对词汇、片段、段落或文件进行分组和归类。 文本分类：对片段、段落或文件进行分组和归类，在使用数据挖掘分类方法的
机器学习-朴素贝叶斯分类
qq_52233007的博客
11-29 1837
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考优点：1、朴素贝叶斯模型发源于古典数学理论，有着坚实的数学基础，以及稳定的分类效率。2、NBC模型所需估计的参数很少，对缺失数据不太敏感，算法也比较简单。缺点：1、理论上，NBC模型与其他分类方法相比具有最小的误差率。
机器学习 --- 朴素贝叶斯分类器
学习日常分享
06-23 2万+
第1关：条件概率 任务描述 本关任务：根据本节课所学知识完成本关所设置的选择题。 相关知识 为了完成本关任务，你需要掌握条件概率。 条件概率 朴素贝叶斯分类算法是基于贝叶斯定理与特征条件独立假设的分类方法，因此想要了解朴素贝叶斯分类算法背后的算法原理，就不得不用到概率论的一些知识，首当其冲就是条件概率。接下来就开启我们的条件概率之旅吧。 什么是条件概率 概率指的是某一事件A发生的可能性，表示为P(A)。而条件概率指的是某一事件A已经发生了条件下，另一事件B发生的可能性，表示为P(B|A)，举个例子： 今天有
机器学习-朴素贝叶斯分类器
m0_74216325的博客
05-14 994
贝叶斯分类器是一种基于贝叶斯定理的概率模型，常用于文本分类、垃圾邮件过滤、情析等任务。该分类器基于特征之间的条件独立性假设，即给定类别下特征之间相互独立。它的工作原理是通过计算给定特征条件下类别的概率，并选择具有最高概率的类别作为预测结果。在本次的实验中，主要涉及朴素贝叶斯分类器，朴素贝叶斯分类器，它假设每个特征对于类别的影响是相互独立的，即使这在实际情况中并不成立。常见的朴素贝叶斯分类器包括多项式朴素贝叶斯、伯努利朴素贝叶斯和高斯朴素贝叶斯，它们分别适用于不同类型的特征分布。
人工智能-项目实践-朴素贝叶斯分类器-朴素贝叶斯文本分类器
03-25
人工智能_项目实践_朴素贝叶斯分类器_朴素贝叶斯文本分类器 **数据：**搜狗文本分类语料库 **分类器：**朴素贝叶斯分类器 NBC(Naive Bayesian Classifier) **编程语言：**Python+jieba分词库+nltk+sklearn
机器学习+贝叶斯分类器+北邮自动化机器学习实验+作业
04-29
在本实验中，我们将深入探讨机器学习领域的一个关键概念——贝叶斯分类器，这是北京邮电大学自动化专业机器学习课程中的一个实验项目。贝叶斯分类器是一种基于贝叶斯定理的统计方法，广泛应用于数据挖掘、文本分类、...
机器学习 naive 贝叶斯分类器实现 （附原始matlab代码和数据集）
08-30
主要适用于机器学习初学者，掌握基础理论； 可以在高质量数据集上面，修改测试代码，更好的掌握 naive Bayes 分类器理论和实际应用； 理解分类器的实际价值和局限性所在。 朴素贝叶斯是一种构建分类器的简单技术：...
人工智能与机器学习原理精解【5】
基础数学与应用数学
07-24 1136
下面内容来自文心一言的自动生成特征值分解是一种矩阵分解方法，特别适用于方阵。它能够将一个矩阵分解成特征向量和特征值的线性组合，这在数学、物理、工程及计算机科学等多个领域都有重要应用。以下是对特征值分解的详细说明，包括算法和例子。A=QΛQ−1A = QΛQ^{-1}A=QΛQ−1其中，Q是由A的特征向量构成的矩阵（每列是一个特征向量），Λ是一个对角矩阵，其对角线上的元素是A的特征值。对于实对称矩阵，Q是正交矩阵，即Q的逆等于Q的转置（QTQ^TQT），因此特征值分解可以简化为：A=QΛQTA = QΛQ^T
【机器学习】Jupyter Notebook如何使用之基本步骤和进阶操作
m0_49243785的博客
07-23 741
Jupyter Notebook 是一个交互式计算环境，它允许创建包含代码、文本和可视化内容的文档
2024钉钉杯A题思路详解
最新发布
全栈川川
07-26 1813
2024钉钉杯思路
机器学习-贝叶斯分类器
04-12
贝叶斯分类器是一种常见的机器学习算法，它基于贝叶斯定理进行分类。该算法通过计算给定特征条件下每个类别的概率，并选择具有最高概率的类别作为预测结果。 贝叶斯分类器的基本原理是利用已知的特征和类别之间的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值