精华内容
下载资源
问答
  • 在sklearn中,提供了若干种朴素贝叶斯的实现算法,不同的朴素贝叶斯算法,主要是对P(xi|y)的分布假设不同,进而采用不同的参数估计方式。我们能够发现,朴素贝叶斯算法,主要就是计算P(xi|y),一旦P(xi|y)确定,最终...

    在sklearn中,提供了若干种朴素贝叶斯的实现算法,不同的朴素贝叶斯算法,主要是对P(xi|y)的分布假设不同,进而采用不同的参数估计方式。我们能够发现,朴素贝叶斯算法,主要就是计算P(xi|y),一旦P(xi|y)确定,最终属于每个类别的概率,自然也就迎刃而解了。
    常用的三种朴素贝叶斯为:

    • 高斯朴素贝叶斯
    • 伯努利朴素贝叶斯
    • 多项式朴素贝叶斯

    高斯朴素贝叶斯

    适用于连续变量,其假定各个特征xi在各个类别y下是服从正态分布的,算法内部使用正态分布的概率密度函数来计算概率如下:
    在这里插入图片描述
    在这里插入图片描述

    import numpy as np
    import pandas as pd
    from sklearn.naive_bayes import GaussianNB
    
    np.random.seed(0)
    x = np.random.randint(0,10,size=(6,2))
    y = np.array([0,0,0,1,1,1])
    data = pd.DataFrame(np.concatenate([x, y.reshape(-1,1)], axis=1), columns=['x1','x2','y'])
    display(data)
    
    gnb = GaussianNB()
    gnb.fit(x,y)
    #每个类别的先验概率
    print('概率:', gnb.class_prior_)
    #每个类别样本的数量
    print('样本数量:', gnb.class_count_)
    #每个类别的标签
    print('标签:', gnb.classes_)
    #每个特征在每个类别下的均值
    print('均值:',gnb.theta_)
    #每个特征在每个类别下的方差
    print('方差:',gnb.sigma_)
    
    #测试集
    x_test = np.array([[6,3]])
    print('预测结果:', gnb.predict(x_test))
    print('预测结果概率:', gnb.predict_proba(x_test))
    

    在这里插入图片描述

    伯努利朴素贝叶斯

    设试验E只有两个可能的结果:A与A¯,则称为E为伯努利试验
    伯努利朴素贝叶斯,适用于离散变量,其假设各个特征xi在各个类别y下是服从n重伯努利分布(二项分布)的,因为伯努利试验仅有两个结果,因此,算法会首先对特征值进行二值化处理(假设二值化的结果为1与0)。
    计算方式如下:
    在这里插入图片描述
    在训练集中,会进行如下的估计:
    在这里插入图片描述
    在这里插入图片描述

    from sklearn.naive_bayes import BernoulliNB
    
    np.random.seed(0)
    x = np.random.randint(-5,5,size=(6,2))
    y = np.array([0,0,0,1,1,1])
    data = pd.DataFrame(np.concatenate([x,y.reshape(-1,1)], axis=1), columns=['x1','x2','y'])
    display(data)
    
    bnb = BernoulliNB()
    bnb.fit(x,y)
    #每个特征在每个类别下发生(出现)的次数。因为伯努利分布只有两个值。
    #我们只需要计算出现的概率P(x=1|y),不出现的概率P(x=0|y)使用1减去P(x=1|y)即可。
    print('数值1出现次数:', bnb.feature_count_)
    #每个类别样本所占的比重,即P(y)。注意该值为概率取对数之后的结果,
    #如果需要查看原有的概率,需要使用指数还原。
    print('类别占比p(y):',np.exp(bnb.class_log_prior_))
    #每个类别下,每个特征(值为1)所占的比例(概率),即p(x|y)
    #该值为概率取对数之后的结果,如果需要查看原有的概率,需要使用指数还原
    print('特征概率:',np.exp(bnb.feature_log_prob_))
    

    在这里插入图片描述

    多项式朴素贝叶斯

    多项式朴素贝叶斯,适用于离散变量,其假设各个特征xi在各个类别y下是服从多项式分布的,故每个特征值不能是负数。
    计算如下:
    在这里插入图片描述

    from sklearn.naive_bayes import MultinomialNB
    
    np.random.seed(0)
    x = np.random.randint(0,4,size=(6,2))
    y = np.array([0,0,0,1,1,1])
    data = pd.DataFrame(np.concatenate([x,y.reshape(-1,1)], axis=1), columns=['x1','x2','y'])
    display(data)
    
    mnb = MultinomialNB()
    mnb.fit(x,y)
    #每个类别的样本数量
    print(mnb.class_count_)
    #每个特征在每个类别下发生(出现)的次数
    print(mnb.feature_count_)
    #每个类别下,每个特征所占的比例(概率),即P(x|y)
    #该值为概率取对数之后的结果,如果需要查看原有的概率,需要使用指数还原
    print(np.exp(mnb.feature_log_prob_))
    

    在这里插入图片描述

    展开全文
  • 朴素贝叶斯优点:在数据较少的情况下仍然有效,可以处理多类别问题缺点:对于输入数据的准备方式较为敏感适用数据类型:标称型数据贝叶斯准则:使用朴素贝叶斯进行文档分类朴素贝叶斯的一般过程(1)收集数据:可以...

    朴素贝叶斯

    优点:在数据较少的情况下仍然有效,可以处理多类别问题

    缺点:对于输入数据的准备方式较为敏感

    适用数据类型:标称型数据

    贝叶斯准则:

    使用朴素贝叶斯进行文档分类

    朴素贝叶斯的一般过程

    (

    1

    )收集数据:可以使用任何方法。本文使用

    RSS

    (

    2

    )准备数据:需要数值型或者布尔型数据

    (

    3

    )分析数据:有大量特征时,绘制特征作用不大,此时使用直方图效果更好

    (

    4

    )训练算法:计算不同的独立特征的条件概率

    (

    5

    )测试算法:计算错误率

    (

    6

    )使用算法:一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴

    素贝叶斯分类器,不一定非要是文本。

    准备数据:从文本中构建词向量

    摘自机器学习实战。

    [['my','dog','has','flea','problems','help','please'],

    0

    ['maybe','not','take','him','to','dog','park','stupid'],

    1

    ['my','dalmation','is','so','cute','I','love','him'],

    0

    展开全文
  • 朴素贝叶斯

    2018-08-04 11:13:24
    朴素贝叶斯适用于分类任务,思想简单,用统计的结果充当先验概率,并以此来估计后验概率。   #!/usr/bin/python # coding=utf-8 from numpy import * # 过滤网站的恶意留言 侮辱性:1 非侮辱性:0 # 创建...

    这也是在概率论课上做的实验报告,因为整理成文档比较麻烦,就直接上PPT了。

    朴素贝叶斯适用于分类任务,思想简单,用统计的结果充当先验概率,并以此来估计后验概率。

     

    #!/usr/bin/python
    # coding=utf-8
    from numpy import *
    
    # 过滤网站的恶意留言  侮辱性:1     非侮辱性:0
    # 创建一个实验样本
    def loadDataSet():
        postingList = [['my','dog','has','flea','problems','help','please'],
                       ['maybe','not','take','him','to','dog','park','stupid'],
                       ['my','dalmation','is','so','cute','I','love','him'],
                       ['stop','posting','stupid','worthless','garbage'],
                       ['mr','licks','ate','my','steak','how','to','stop','him'],
                       ['quit','buying','worthless','dog','food','stupid']]
        classVec = [0,1,0,1,0,1]
        return postingList, classVec
    
    # 创建一个包含在所有文档中出现的不重复词的列表
    def createVocabList(dataSet):
        vocabSet = set([])      # 创建一个空集
        for document in dataSet:
            vocabSet = vocabSet | set(document)   # 创建两个集合的并集
        return list(vocabSet)
    
    # 将文档词条转换成词向量
    def setOfWords2Vec(vocabList, inputSet):
        returnVec = [0]*len(vocabList)        # 创建一个其中所含元素都为0的向量
        for word in inputSet:
            if word in vocabList:
                # returnVec[vocabList.index(word)] = 1     # index函数在字符串里找到字符第一次出现的位置  词集模型
                returnVec[vocabList.index(word)] += 1      # 文档的词袋模型    每个单词可以出现多次
            else: print "the word: %s is not in my Vocabulary!" % word
        return returnVec
    
    # 朴素贝叶斯分类器训练函数   从词向量计算概率
    def trainNB0(trainMatrix, trainCategory):
        numTrainDocs = len(trainMatrix)
        numWords = len(trainMatrix[0])
        pAbusive = sum(trainCategory)/float(numTrainDocs)#先验概率  某类别的邮件总数/总邮件数
        # p0Num = zeros(numWords); p1Num = zeros(numWords)
        # p0Denom = 0.0; p1Denom = 0.0
        p0Num = ones(numWords);   # 避免一个概率值为0,最后的乘积也为0
        p1Num = ones(numWords);   # 用来统计两类数据中,各词的词频
        p0Denom = 2.0;  # 用于统计0类中的总数
        p1Denom = 2.0  # 用于统计1类中的总数
        for i in range(numTrainDocs):
            if trainCategory[i] == 1:
                p1Num += trainMatrix[i] #在类1中所有邮件中词出现的总数
                p1Denom += sum(trainMatrix[i])
            else:
                p0Num += trainMatrix[i]
                p0Denom += sum(trainMatrix[i])
                # p1Vect = p1Num / p1Denom
                # p0Vect = p0Num / p0Denom
        p1Vect = log(p1Num / p1Denom)    # 在类1中,每个词的发生概率=在类1中所有邮件中词出现的总数/类1 邮件中词的总个数
        p0Vect = log(p0Num / p0Denom)      # 避免下溢出或者浮点数舍入导致的错误   下溢出是由太多很小的数相乘得到的
        return p0Vect, p1Vect, pAbusive
    
    # 朴素贝叶斯分类器
    def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
        p1 = sum(vec2Classify*p1Vec) + log(pClass1)
        p0 = sum(vec2Classify*p0Vec) + log(1.0-pClass1)
        if p1 > p0:
            return 1
        else:
            return 0
    
    def testingNB():
        listOPosts, listClasses = loadDataSet()
        myVocabList = createVocabList(listOPosts)
        trainMat = []
        for postinDoc in listOPosts:
            trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
        p0V, p1V, pAb = trainNB0(array(trainMat), array(listClasses))
        testEntry = ['love','my','dalmation']
        thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
        print testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)
        testEntry = ['stupid','garbage']
        thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
        print testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)
    
    # 调用测试方法----------------------------------------------------------------------
    testingNB()

     

    实验结果:

    对于朴素贝叶斯的改进点:

    1 用bag of words 而不是 one-hot

    2 对于0概率事件采用平滑算法

    3 用log处理概率 ,把乘法转化成加法,避免下溢出

    4 将文本进行切分,防止垃圾邮件的关键词在全文中的密度被稀释。

    5 位置权重 

     

    贝叶斯的常见应用:

    1 褒贬分析 (情感分析)

        1.1通过爬虫对评论进行收集、抓取

        1.2用训练好的朴素贝叶斯分类器对评论进行分别判断

        1.3然后统计比例,得到大致估计。

       难点:1中文的本身难度(双重否定、副词的位置【很不喜欢  不很喜欢】、情感表达的含蓄、转折性表达之类的)

    2 拼写纠错

     

     

    展开全文
  • # 朴素贝叶斯算法的python实现算法优缺点优点:在数据较少的情况下依然有效,可以处理多类别问题缺点:对输入数据的准备方式敏感适用数据类型:标称型数据算法思想:朴素贝叶斯比如我们想判断一个邮件是不是垃圾邮件...

    # 朴素贝叶斯算法的python实现

    算法优缺点

    优点:在数据较少的情况下依然有效,可以处理多类别问题

    缺点:对输入数据的准备方式敏感

    适用数据类型:标称型数据

    算法思想:

    朴素贝叶斯

    比如我们想判断一个邮件是不是垃圾邮件,那么我们知道的是这个邮件中的词的分布,那么我们还要知道:垃圾邮件中某些词的出现是多少,就可以利用贝叶斯定理得到。

    朴素贝叶斯分类器中的一个假设是:每个特征同等重要

    贝叶斯分类是一类分类算法的总称,这类算法均以贝叶斯定理为基础,故统称为贝叶斯分类。

    函数

    loadDataSet()

    创建数据集,这里的数据集是已经拆分好的单词组成的句子,表示的是某论坛的用户评论,标签1表示这个是骂人的

    createVocabList(dataSet)

    找出这些句子中总共有多少单词,以确定我们词向量的大小

    setOfWords2Vec(vocabList, inputSet)

    将句子根据其中的单词转成向量,这里用的是伯努利模型,即只考虑这个单词是否存在

    bagOfWords2VecMN(vocabList, inputSet)

    这个是将句子转成向量的另一种模型,多项式模型,考虑某个词的出现次数

    trainNB0(trainMatrix,trainCatergory)

    计算P(i)和P(w[i]|C[1])和P(w[i]|C[0]),这里有两个技巧,一个是开始的分子分母没有全部初始化为0是为了防止其中一个的概率为0导致整体

    为0,另一个是后面乘用对数防止因为精度问题结果为0

    classifyNB(vec2Classify, p0Vec, p1Vec, pClass1)

    根据贝叶斯公式计算这个向量属于两个集合中哪个的概率高

    #coding=utf-8

    fromnumpyimport*

    defloadDataSet():

    postingList=[['my','dog','has','flea','problems','help','please'],

    ['maybe','not','take','him','to','dog','park','stupid'],

    ['my','dalmation','is','so','cute','I','love','him'],

    ['stop','posting','stupid','worthless','garbage'],

    ['mr','licks','ate','my','steak','how','to','stop','him'],

    ['quit','buying','worthless','dog','food','stupid']]

    classVec=[0,1,0,1,0,1]#1 is abusive, 0 not

    returnpostingList,classVec

    #创建一个带有所有单词的列表

    defcreateVocabList(dataSet):

    vocabSet=set([])

    fordocumentindataSet:

    vocabSet=vocabSet|set(document)

    returnlist(vocabSet)

    defsetOfWords2Vec(vocabList,inputSet):

    retVocabList=[0]*len(vocabList)

    forwordininputSet:

    ifwordinvocabList:

    retVocabList[vocabList.index(word)]=1

    else:

    print'word ',word,'not in dict'

    returnretVocabList

    #另一种模型

    defbagOfWords2VecMN(vocabList,inputSet):

    returnVec=[0]*len(vocabList)

    forwordininputSet:

    ifwordinvocabList:

    returnVec[vocabList.index(word)]+=1

    returnreturnVec

    deftrainNB0(trainMatrix,trainCatergory):

    numTrainDoc=len(trainMatrix)

    numWords=len(trainMatrix[0])

    pAbusive=sum(trainCatergory)/float(numTrainDoc)

    #防止多个概率的成绩当中的一个为0

    p0Num=ones(numWords)

    p1Num=ones(numWords)

    p0Denom=2.0

    p1Denom=2.0

    foriinrange(numTrainDoc):

    iftrainCatergory[i]==1:

    p1Num+=trainMatrix[i]

    p1Denom+=sum(trainMatrix[i])

    else:

    p0Num+=trainMatrix[i]

    p0Denom+=sum(trainMatrix[i])

    p1Vect=log(p1Num/p1Denom)#处于精度的考虑,否则很可能到限归零

    p0Vect=log(p0Num/p0Denom)

    returnp0Vect,p1Vect,pAbusive

    defclassifyNB(vec2Classify,p0Vec,p1Vec,pClass1):

    p1=sum(vec2Classify*p1Vec)+log(pClass1)#element-wise mult

    p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)

    ifp1>p0:

    return1

    else:

    return0

    deftestingNB():

    listOPosts,listClasses=loadDataSet()

    myVocabList=createVocabList(listOPosts)

    trainMat=[]

    forpostinDocinlistOPosts:

    trainMat.append(setOfWords2Vec(myVocabList,postinDoc))

    p0V,p1V,pAb=trainNB0(array(trainMat),array(listClasses))

    testEntry=['love','my','dalmation']

    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))

    printtestEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)

    testEntry=['stupid','garbage']

    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))

    printtestEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)

    defmain():

    testingNB()

    if__name__=='__main__':

    main()

    展开全文
  • 朴素贝叶斯面试总结

    千次阅读 2018-03-06 22:51:12
    1. 朴素贝叶斯与LR的区别?简单来说:朴素贝叶斯是生成模型,根据已有样本进行贝叶斯估计学习出先验概率P(Y)和条件概率P(X|Y),进而求出联合分布概率P(XY),最后利用贝叶斯定理求解P(Y|X), 而LR是...朴素贝叶斯适用...
  • 具体实现方法如下:朴素贝叶斯算法优缺点优点:在数据较少的情况下依然有效,可以处理多类别问题缺点:对输入数据的准备方式敏感适用数据类型:标称型数据算法思想:比如我们想判断一个邮件是不是垃圾邮件,那么我们...
  • Naive Bayes 朴素贝叶斯算法,是应用最为广泛的...朴素贝叶斯算法的核心就是贝叶斯公式,贝叶斯公式为我们提供了一个适用于计算一些数据属于某一类别的概率的计算方法。贝叶斯公式如下:其中,表示属于某个的概率...
  • 朴素贝叶斯算法优点:算法原理和实现简单,常用于文本分类。对小规模数据表现很好,适合多分类增量式训练任务。对缺失数据不太敏感。缺点:对输入数据的表达形式很敏感需要计算先验概率,分类决策存在错误率要求样本...
  • 朴素贝叶斯模型是一组非常简单快速的分类算法,通常适用于维度非常高的数据集。因为运行速度快,而且可调参数少,因此非常适合为分类问题提供快速粗糙的基本方案。本节重点介绍朴素贝叶斯分类器(naiveBayes ...
  • 朴素贝叶斯优点:在数据较少的情况下仍然有效,可以处理多类别问题缺点:对于输入数据的准备方式较为敏感适用数据类型:标称型数据?贝叶斯准则:使用朴素贝叶斯进行文档分类?朴素贝叶斯的一般过程(1)收集数据:可以...
  • 具体实现方法如下:朴素贝叶斯算法优缺点优点:在数据较少的情况下依然有效,可以处理多类别问题缺点:对输入数据的准备方式敏感适用数据类型:标称型数据算法思想:比如我们想判断一个邮件是不是垃圾邮件,那么我们...
  • 朴素贝叶斯(Naive Bayesian Mode,NBM)贝叶斯由来贝叶斯是由英国学者托马斯·贝叶斯 提出的一种纳推理的理论,后来发展为一种系统的统计推断方法。被称为贝叶斯方法。朴素贝叶斯朴素贝叶斯法是基于贝叶斯定理与特征...
  • 朴素贝叶斯优点:在数据较少的情况下仍然有效,可以处理多类别问题缺点:对于输入数据的准备方式较为敏感适用数据类型:标称型数据贝叶斯准则:使用朴素贝叶斯进行文档分类朴素贝叶斯的一般过程(1)收集数据:可以...
  • 朴素贝叶斯简介

    2019-11-26 14:05:09
    朴素贝叶斯是一种速度很快的分类算法,适用于数据特征维度很高的情况。它假设数据的特征之间相互独立,这也是“朴素”这一名称的由来,其数学基础是贝叶斯定理。 根据每个特征的数据分布的假设不同,有高斯朴素...
  • 朴素贝叶斯算法是一种有监督学习算法,用于解决分类问题。 “朴素”是因为整个形式化过程只做最原始、最简单的假设。 朴素贝叶斯的优缺点: 优点: – 在数据较少的情况下仍然有效,可以处理多类别问题。 – ...
  • 贝努利朴素贝叶斯适合于二项式分布的数据集,高斯朴素贝叶斯适用于任何连续数值型的数据集,多项式朴素贝叶斯适合非负、离散数值的数据集。使用的类为sklearn.naive_bayes.BernoulliNB,GaussianNB,MultinomialNB。
  • 回顾上两篇文章,我们讲述了线性回归和逻辑回归和决策树今天我们来看一下另外一个非常常用的算法:朴素贝叶斯算法“朴素贝叶斯是一种常用的分类算法,适用于维度非常高的数据集,具有速度快,可调参数少有点,非常...
  • 朴素贝叶斯算法

    2018-08-21 09:23:13
    朴素贝叶斯算法实例,python3可运行,每行代码均有详细解释,适用初学贝叶斯者.
  • 算法优缺点优点:在数据较少的情况下依然有效,可以处理多类别问题缺点:对输入数据的准备方式敏感适用数据类型:标称型数据算法思想:朴素贝叶斯比如我们想判断一个邮件是不是垃圾邮件,那么我们知道的是这个邮件中...
  • 在本文中,我将讨论高斯朴素贝叶斯:算法,其实现和应用于微型维基百科数据集(维基百科中给出的数据集)。算法:高斯朴素贝叶斯算法是一种概率算法。它涉及到对数据集中的类和给定类的测试数据分别进行先验概率和后验...
  • 朴素贝叶斯模型是一组非常简单快速的分类算法,通常适用于维度非常高的数据集。因为运行速度快,而且可调参数少,因此非常适合为分类问题提供快速粗糙的基本方案。1贝叶斯分类朴素贝叶斯分类器建立在贝叶斯分类方法...
  • 朴素贝叶斯 适用问题:多类分类 模型类型:生成模型 模型特点:特征与类别的联合概率分布,条件独立假设。 学习策略:极大似然估计,极大后验概率估计或者损失函数为目标函数的最小化 学习的试试函数:对数似然损失 ...
  • 这次的朴素贝叶斯适用于文本分类的检测,所以说明一下本程序的输入输入吧~ skf是由交叉验证得到的 from sklearn.cross_validation import StratifiedKFold 这个sklearn里提供了交叉验证的方法 为啥要
  • sklearn——朴素贝叶斯

    千次阅读 2018-08-08 12:34:52
    以下文章为一位博主翻译自某篇官方文档,在此引用: 在scikit-learn中,提供...高斯朴素贝叶斯适用于连续型数值,比如身高在160cm以下为一类,160-170cm为一个类,则划分不够细腻。 多项式朴素贝叶斯:常用于文...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 400
精华内容 160
关键字:

朴素贝叶斯适用