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

已于 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
机器学习-朴素贝叶斯分类器
sinat_41847989的博客
01-24 745
一. 概率知识 先验概率：先验概率（prior probability）是指根据以往经验和分析得到的概率 后验概率：后验概率,事情已经发生，要求这件事情发生的原因是由某个因素引起的可能性的大小 后验概率就是条件概率 p(c|x) = p(x|c)p(c)/p(x) 贝叶斯概率引入先验知识和逻辑推理来处理不确定的命题 事情还没有发生，要求这件事情发生的可能性的大小，是先验...
模式识别实验报告实验一Bayes分类器设计
05-09
鄙人深感获此档案难度之高。在一番探索后，仍旧花费了3.43元巨款才购得此文件。念及此文件并非版权保护之作，且无任何协议在内，又经内心阵阵权衡。遂决定将其公之于众，若汝等困于寻此文件时，忽觉柳暗花明于此。鄙人不甚喜之。
机器学习之贝叶斯分类
最新发布
isi_1的博客
05-14 774
​贝叶斯分类算法是统计学中的一种概率分类方法，朴素贝叶斯分类是贝叶斯分类中最简单的一种。其分类原理就是利用贝叶斯公式根据某特征的先验概率计算出其后验概率，然后选择具有最大后验概率作为该特征所属的类。
模式识别实验报告--贝叶斯分类器设计
qq_46139457的博客
03-23 6769
模式识别实验报告–贝叶斯分类器设计 一、实验内容 用 FAMALE.TXT 和 MALE.TXT 的数据作为训练样本集，建立 Bayes 分类器，用测试样本数据对该分类器进行测试。具体做法：应用单个特征进行实验：假设身高和体重不相关，以（a）身高或者（b）体重数据作为特征，在正态分布假设下利用贝叶斯法估计概率密度函数， 建立最小错误率 Bayes 分类器。在分类器设计时可以考察采用不同先验概率进行实验，考察先验概率的不同对错误率的影响。 需要用到的数据文件： 训练样本集： FAMALE.TXT 50个女生
机器学习实验 - 朴素贝叶斯分类器
qq_41626672的博客
10-25 5031
西南交通大学 机器学习实验2 朴素贝叶斯分类器 （1）了解朴素贝叶斯与半朴素贝叶斯的区别与联系，掌握高斯分布、多项式分布和伯努利分布的朴素贝叶斯计算方法。（2）编程实现朴素贝叶斯分类器，基于多分类数据集，使用朴素贝叶斯分类器实现多分类预测，通过精确率、召回率和F1值度量模型性能。
【Sklearn】入门花卉数据集实验--理解朴素贝叶斯分类器
cungudafa的博客
06-19 3058
文章目录一、前言二、入门实例--花卉实例1.下载数据集2.beyes分类原理3.实例 一、前言 环境：Win10 + anaconda3 + jupyternotebook 图像的分类： 根据各自在图像信息中所反映的不同特征，把不同类别的目标区分开来的图像处理方法。它利用计算机对图像进行定量分析，把图像或图像中的每个像元或区域划归为若干个类别中的某一种，以代替人的视觉判读。 常见的分类算法： 包...
西电数据挖掘实验一 分类技术——鸢尾花分类
weixin_65746914的博客
01-14 1967
分类技术——鸢尾花分类 决策树 KNN 贝叶斯分类
机器学习——贝叶斯分类器
11-26
机器学习——贝叶斯分类器 贝叶斯分类器是机器学习中的一种常用算法，它基于贝叶斯定理和条件独立性假设，旨在对数据进行分类和预测。贝叶斯分类器的主要思想是通过训练数据集学习联合概率分布，然后使用后验概率...
人工智能-项目实践-朴素贝叶斯分类器-朴素贝叶斯文本分类器
03-25
人工智能_项目实践_朴素贝叶斯分类器_朴素贝叶斯文本分类器 **数据：**搜狗文本分类语料库 **分类器：**朴素贝叶斯分类器 NBC(Naive Bayesian Classifier) **编程语言：**Python+jieba分词库+nltk+sklearn
机器学习+贝叶斯分类器+北邮自动化机器学习实验+作业
04-29
在本实验中，我们将深入探讨机器学习领域的一个关键概念——贝叶斯分类器，这是北京邮电大学自动化专业机器学习课程中的一个实验项目。贝叶斯分类器是一种基于贝叶斯定理的统计方法，广泛应用于数据挖掘、文本分类、...
机器学习 naive 贝叶斯分类器实现 （附原始matlab代码和数据集）
08-30
主要适用于机器学习初学者，掌握基础理论； 可以在高质量数据集上面，修改测试代码，更好的掌握 naive Bayes 分类器理论和实际应用； 理解分类器的实际价值和局限性所在。 朴素贝叶斯是一种构建分类器的简单技术：...
机器学习实验四：贝叶斯分类器
magic171的博客
12-05 1164
实验数据为来自 UCI 的鸢尾花三分类数据集 Iris Plants Database。数据集共包含 150 组数据，分为 3 类，每类 50 组数据。每组数据包括 4 个参数和 1 个分类标签，4 个参数分别为：萼片长度 sepal length、萼片宽度 sepalwidth、花瓣长度 petal length、花瓣宽度 petal width，单位均为厘米。分类标签共有三种，分别为 Iris Setosa、Iris Versicolour 和 Iris Virginica。
机器学习实战篇：使用贝叶斯模型对鸢尾花数据集分类
人工智能讲师团
03-11 7925
1、简介 本文主要讲解朴素贝叶斯及其推理，并实现鸢尾花数据的分类问题 2、算法解释 朴素贝叶斯最初来源于统计科学领域。根据朴素贝叶斯公式： 由于类似然涉及到多个特征的组合求解较为困难。所以为了简化运算，降低计算复杂度，我们假设每个特征具备统计独立性，即特征间不存在关联性。这样就可以简化上述贝叶斯公式为： 上述公式即为朴素贝叶斯通用公式，我们进一步化简去除无关证据项得： 根据...
机器学习实验：朴素贝叶斯算法实现对iris鸢尾花数据集的分类
热门推荐
m0_46553432的博客
04-14 1万+
机器学习实验：朴素贝叶斯算法实现对iris鸢尾花数据集的分类 实验内容： 通过sklearn提供的贝叶斯算法模型实现对iris鸢尾花数据集的分类及预测 使用PCA降维，并通过matplotlib对决策边进行绘制 代码如下： 导入相关库 import pandas as pd import numpy as np import matplotlib.colors as colors import matplotlib as mpl import matplotlib.pyplot as plt imp
机器学习实验6 贝叶斯分类器
weixin_51703554的博客
10-12 322
可以求出，在这里使用布尔值索引lable==i可以减少代码量，更加简便快捷。由于属性是-1和1，使用列表等下标必须是非负整数，所以这里使用字典存储，索引更加灵活。通过这次实验，我学习到了朴素贝叶斯分类器，相较于以前的SVM等分类方法，又学习到了基于概率的分类，提供了另一种解决分类问题的思路。3、求出条件概率，即不同属性在不同类别中出现的概率。需要保存两个键，键可能是负数或字符，使用嵌套的字典。三层循环，最外层枚举类型，第二层枚举属性列，最内层枚举该属性的所有取值。同样使用拉普拉斯修正进行数据平滑，公式为。
机器学习实验报告——Bayes算法
m0_64198455的博客
01-22 1482
朴素贝叶斯是一种有监督学习算法，这种算法基于贝叶斯的一个朴素的假设——每对特征和样本数据都是独立同分布的。最终可以推出朴素贝叶斯分类器的判定准则：贝叶斯的主要思路就是数数，统计每个条件组合下各种结果的概率，并根据这个概率做出分类。但是，单纯的贝叶斯在计算机计算的时候会出现计算规模过大的情况，这里就需要 引入朴素条件，化简式子。最终结果就是在计算时我们只需要统计单个条件下的结果，并据此计算得结果就好了，区别于先自由组合条件在统计结果。
机器学习-贝叶斯分类器
04-12
贝叶斯分类器是一种常见的机器学习算法，它基于贝叶斯定理进行分类。该算法通过计算给定特征条件下每个类别的概率，并选择具有最高概率的类别作为预测结果。 贝叶斯分类器的基本原理是利用已知的特征和类别之间的关系，来预测新样本的类别。它假设特征之间相互独立，并且每个特征对于确定类别的重要性是相同的。 具体来说，贝叶斯分类器使用训练数据集来估计每个类别的先验概率和每个特征在每个类别下的条件概率。然后，对于给定的测试样本，它计算该样本属于每个类别的后验概率，并选择具有最高后验概率的类别作为预测结果。 贝叶斯分类器有几种不同的变体，其中最常见的是朴素贝叶斯分类器。朴素贝叶斯分类器假设特征之间是相互独立的，这样可以简化计算过程。它在文本分类、垃圾邮件过滤等领域得到广泛应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值