精华内容
下载资源
问答
  • 朴素贝叶斯应用实例
    千次阅读
    2022-03-12 14:58:03
    """
    朴素贝叶斯算法案例
    """
    import numpy as np
    #准备数据
    def loadDataSets():
        """
        加载数据集
        :return: dataMatrix,labelList
        """
        dataMatrix = [
            ["stop", "fuck", "you", "bitch", "garbage"],
            ["useless", "dog", "stupid", "worthless"],
            ["suck", "my", "dick", "bitch", "pig", "asshole"],
            ["son", "bitch", "hoocker", "happy"],
            ['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
            ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
            ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
        ]
        labelList = [1, 1, 1, 1, 0, 0, 0]
    
        return dataMatrix, labelList
    
    #得到去重列表(词汇表)
    def buildWordsSet(dataMatrix):
        """
        创建单词集合
        :param dataMatrix: 单词矩阵
        :return:
        """
    	# 定义一个空set,因为set本身有去重的功能
        wordsSet = set([])
    	# 遍历矩阵的每一行
        for comment in dataMatrix:
    		# |表示取交集
            wordsSet = wordsSet | set(comment)
        return list(wordsSet)
    
    #把dataMatrix转为one-hot
    def getOneZeroVector(wordSet, comment):
        """
        以wordSet这个训练集词频向量为依据构建comment的词频(0,1)向量
        :param wordSet: 全集
        :param comment: 单个评论的list
        :return: 每个comment对应的(0,1)向量
        """
        one_zero_vec = [0] * len(wordSet)
        for word in comment:
            if word in wordSet:
                one_zero_vec[wordSet.index(word)] = 1
            else:
                print(" %s 没有收录" % word)
        return one_zero_vec
    
    #训练:
    #计算bayes参数代码
    def getBayesParams(one_zero_matrix, labelList):
        """
        计算贝叶斯公式参数
        :param one_zero_matrix: (0,1)词频矩阵
        :param labelList: 每个评论的标签
        :return: log(词频/好类总词数) , log(词频/坏类总次数) , 侮辱性评论占训练集总评论概率
        """
        # 侮辱性评论概率
        p_c1 = sum(labelList) / float(len(labelList))
        # 训练集总词数
        total_words_count = len(one_zero_matrix[0])
        # 两种单词出现频率列表
        p0List = np.ones(len(one_zero_matrix[0]))
        p1List = np.ones(len(one_zero_matrix[0]))
        # 计算两类词频
        p0num = 1.0
        p1num = 1.0
    
        # 遍历所有测试集评论
        for i in range(len(labelList)):
            # 若该评论是侮辱性
            if labelList[i] == 1:
                p1List += one_zero_matrix[i]
                p1num += sum(one_zero_matrix[i])
            else:
                p0List += one_zero_matrix[i]
                p0num += sum(one_zero_matrix[i])
        # 每个词词频列表/该类别词频 再取对数
        p1vec = np.log(p1List / p1num)  # 已知是侮辱性评论情况下,每个词出现的概率
        p0vec = np.log(p0List / p0num)  # 已知不是侮辱性评论情况下,每个词出现的概率
    
        return p1vec, p0vec, p_c1
    
    def classifyByBayes(p1vec, p0vec, p_c1, one_zero_vector):
        """
        使用贝叶斯参数比较得出结果
        :param p1vec:
        :param p0vec:
        :param p_c1:
        :param one_zero_vector:
        :return:
        """
        # sum(one_zero_vector * p1vec) 对应元素相乘相加
        # p_1 = sum(one_zero_vector * p1vec) + np.log(p_c1)
        p_1 = sum(one_zero_vector * p1vec)
        # p_0 = sum(one_zero_vector * p0vec) + np.log(1.0 - p_c1)
        p_0 = sum(one_zero_vector * p0vec)
        if p_1 > p_0:
            return 1
        else:
            return 0
    
    
    更多相关内容
  • 基于朴素贝叶斯分类器的文本分类算法 (C语言.txt 两个人吵架先说对不起的人并不是 认输了并不是原谅了他只是比对方更珍惜这份感情#include <stdio.h> #include <string.h> #include <direct.h> //_getcwd, _chdir) #...
  • 本文实例讲述了朴素贝叶斯分类算法原理与Python实现与使用方法。分享给大家供大家参考,具体如下: 朴素贝叶斯分类算法 1、朴素贝叶斯分类算法原理 1.1、概述 贝叶斯分类算法是一大类分类算法的总称 贝叶斯分类算法...
  • 本文实例为大家分享了Python朴素贝叶斯实例代码,供大家参考,具体内容如下 #-*- coding: utf-8 -*- #添加中文注释 from numpy import * #过滤网站的恶意留言 #样本数据 def loadDataSet(): postingList=[['my', '...
  • 朴素贝叶斯(二)文本分类朴素贝叶斯的一般流程用python进行文本分类准备数据:从文本中构建词向量训练算法:从词向量计算概率测试算法:朴素贝叶斯分类函数文档词袋模型 朴素贝叶斯的一般流程 (1)收集数据:任何...
  • 朴素贝叶斯算法就是在牺牲一定准确率的情况下强制特征x满足独立条件,求解P(x|y)就更为方便了 但基本上现实生活中,没有任何关系的两个特征几乎是不存在的,故朴素贝叶斯不适合那些关系密切的特征 from ...
  • 朴素贝叶斯分类算法简单实例

    千次阅读 2021-08-18 08:55:16
    而朴素朴素贝叶斯分类是贝叶斯分类中最简单,也是常见的一种分类方法。这篇文章我尽可能用直白的话语总结一下我们学习会上讲到的朴素贝叶斯分类算法,希望有利于他人理解。 1 分类问题综述 对于分类问题,...

    贝叶斯分类是一类分类算法的总称,这类算法均以贝叶斯定理为基础,故统称为贝叶斯分类。而朴素朴素贝叶斯分类是贝叶斯分类中最简单,也是常见的一种分类方法。这篇文章我尽可能用直白的话语总结一下我们学习会上讲到的朴素贝叶斯分类算法,希望有利于他人理解。

    1  分类问题综述

     对于分类问题,其实谁都不会陌生,日常生活中我们每天都进行着分类过程。例如,当你看到一个人,你的脑子下意识判断他是学生还是社会上的人;你可能经常会走在路上对身旁的朋友说“这个人一看就很有钱”之类的话,其实这就是一种分类操作。

    既然是贝叶斯分类算法,那么分类的数学描述又是什么呢?

    从数学角度来说,分类问题可做如下定义:已知集合,确定映射规则y = f(x),使得任意有且仅有一个,使得成立。

    其中C叫做类别集合,其中每一个元素是一个类别,而I叫做项集合(特征集合),其中每一个元素是一个待分类项,f叫做分类器。分类算法的任务就是构造分类器f。

    分类算法的内容是要求给定特征,让我们得出类别,这也是所有分类问题的关键。那么如何由指定特征,得到我们最终的类别,也是我们下面要讲的,每一个不同的分类算法,对应着不同的核心思想。

    本篇文章,我会用一个具体实例,对朴素贝叶斯算法几乎所有的重要知识点进行讲解。

    2  朴素贝叶斯分类

    那么既然是朴素贝叶斯分类算法,它的核心算法又是什么呢?

    是下面这个贝叶斯公式:

    换个表达形式就会明朗很多,如下:

    我们最终求的p(类别|特征)即可!就相当于完成了我们的任务。

    3  例题分析

    下面我先给出例子问题。

    给定数据如下:

    现在给我们的问题是,如果一对男女朋友,男生想女生求婚,男生的四个特点分别是不帅,性格不好,身高矮,不上进,请你判断一下女生是嫁还是不嫁?

    这是一个典型的分类问题,转为数学问题就是比较p(嫁|(不帅、性格不好、身高矮、不上进))与p(不嫁|(不帅、性格不好、身高矮、不上进))的概率,谁的概率大,我就能给出嫁或者不嫁的答案!

    这里我们联系到朴素贝叶斯公式:

    我们需要求p(嫁|(不帅、性格不好、身高矮、不上进),这是我们不知道的,但是通过朴素贝叶斯公式可以转化为好求的三个量.

    p(不帅、性格不好、身高矮、不上进|嫁)、p(不帅、性格不好、身高矮、不上进)、p(嫁)(至于为什么能求,后面会讲,那么就太好了,将待求的量转化为其它可求的值,这就相当于解决了我们的问题!)

    4  朴素贝叶斯算法的朴素一词解释

    那么这三个量是如何求得?

    是根据已知训练数据统计得来,下面详细给出该例子的求解过程。

    回忆一下我们要求的公式如下:

    那么我只要求得p(不帅、性格不好、身高矮、不上进|嫁)、p(不帅、性格不好、身高矮、不上进)、p(嫁)即可,好的,下面我分别求出这几个概率,最后一比,就得到最终结果。

    p(不帅、性格不好、身高矮、不上进|嫁) = p(不帅|嫁)*p(性格不好|嫁)*p(身高矮|嫁)*p(不上进|嫁),那么我就要分别统计后面几个概率,也就得到了左边的概率!

    等等,为什么这个成立呢?学过概率论的同学可能有感觉了,这个等式成立的条件需要特征之间相互独立吧!

    对的!这也就是为什么朴素贝叶斯分类有朴素一词的来源,朴素贝叶斯算法是假设各个特征之间相互独立,那么这个等式就成立了!

    但是为什么需要假设特征之间相互独立呢?

    1、我们这么想,假如没有这个假设,那么我们对右边这些概率的估计其实是不可做的,这么说,我们这个例子有4个特征,其中帅包括{帅,不帅},性格包括{不好,好,爆好},身高包括{高,矮,中},上进包括{不上进,上进},那么四个特征的联合概率分布总共是4维空间,总个数为2*3*3*2=36个。

    36个,计算机扫描统计还可以,但是现实生活中,往往有非常多的特征,每一个特征的取值也是非常之多,那么通过统计来估计后面概率的值,变得几乎不可做,这也是为什么需要假设特征之间独立的原因。

    2、假如我们没有假设特征之间相互独立,那么我们统计的时候,就需要在整个特征空间中去找,比如统计p(不帅、性格不好、身高矮、不上进|嫁),

    我们就需要在嫁的条件下,去找四种特征全满足分别是不帅,性格不好,身高矮,不上进的人的个数,这样的话,由于数据的稀疏性,很容易统计到0的情况。 这样是不合适的。

    根据上面俩个原因,朴素贝叶斯法对条件概率分布做了条件独立性的假设,由于这是一个较强的假设,朴素贝叶斯也由此得名!这一假设使得朴素贝叶斯法变得简单,但有时会牺牲一定的分类准确率。

    好的,上面我解释了为什么可以拆成分开连乘形式。那么下面我们就开始求解!

    我们将上面公式整理一下如下:

    下面我将一个一个的进行统计计算(在数据量很大的时候,根据中心极限定理,频率是等于概率的,这里只是一个例子,所以我就进行统计即可)。

    p(嫁)=?

    首先我们整理训练数据中,嫁的样本数如下:

    则 p(嫁) = 6/12(总样本数) = 1/2

    p(不帅|嫁)=?统计满足样本数如下:

    则p(不帅|嫁) = 3/6 = 1/2 在嫁的条件下,看不帅有多少

    p(性格不好|嫁)= ?统计满足样本数如下:

    则p(性格不好|嫁)= 1/6

    p(矮|嫁) = ?统计满足样本数如下:

    则p(矮|嫁) = 1/6

    p(不上进|嫁) = ?统计满足样本数如下:

    则p(不上进|嫁) = 1/6

    下面开始求分母,p(不帅),p(性格不好),p(矮),p(不上进)

    统计样本如下:

    不帅统计如上红色所示,占4个,那么p(不帅) = 4/12 = 1/3

    性格不好统计如上红色所示,占4个,那么p(性格不好) = 4/12 = 1/3

    身高矮统计如上红色所示,占7个,那么p(身高矮) = 7/12

    不上进统计如上红色所示,占4个,那么p(不上进) = 4/12 = 1/3

    到这里,要求p(不帅、性格不好、身高矮、不上进|嫁)的所需项全部求出来了,下面我带入进去即可,

    = (1/2*1/6*1/6*1/6*1/2)/(1/3*1/3*7/12*1/3)

    下面我们根据同样的方法来求p(不嫁|不帅,性格不好,身高矮,不上进),完全一样的做法,为了方便理解,我这里也走一遍帮助理解。首先公式如下:

    下面我也一个一个来进行统计计算,这里与上面公式中,分母是一样的,于是我们分母不需要重新统计计算!

    p(不嫁)=?根据统计计算如下(红色为满足条件):

    则p(不嫁)=6/12 = 1/2

    p(不帅|不嫁) = ?统计满足条件的样本如下(红色为满足条件):

    则p(不帅|不嫁) = 1/6

    p(性格不好|不嫁) = ?据统计计算如下(红色为满足条件):


    则p(性格不好|不嫁) =3/6 = 1/2

    p(矮|不嫁) = ?据统计计算如下(红色为满足条件):

    则p(矮|不嫁) = 6/6 = 1

    p(不上进|不嫁) = ?据统计计算如下(红色为满足条件):

    则p(不上进|不嫁) = 3/6 = 1/2

    那么根据公式:

    p (不嫁|不帅、性格不好、身高矮、不上进) = ((1/6*1/2*1*1/2)*1/2)/(1/3*1/3*7/12*1/3)

    很显然(1/6*1/2*1*1/2) > (1/2*1/6*1/6*1/6*1/2)

    于是有p (不嫁|不帅、性格不好、身高矮、不上进)>p (嫁|不帅、性格不好、身高矮、不上进)

    所以我们根据朴素贝叶斯算法可以给这个女生答案,是不嫁!!!!

    5  朴素贝叶斯分类的优缺点

    优点:

    (1) 算法逻辑简单,易于实现(算法思路很简单,只要使用贝叶斯公式转化医学即可!)

    (2)分类过程中时空开销小(假设特征相互独立,只会涉及到二维存储)

    缺点:

    理论上,朴素贝叶斯模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此,这是因为朴素贝叶斯模型假设属性之间相互独立,这个假设在实际应用中往往是不成立的,在属性个数比较多或者属性之间相关性较大时,分类效果不好。

    而在属性相关性较小时,朴素贝叶斯性能最为良好。对于这一点,有半朴素贝叶斯之类的算法通过考虑部分关联性适度改进。

    整个例子详细的讲解了朴素贝叶斯算法的分类过程,希望对大家的理解有帮助~

    参考:李航博士《统计学习方法》

    算法杂货铺--分类算法之朴素贝叶斯分类(Naive Bayesian classification)

    致谢:德川,皓宇,继豪,施琦

    原文地址:https://mp.weixin.qq.com/s?__biz=MzI4MDYzNzg4Mw==&mid=2247483819&idx=1&sn=7f1859c0a00248a4c658fa65f846f341&chksm=ebb4397fdcc3b06933816770b928355eb9119c4c80a1148b92a42dc3c08de5098fd6f278e61e#rd

    展开全文
  • 主要为大家详细介绍了Python实现朴素贝叶斯算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 朴素贝叶斯相关西瓜数据集,用于自然语言处理>01.朴素贝叶斯介绍 中的案例数据,该数据集仅作参考使用
  • 案例分析数据集
  • 《机器学习》算法实例-朴素贝叶斯算法-屏蔽社区留言板的侮辱言论 构建一个快速过滤器来屏蔽在线社区留言板上的侮辱性言论。如果某条留言使用了负面或者侮辱性的语言,那么就将该留言标识为内容不当。对此问题建立两...
  • 朴素贝叶斯估计 朴素贝叶斯是基于贝叶斯定理与特征条件独立分布假设的分类方法。首先根据特征条件独立的假设学习输入/输出的联合概率分布,然后基于此模型,对给定的输入x,利用贝叶斯定理求出后验概率最大的输出y。...
  • 主要为大家详细介绍了python实现基于朴素贝叶斯的垃圾分类算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 贝叶斯(Thomas Bayes,1701—1761),英国牧师、业余数学家。生活在18世纪的贝叶斯生前是位受人尊敬英格兰长老会牧师。为了证明上帝的存在,他发明了概率统计学原理,遗憾的是,他的这一美好愿望至死也未能实现。...

           贝叶斯(Thomas Bayes,1701—1761),英国牧师、业余数学家。生活在18世纪的贝叶斯生前是位受人尊敬英格兰长老会牧师。为了证明上帝的存在,他发明了概率统计学原理,遗憾的是,他的这一美好愿望至死也未能实现。贝叶斯在数学方面主要研究概率论。他首先将归纳推理法用于概率论基础理论,并创立了贝叶斯统计理论,对于统计决策函数统计推断统计的估算等做出了贡献。1763年发表了这方面的论著,对于现代概率论和数理统计都有很重要的作用。贝叶斯的另一著作《机会的学说概论》发表于1758年。贝叶斯所采用的许多术语被沿用至今。贝叶斯思想和方法对概率统计的发展产生了深远的影响。今天,贝叶斯思想和方法在许多领域都获得了广泛的应用。

    联合概率 :设 A B 是两个随机事件, A B 同时发生的概率称为联合概率,记为: P(A B)
    条件概率 :在 B 事件发生的条件下, A 事件发生的概率称为条件概率,记为: P(A|B)

    乘法定理P(A|B) = P(AB) / P(B) 

     

     

     

     

     

    展开全文
  • 朴素贝叶斯算法&应用实例

    万次阅读 2019-01-28 08:56:24
    朴素贝叶斯中的朴素是指假设各个特征之间相互独立,不会互相影响,所以称为朴素贝叶斯。正是因为这个假设,使得算法的模型简单且容易理解,虽然牺牲了一点准确性,但是如果模型训练的好,也能得到不错的分类效果。 ...

    https://www.toutiao.com/a6650068891382841859/

     

    2019-01-24 22:23:40

    朴素贝叶斯

    朴素贝叶斯中的朴素是指假设各个特征之间相互独立,不会互相影响,所以称为朴素贝叶斯。正是因为这个假设,使得算法的模型简单且容易理解,虽然牺牲了一点准确性,但是如果模型训练的好,也能得到不错的分类效果。

    朴素贝叶斯算法&应用实例

     

    公式简单推导

    下面我们简单看一下公式的推导过程

    朴素贝叶斯算法&应用实例

     

    评测指标

    我们得出分类的结果后,怎么来评测我们训练的模型的好与不好呢?我们通常「准确度」「精确率」「召回率」这几个指标来进行判断模型的好坏。下边我们用一个简单的例子来说明这几个指标是怎么计算的。

    下面我们看一个表。

    朴素贝叶斯算法&应用实例

     

    表中表示实际上科技类的文章有 40 篇,财经类的有 30 篇,然而预测的结果科技类的有 35 篇,其中 30 篇预测正确了,有 5 篇预测错误了;预测结果财经类的有 35 篇,其中 25 篇预测正确了,10 篇预测错误了。

    • 准确度

    表示预测正确的文章数比上总的文章数:(30+25)/(40+30)=78%

    • 精确率

    表示每一类预测正确的数量比上预测的该类文章总数量,比如科技类精确率:30/(30+5)=85%

    • 召回率

    表示每一类预测正确的数量比上实际该类的总数量,比如科技类:30/40=75%

    应用实例

    上边我们已经了解了朴素贝叶斯公式及推导过程,下边我们来看一下在实际的新闻分类中的应用。

    元数据的准备,我们的元数据是网上找来的一些各类的新闻,这里为了简单,我们只选取了科技、财经和体育三类数量不等的新闻,并且都已知他们的类别。然后通过中文结巴分词

    对每篇新闻进行分词。这里我们用到的是gihub上的一个开源的python库,有兴趣的可以了解一下。

    下面我们来看一下代码的具体实现。

    首先我们先把汉字的文章转成每个词所对应的数字id的形式,方便我们后边的操作和计算。

    Convert.py

    import os
    import sys
    import random
    import re
    ​
    inputPath = sys.argv[1]
    outputFile = sys.argv[2]
    #训练集所占百分比
    trainPercent = 0.8
    wordDict = {}
    wordList = []
    ​
    trainOutputFile = open('%s.train' % outputFile, "w")
    testOutputFile = open('%s.test' % outputFile, "w")
    ​
    for fileName in os.listdir(inputPath):
     tag = 0
     if fileName.find('technology') != -1:
     tag = 1
     elif fileName.find('business') != -1:
     tag = 2
     elif fileName.find('sport') != -1:
     tag = 3
    ​
     outFile = trainOutputFile
     rd = random.random()
     if rd >= trainPercent:
     outFile = testOutputFile
    ​
     inputFile = open(inputPath+'/'+fileName, "r")
     content = inputFile.read().strip()
     content = content.decode('utf-8', 'ignore')
     content = content.replace('
    ', ' ')
     r1 = u'[a-zA-Z0-9’!"#$%&'()*+,-./:;<=>?@,。?★、…【】《》?“”‘’![\]^_`{|}~]+'
     content = re.sub(r1, '', content)
     outFile.write(str(tag)+' ')
     words = content.split(' ')
     for word in words:
     if word not in wordDict:
     wordList.append(word)
     wordDict[word] = len(wordList)
    ​
     outFile.write(str(wordDict[word]) + ' ')
    ​
     inputFile.close()
    ​
    trainOutputFile.close()
    testOutputFile.close()

    朴素贝叶斯实现过程

    NB.py

    #Usage:
    #Training: NB.py 1 TrainingDataFile ModelFile
    #Testing: NB.py 0 TestDataFile ModelFile OutFile
    ​
    import sys
    import os
    import math
    ​
    ​
    DefaultFreq = 0.1
    TrainingDataFile = "nb_data.train"
    ModelFile = "nb_data.model"
    TestDataFile = "nb_data.test"
    TestOutFile = "nb_data.out"
    ClassFeaDic = {}
    ClassFreq = {}
    WordDic = {}
    ClassFeaProb = {}
    ClassDefaultProb = {}
    ClassProb = {}
    ​
    #加载数据
    def LoadData():
     i =0
     infile = open(TrainingDataFile, 'r')
     sline = infile.readline().strip()
     while len(sline) > 0:
     pos = sline.find("#")
     if pos > 0:
     sline = sline[:pos].strip()
     words = sline.split(' ')
     if len(words) < 1:
     print("Format error!")
     break
     classid = int(words[0])
     if classid not in ClassFeaDic:
     ClassFeaDic[classid] = {}
     ClassFeaProb[classid] = {}
     ClassFreq[classid] = 0
     ClassFreq[classid] += 1
     words = words[1:]
     for word in words:
     if len(word) < 1:
     continue
     wid = int(word)
     if wid not in WordDic:
     WordDic[wid] = 1
     if wid not in ClassFeaDic[classid]:
     ClassFeaDic[classid][wid] = 1
     else:
     ClassFeaDic[classid][wid] += 1
     i += 1
     sline = infile.readline().strip()
     infile.close()
     print(i, "instances loaded!")
     print(len(ClassFreq), "classes!", len(WordDic), "words!")
    ​
    #计算模型
    def ComputeModel():
     sum = 0.0
     for freq in ClassFreq.values():
     sum += freq
     for classid in ClassFreq.keys():
     ClassProb[classid] = (float)(ClassFreq[classid])/(float)(sum)
     for classid in ClassFeaDic.keys():
     sum = 0.0
     for wid in ClassFeaDic[classid].keys():
     sum += ClassFeaDic[classid][wid]
     newsum = (float)(sum + 1)
     for wid in ClassFeaDic[classid].keys():
     ClassFeaProb[classid][wid] = (float)(ClassFeaDic[classid][wid]+DefaultFreq)/newsum
     ClassDefaultProb[classid] = (float)(DefaultFreq) / newsum
     return
    ​
    #保存模型
    def SaveModel():
     outfile = open(ModelFile, 'w')
     for classid in ClassFreq.keys():
     outfile.write(str(classid))
     outfile.write(' ')
     outfile.write(str(ClassProb[classid]))
     outfile.write(' ')
     outfile.write(str(ClassDefaultProb[classid]))
     outfile.write(' ' )
     outfile.write('
    ')
     for classid in ClassFeaDic.keys():
     for wid in ClassFeaDic[classid].keys():
     outfile.write(str(wid)+' '+str(ClassFeaProb[classid][wid]))
     outfile.write(' ')
     outfile.write('
    ')
     outfile.close()
    ​
    #加载模型
    def LoadModel():
     global WordDic
     WordDic = {}
     global ClassFeaProb
     ClassFeaProb = {}
     global ClassDefaultProb
     ClassDefaultProb = {}
     global ClassProb
     ClassProb = {}
     infile = open(ModelFile, 'r')
     sline = infile.readline().strip()
     items = sline.split(' ')
     if len(items) < 6:
     print("Model format error!")
     return
     i = 0
     while i < len(items):
     classid = int(items[i])
     ClassFeaProb[classid] = {}
     i += 1
     if i >= len(items):
     print("Model format error!")
     return
     ClassProb[classid] = float(items[i])
     i += 1
     if i >= len(items):
     print("Model format error!")
     return
     ClassDefaultProb[classid] = float(items[i])
     i += 1
     for classid in ClassProb.keys():
     sline = infile.readline().strip()
     items = sline.split(' ')
     i = 0
     while i < len(items):
     wid = int(items[i])
     if wid not in WordDic:
     WordDic[wid] = 1
     i += 1
     if i >= len(items):
     print("Model format error!")
     return
     ClassFeaProb[classid][wid] = float(items[i])
     i += 1
     infile.close()
     print(len(ClassProb), "classes!", len(WordDic), "words!")
    ​
    #预测类别
    def Predict():
     global WordDic
     global ClassFeaProb
     global ClassDefaultProb
     global ClassProb
    ​
     TrueLabelList = []
     PredLabelList = []
     i =0
     infile = open(TestDataFile, 'r')
     outfile = open(TestOutFile, 'w')
     sline = infile.readline().strip()
     scoreDic = {}
     iline = 0
     while len(sline) > 0:
     iline += 1
     if iline % 10 == 0:
     print(iline," lines finished!
    ")
     pos = sline.find("#")
     if pos > 0:
     sline = sline[:pos].strip()
     words = sline.split(' ')
     if len(words) < 1:
     print("Format error!")
     break
     classid = int(words[0])
     TrueLabelList.append(classid)
     words = words[1:]
     for classid in ClassProb.keys():
     scoreDic[classid] = math.log(ClassProb[classid])
     for word in words:
     if len(word) < 1:
     continue
     wid = int(word)
     if wid not in WordDic:
     continue
     for classid in ClassProb.keys():
     if wid not in ClassFeaProb[classid]:
     scoreDic[classid] += math.log(ClassDefaultProb[classid])
     else:
     scoreDic[classid] += math.log(ClassFeaProb[classid][wid])
     i += 1
     maxProb = max(scoreDic.values())
     for classid in scoreDic.keys():
     if scoreDic[classid] == maxProb:
     PredLabelList.append(classid)
     sline = infile.readline().strip()
     infile.close()
     outfile.close()
     print(len(PredLabelList),len(TrueLabelList))
     return TrueLabelList,PredLabelList
    ​
    #计算准确度
    def Evaluate(TrueList, PredList):
     accuracy = 0
     i = 0
     while i < len(TrueList):
     if TrueList[i] == PredList[i]:
     accuracy += 1
     i += 1
     accuracy = (float)(accuracy)/(float)(len(TrueList))
     print("Accuracy:",accuracy)
    ​
    #计算精确率和召回率
    def CalPreRec(TrueList,PredList,classid):
     correctNum = 0
     allNum = 0
     predNum = 0
     i = 0
     while i < len(TrueList):
     if TrueList[i] == classid:
     allNum += 1
     if PredList[i] == TrueList[i]:
     correctNum += 1
     if PredList[i] == classid:
     predNum += 1
     i += 1
     return (float)(correctNum)/(float)(predNum),(float)(correctNum)/(float)(allNum)
    ​
    #main framework
    if sys.argv[1] == '1':
     print("start training:")
     LoadData()
     ComputeModel()
     SaveModel()
    elif sys.argv[1] == '0':
     print("start testing:")
    ​
     LoadModel()
     TList,PList = Predict()
     i = 0
     outfile = open(TestOutFile, 'w')
     while i < len(TList):
     outfile.write(str(TList[i]))
     outfile.write(' ')
     outfile.write(str(PList[i]))
     outfile.write('
    ')
     i += 1
     outfile.close()
     Evaluate(TList,PList)
     for classid in ClassProb.keys():
     pre,rec = CalPreRec(TList, PList,classid)
     print("Precision and recall for Class",classid,":",pre,rec)
    else:
     print("Usage incorrect!")
    ​
    展开全文
  • 朴素贝叶斯

    2021-03-02 10:57:44
    朴素贝叶斯
  • 本节主要介绍数据挖掘中常见的分类方法决策树和朴素贝叶斯算法。 决策树算法 决策树(Decision Tree,DT)分类法是一个简单且广泛使用的分类技术。 决策树是一个树状预测模型,它是由结点和有向边组成的层次结构。...
  • 朴素贝叶斯模型及案例(Python)

    千次阅读 2022-04-15 14:13:49
    1 朴素贝叶斯的算法原理 贝叶斯分类是机器学习中应用极为广泛的分类算法之一。 朴素贝叶斯是贝叶斯模型当中最简单的一种,其算法核心为如下所示的贝叶斯公式。 其中P(A)为事件A发生的概率,P(B)为事件B...
  • 朴素贝叶斯算法 — 超详细公式讲解+代码实例

    万次阅读 多人点赞 2020-08-19 21:56:58
    朴素贝叶斯法是基于贝叶斯定理与特征条件独立性假设的分类方法。对于给定的训练集,首先基于特征条件独立假设学习输入输出的联合概率分布(朴素贝叶斯法这种通过学习得到模型的机制,显然属于生成模型);然后基于此...
  • 朴素贝叶斯分类器 C++ 具有 TF/IDF 平滑的基于文本的朴素贝叶斯分类器 设计决策: 我的设计如下。 首先,我为每个类别实例化了 4 个 <string> 映射,以跟踪 training.txt 中的单词和单词计数。 我还实例化了 4 个 ...
  • 用于朴素贝叶斯案例数据集,包括停用词和训练集
  • 主要介绍了Python实现的朴素贝叶斯分类器,结合具体实例形式分析了基于Python实现的朴素贝叶斯分类器相关定义与使用技巧,需要的朋友可以参考下
  • sklearn应用朴素贝叶斯算法 通过两节知识的学习,相信你对朴素贝叶斯算法有了初步的掌握,本节将实际应用朴素贝叶斯算法,从实战中体会算法的精妙之处。 首先看下面一个简单应用案例: 简单应用案例 假设一个学校有 ...
  • 文章目录机器学习应用篇(一)——朴素贝叶斯1、鸢尾花案例2、小结 朴素贝叶斯(Naive Bayes,NB):朴素贝叶斯分类算法是学习效率和分类效果较好的分类器之一。朴素贝叶斯算法一般应用在文本分类,垃圾邮件的分类,...
  • 本文实例讲述了Python实现的朴素贝叶斯算法。分享给大家供大家参考,具体如下: 代码主要参考机器学习实战那本书,发现最近老外的书确实比中国人写的好,由浅入深,代码通俗易懂,不多说上代码: #encoding:utf-8 '...
  • 该算法用Python实现了朴素贝叶斯分类器,并用于文本分类,实现垃圾邮件的检测。
  • (一)贝叶斯原理中的几个概念 先验概率 通过经验来判断事情发生的概率,比如说某一种疾病的发病率是万分之一,就是先验概率。再比如南方的梅雨季是 6-7 月,就是通过往年的气候总结出来的经验,这个时候下雨的...
  • 最后,我们通过实例来讨论贝叶斯分类的中最简单的一种: 朴素贝叶斯分类。 2. 贝叶斯理论 & 条件概率 2.1 贝叶斯理论 我们现在有一个数据集,它由两类数据组成,数据分布如下图所示: 我们现在用 p1(x,y) 表示数据点...
  • 朴素贝叶斯学习实例【机器学习】

    千次阅读 2022-03-17 16:27:19
    朴素贝叶斯学习实例【机器学习】 文章目录朴素贝叶斯学习实例【机器学习】一、题目要求二、数据预处理1.数据替换2.OneHotEncoder的使用三、实验代码1.包的导入2.读入数据3.贝叶斯分类四、总结 一、题目要求 请编写...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,542
精华内容 6,616
关键字:

朴素贝叶斯应用实例