朴素贝叶斯分类是一种十分简单的分类算法，它的核心思想就是：求解某样本在此特征组合情况下属于各个类别的概率，哪个类别对应的概率最大，就猜测属于该类别。举个例子，当你看到今天的温度，湿度和空气状况，判断今天属于春天还是冬天；假如你在北京，今天气温5度，干燥，轻度雾霾，那么你就很可能觉得今天应该是冬天了；就是根据一组特征值来判断属于哪种类别的概率大。
 
其数学定义如下：
 
  假设类别集合为$C=\{c_1, c_2, ... ,c_n\}$，特征集合为$A = \{A_1, A_2,...,A_n\}$。在某一组特征值为$\{a_1, a_2,...,a_n\}$的情况下，求解属于某类别$c_i$的概率，这其实是一个条件概率，该概率为: 
 
 $$p(c_i|a_1,a_2,...,a_n)$$  

 在实际应用中，直接求解这个值可能有些不现实，我们可以根据贝叶斯定理进行变换一下: 

 

 $$p(c_i|a_1,a_2,...,a_n)=\frac{p(c_i)*p(a_1,a_2,...,a_n|c_i)}{p(a_1,a_2,...,a_n)}$$  

 用朴素的语言可以表达为： 

 

 $$posterior(后验概率)=\frac{prior(先验概率)*likelihoor(似然概率)}{evidence(边际概率)}$$  

 实际中，我们只关心分子部分，因为分母不依赖于类别

$C$而且特征$\{a_1,a_2,...a_n\}$的值是给定的，于是分母可以认为是一个常数。这样求解重点就等价于

$p(c_i)\;p(c_i| a1,...,an)$,重复使用链式法则，可将该式写成条件概率的形式，如下所示： 

 

$p(c_i)\;p(c_i| a1,...,an)$ 

 

$=p(c_i)\;p(c_i| a1)\;p(a_2,a_3,...,a_n|c_i,a_1)$ 

 

$=p(c_i)\;p(c_i| a1)\;p(a_2|c_i,a_1)\;p(a_3,...,a_n|c_i,a_1,a_2)$ 

 

$=p(c_i)\;p(c_i| a1)\;p(a_2|c_i,a_1)\;p(a_3|c,a_1,a_2)\;...p(a_n|c_i,a_1,...,a_{n-1})$
 
由于朴素贝叶斯假设各特征之间是相互独立的，则有： 
 
 $$p(a_i|C,a_j)=p(a_i|C)$$  

 所以有: 

 

 $$p(c_i)\;p(c_i| a1,...,an)=p(c_i)\;p(a_1|c_i)...p(a_n|c_i)$$  

 

 $$=p(c_i)\prod_{k=1}^np(a_k|c_i)$$  

 而

$p(c_i)$我们一般用类别

$i$的样本数量除以总样本数量来估计，即： 

 $$p(c_i)=\frac{D(i):类别i样本数量}{D:总的样本数量}$$  

 而对于

$p(a_k|c_i)$，只需要找出所有的类别为i的样本中，第k个属性中，取值为

$a_k$的比例。
 
  这样便可以算出每种类别对应的$p(c_i|a_1,a_2,...,a_n)$值，而这个p值较大的类就是该特征值对有可能所属的类别。
 
离散型举例
 
下图是一个例子：根据天气状况决定要不要去打球： 
 
 
现在假设有一个新的样本，$\{sunny,cool,high,true\}$ 
 我们可以求解两类分别对应的概率$p(play=yes|sunny,cool,high,true)$和$p(play=no|sunny,cool,high,true)$，假设前者为$p_y$后者为$p_n$，根据前面的: 
 
 $$p(c_i|a_1,a_2,...,a_n)=\frac{p(c_i)*p(a_1,a_2,...,a_n|c_i)}{p(a_1,a_2,...,a_n)}$$  

 由于分母都相同，可以不同考虑，仅仅去比较分子的大小。所以转化为计算分子部分，求解分子部分公式为： 

 

 $$p(c_i)\;p(c_i| a1,...,an)=p(c_i)\prod_{k=1}^np(a_k|c_i)$$  

 则有： 

 

$p_y=p(yes)*p(sunny|yes)*p(cool|yes)*p(high|yes)*p(true|yes)$
 
$p_n=p(no)*p(sunny|no)*p(cool|no)*p(high|no)*p(true|no)$
 
而$p(yes) =\frac{9}{14}$ ，即训练样本中，类型为$yes$所占的比例。同理，$p(yes) =\frac{5}{14}$，二者都是先验概率。 
 而$p(sunny|yes)=\frac{2}{9}$，即所有为$yes$类的样本中，天气为$sunny$所占的比例；同理$p(sunny|no)=\frac{3}{5}$。其他的类似求解，最后解得:$p(cool|yes)=\frac{1}{3},p(cool|no)=\frac{1}{5};p(high|yes)=\frac{1}{3},p(high|no)=\frac{4}{5};p(true|yes)=\frac{1}{3},p(true|no)=\frac{3}{5};$。所以带入可以得: 
 
 $$p_y=0.2;p_n=0.8$$  

 此时

$p_n>p_y$，所以，不会出去打球。
 
连续型举例:
 
  对于连续型的情况，数学推导过程都差不多，但是在计算各种概率时不能仅仅用样本比例来求解，试想一下，测试样本中特征的取值可能压根就没有在已知样本中出现，这时候需要预测一下特征的分布情况（如果分布未知，一般用高斯分布，高斯分布其实就是正态分布，只是叫法不一样）。
 
  而我们需要用已知的样本数据来求解分布的未知参数（例如高斯分布模型中的参数的均值和方差），得到分布的参数之后，就可以根据输入的值来得到相应的概率。
 
下面是一个连续性的例子:
 
  根据身高，体重和脚的尺寸来猜测性别。样本数据如下图所示:
 
 
现在我们有一个测试样本，$\{6, 130,8\}$，我们需要判断这个样本的性别。同样，我们仅仅计算分子，分母不考虑，因为是一样的。 
 首先求解先验概率： 
   $p(男)=0.5,p(女)=0.5$
 
然后计算似然概率: 
 以身高为例，男性身高的高斯分布为: 
 
 $$p(height|男)=\frac{1}{ \sqrt{2\pi\sigma^2}}exp\left( \frac{-(x-\mu)^2}{2\sigma^2}\right)$$  

 其中

$\{\mu=5.855,\sigma^2=3.6033e^{-02}\}$，将

$x=6$带入，可以得到

$p(height=6|男)=1.5789$,同理可以计算得: 

 

$p(weight=130|男)=5.9881e^{-06},p(footsize=8|男)=1.3112e^{-3}$ 

 

$p(height=6|女)=2.2346e^{-1},p(weight=130|女)=1.6789e^{-2},p(footsize=8|女)=2.8669e^{-04}$
 
最终带入公式可以得: 
 
 $$\{p_{male}=6.1984e^{-09},p_{female}=5.3778e^{-04}\}$$  

 显然为女性的概率更大，所以猜测是女性。

简介
         贝叶斯定理用Thomas Bayes的名字命名。早在18世纪，英国学者贝叶斯提出计算条件概率的公式用来解决如下问题：
 
         假设B[1]、B[2]…B[n]互斥并且构成一个完备事件组，已知他们的概率P(B[i]),i=1,2,...,n,已知某一事件A与B相伴随机出现，并且已知条件概率P(A|B[i])的概率，求条件概率p(B[i]|A)
 
         贝叶斯定理具体形式为：
 
                                              
 
其中P(A|B)是在 B 发生的情况下 A 发生的可能性。P(B|A)是在A发生的情况下B发生的概率可能性。
 
         P(A)是 A 的先验概率，之所以称为“先验”是因为它不考虑任何 B 方面的因素。P(A|B)是已知 B 发生后 A 的条件概率，也由于得自 B 的取值而被称作 A 的后验概率。P(B|A)是已知 A 发生后 B 的条件概率，也由于得自 A 的取值而被称作 B 的后验概率。P(B)是 B 的先验概率，也作标淮化常量（normalizing constant）。后验概率 = (相似度 * 先验概率)/标淮化常量，既是P(A|B) =P(AB)/P(B)，比例P(B|A)/P(B)也有时被称作标淮相似度（standardised likelihood），Bayes定理可表述为：后验概率 = 标淮相似度 * 先验概率        
 
朴素贝叶斯
在数据挖掘中，朴素贝叶斯是一个比较经典的算法，给定训练数据集A,类别B，其中A
 
的属性列为Ai,i=1,2,…,n;B={B1,B2,…,Bn};贝叶斯算法核心思想是给定待判定数据元组，根据训练数据集进行分类预测，通过贝叶斯定理计算当前待判定元组属于某一类别的概率，概率最大者即为该待判定元组的类别归属。
 
         所谓的朴素贝叶斯是指在给定训练集数据元组中，每一个属性列之间是独立的，相互之间互不影响，A1,A2,…,An之间互相独立：
 
         通过贝叶斯公式计算后验概率：
 
                                                      
 
此公式是表名给定元组数据A，其在A的条件下属于类别Bj的概率，由于A的每一列之间相互独立的，互不影响，因此
 
                                                     
 
         在求出之后，因为P(A)对每一个类别都相同，因此可通过对的数值进行比较，因此就有：得出概率最大的即为相应的预测类别。
 
     在进行贝叶斯算法应用时候由于数据量较大而且较为复杂，因此经常会遇见概率为0的值，那么概率为0的值怎么办呐？有一个简单的技巧来避免该问题，可以假定训练数据库D很大，以至于对每个计数加1造成的估计概率的变化忽略不计，但可以方便的避免概率值为0.这种概率估计技术成为拉普拉斯校准或者拉普拉斯估计法。对元组中每一列属性的不重复的数据项计数加1,并且在分母计算上也加1，这样可以有效地避免概率为0的问题。
 
同时在运用python进行计算概率时候，我们可以通过取对数进行相应的计算，因为数据量过大的话会造成某项概率过小，但是我们按照数学的方法，y=x是单调递增，那么y=lnx也
 
是单调递增的这个思想，即x1>x2 那么lnx1>lnx2；通过对数之间的公式运算,如
 
                                                        
 
                                                        
 
                                                       
 
朴素贝叶斯的python实现 
# -*- coding: utf-8 -*-

from numpy import *
from functools import reduce

# 广告、垃圾标识
adClass = 1


def loadDataSet():
    """加载数据集合及其对应的分类"""
    wordsList = [['周六', '公司', '一起', '聚餐', '时间'],
                 ['优惠', '返利', '打折', '优惠', '金融', '理财'],
                 ['喜欢', '机器学习', '一起', '研究', '欢迎', '贝叶斯', '算法', '公式'],
                 ['公司', '发票', '税点', '优惠', '增值税', '打折'],
                 ['北京', '今天', '雾霾', '不宜', '外出', '时间', '在家', '讨论', '学习'],
                 ['招聘', '兼职', '日薪', '保险', '返利']]
    # 1 是, 0 否
    classVec = [0, 1, 0, 1, 0, 1]
    return wordsList, classVec


# python中的& | 是位运算符   and or是逻辑运算符 当and的运算结果为true时候返回的并不是true而是运算结果最后一位变量的值
# 当and返回的结果是false时候，如果A AND B 返回的是第一个false的值，如果a为false 则返回a，如果a不是false，那么返回b
# 如果a or b 为true时候，返回的是第一个真的变量的值，如果a,b都为真时候那么返回a 如果a为假b为真那么返回b
# a & b a和b为两个set,返回结果取a和b的交集  a|b a和b为两个set,返回结果为两个集合的不重复并集
def doc2VecList(docList):
    # 从第一个和第二个集合开始进行并集操作，最后返回一个不重复的并集
    a = list(reduce(lambda x, y: set(x) | set(y), docList))
    return a


def words2Vec(vecList, inputWords):
    """把单子转化为词向量"""
    # 转化成以一维数组
    resultVec = [0] * len(vecList)
    for word in inputWords:
        if word in vecList:
            # 在单词出现的位置上的计数加1
            resultVec[vecList.index(word)] += 1
        else:
            print('没有发现此单词')

    return array(resultVec)


def trainNB(trainMatrix, trainClass):
    """计算，生成每个词对于类别上的概率"""
    # 类别行数
    numTrainClass = len(trainClass)
    # 列数
    numWords = len(trainMatrix[0])

    # 全部都初始化为1， 防止出现概率为0的情况出现
    # 见于韩家炜的数据挖掘概念与技术上的讲解，避免出现概率为0的状况，影响计算，因为在数量很大的情况下，在分子和分母同时+1的情况不会
    # 影响主要的数据
    p0Num = ones(numWords)
    p1Num = ones(numWords)
    # 相应的单词初始化为2
    # 为了分子分母同时都加上某个数λ
    p0Words = 2.0
    p1Words = 2.0
    # 统计每个分类的词的总数
    # 训练数据集的行数作为遍历的条件，从1开始
    # 如果当前类别为1，那么p1Num会加上当前单词矩阵行数据，依次遍历
    # 如果当前类别为0，那么p0Num会加上当前单词矩阵行数据，依次遍历
    # 同时统计当前类别下单词的个数和p1Words和p0Words
    for i in range(numTrainClass):
        if trainClass[i] == 1:
            # 数组在对应的位置上相加
            p1Num += trainMatrix[i]
            p1Words += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Words += sum(trainMatrix[i])
    # 计算每种类型里面， 每个单词出现的概率
    # 朴素贝叶斯分类中，y=x是单调递增函数，y=ln(x)也是单调的递增的
    # 如果x1>x2 那么ln(x1)>ln(x2)
    # 在计算过程中，由于概率的值较小，所以我们就取对数进行比较，根据对数的特性
    # ln(MN) = ln(M)+ln(N)
    # ln(M/N) = ln(M)-ln(N)
    # ln(M**n)= nln(M)
    # 注：其中ln可替换为log的任意对数底
    p0Vec = log(p0Num / p0Words)
    p1Vec = log(p1Num / p1Words)
    # 计算在类别中1出现的概率，0出现的概率可通过1-p得到
    pClass1 = sum(trainClass) / float(numTrainClass)
    return p0Vec, p1Vec, pClass1


def classifyNB(testVec, p0Vec, p1Vec, pClass1):
    # 朴素贝叶斯分类, max(p0， p1)作为推断的分类
    # y=x 是单调递增的， y=ln(x)也是单调递增的。 ， 如果x1 > x2, 那么ln(x1) > ln(x2)
    # 因为概率的值太小了，所以我们可以取ln， 根据对数特性ln(ab) = lna + lnb， 可以简化计算
    # sum是numpy的函数，testVec是一个数组向量，p1Vec是一个1的概率向量，通过矩阵之间的乘机
    # 获得p(X1|Yj)*p(X2|Yj)*...*p(Xn|Yj)*p(Yj)
    # 其中pClass1即为p(Yj)
    # 此处计算出的p1是用对数表示，按照上面所说的，对数也是单调的，而贝叶斯分类主要是通过比较概率
    # 出现的大小，不需要确切的概率数据，因此下述表述完全正确
    p1 = sum(testVec * p1Vec) + log(pClass1)
    p0 = sum(testVec * p0Vec) + log(1 - pClass1)
    if p0 > p1:
        return 0
    return 1


def printClass(words, testClass):
    if testClass == adClass:
        print(words, '推测为：广告邮件')
    else:
        print(words, '推测为：正常邮件')


def tNB():
    # 从训练数据集中提取出属性矩阵和分类数据
    docList, classVec = loadDataSet()
    # 生成包含所有单词的list
    # 此处生成的单词向量是不重复的
    allWordsVec = doc2VecList(docList)
    # 构建词向量矩阵
    # 计算docList数据集中每一行每个单词出现的次数，其中返回的trainMat是一个数组的数组
    trainMat = list(map(lambda x: words2Vec(allWordsVec, x), docList))
    # 训练计算每个词在分类上的概率, p0V:每个单词在非分类出现的概率， p1V:每个单词在是分类出现的概率
    # 其中概率是以ln进行计算的
    # pClass1为类别中是1的概率
    p0V, p1V, pClass1 = trainNB(trainMat, classVec)
    # 测试数据集
    testWords = ['公司', '聚餐', '讨论', '贝叶斯']
    # 转换成单词向量，32个单词构成的数组，如果此单词在数组中，数组的项值置1
    testVec = words2Vec(allWordsVec, testWords)
    # 通过将单词向量testVec代入，根据贝叶斯公式，比较各个类别的后验概率，判断当前数据的分类情况
    testClass = classifyNB(testVec, p0V, p1V, pClass1)
    # 打印出测试结果
    printClass(testWords, testClass)

    testWords = ['公司', '保险', '金融']
    # 转换成单词向量，32个单词构成的数组，如果此单词在数组中，数组的项值置1
    testVec = words2Vec(allWordsVec, testWords)
    # 通过将单词向量testVec代入，根据贝叶斯公式，比较各个类别的后验概率，判断当前数据的分类情况
    testClass = classifyNB(testVec, p0V, p1V, pClass1)
    # 打印出测试结果
    printClass(testWords, testClass)


if __name__ == '__main__':
    tNB()
 
 
 

本文主要讲述朴素贝叶斯分类算法并实现中文数据集的舆情分析案例，希望这篇文章对大家有所帮助，提供些思路。内容包括：
 
1.朴素贝叶斯数学原理知识
 2.naive_bayes用法及简单案例
 3.中文文本数据集预处理
 4.朴素贝叶斯中文文本舆情分析
 
本篇文章为基础性文章，希望对你有所帮助，如果文章中存在错误或不足之处，还请海涵。同时，推荐大家阅读我以前的文章了解基础知识。
 
一. 朴素贝叶斯数学原理知识
 
该基础知识部分引用文章"机器学习之朴素贝叶斯(NB)分类算法与Python实现"（https://blog.csdn.net/moxigandashu/article/details/71480251），也强烈推荐大家阅读博主moxigandashu的文章，写得很好。同时作者也结合概率论讲解，提升下自己较差的数学。
 朴素贝叶斯（Naive Bayesian）是基于贝叶斯定理和特征条件独立假设的分类方法，它通过特征计算分类的概率，选取概率大的情况，是基于概率论的一种机器学习分类（监督学习）方法，被广泛应用于情感分类领域的分类器。
 
下面简单回顾下概率论知识：
 
1.什么是基于概率论的方法？
 
通过概率来衡量事件发生的可能性。概率论和统计学是两个相反的概念，统计学是抽取部分样本统计来估算总体情况，而概率论是通过总体情况来估计单个事件或部分事情的发生情况。概率论需要已知数据去预测未知的事件。
 
例如，我们看到天气乌云密布，电闪雷鸣并阵阵狂风，在这样的天气特征(F)下，我们推断下雨的概率比不下雨的概率大，也就是p(下雨)>p(不下雨)，所以认为待会儿会下雨，这个从经验上看对概率进行判断。而气象局通过多年长期积累的数据，经过计算，今天下雨的概率p(下雨)=85%、p(不下雨)=15%，同样的 p(下雨)>p(不下雨)，因此今天的天气预报肯定预报下雨。这是通过一定的方法计算概率从而对下雨事件进行判断。
 
 
2.条件概率
 
若Ω是全集，A、B是其中的事件（子集），P表示事件发生的概率，则条件概率表示某个事件发生时另一个事件发生的概率。假设事件B发生后事件A发生的概率为：
 
 
设P(A)>0，则有 P(AB) = P(B|A)P(A) = P(A|B)P(B)。
 
设A、B、C为事件，且P(AB)>0，则有 P(ABC) = P(A)P(B|A)P(C|AB)。
 
现在A和B是两个相互独立的事件，其相交概率为 P(A∩B) = P(A)P(B)。
 
3.全概率公式
 
设Ω为试验E的样本空间，A为E的事件，B1、B2、…、Bn为Ω的一个划分，且P(Bi)>0，其中i=1,2,…,n，则：
 
P(A) = P(AB1)+P(AB2)+…+P(ABn)
 
    = P(A|B1)P(B1)+P(A|B2)P(B2)+...+P(A|Bn)P(Bn)
 

 全概率公式主要用途在于它可以将一个复杂的概率计算问题，分解为若干个简单事件的概率计算问题，最后应用概率的可加性求出最终结果。
 
示例：有一批同一型号的产品，已知其中由一厂生成的占30%，二厂生成的占50%，三长生成的占20%，又知这三个厂的产品次品概率分别为2%、1%、1%，问这批产品中任取一件是次品的概率是多少？
 
 参考百度文库资料：
 
https://wenku.baidu.com/view/05d0e30e856a561253d36fdb.html
 
4.贝叶斯公式
 
设Ω为试验E的样本空间，A为E的事件，如果有k个互斥且有穷个事件，即B1、B2、…、Bk为Ω的一个划分，且P(B1)+P(B2)+…+P(Bk)=1，P(Bi)>0（i=1,2,…,k)，则：
 
 
P(A)：事件A发生的概率；
 
P(A∩B)：事件A和事件B同时发生的概率；
 
P(A|B)：事件A在时间B发生的条件下发生的概率；
 
意义：现在已知时间A确实已经发生，若要估计它是由原因Bi所导致的概率，则可用Bayes公式求出。
 
5.先验概率和后验概率
 
先验概率是由以往的数据分析得到的概率，泛指一类事物发生的概率，根据历史资料或主观判断未经证实所确定的概率。后验概率而是在得到信息之后再重新加以修正的概率，是某个特定条件下一个具体事物发生的概率。
 
 6.朴素贝叶斯分类
 
贝叶斯分类器通过预测一个对象属于某个类别的概率，再预测其类别，是基于贝叶斯定理而构成出来的。在处理大规模数据集时，贝叶斯分类器表现出较高的分类准确性。
 
假设存在两种分类：
 
 
如果p1(x,y)>p2(x,y)，那么分入类别1
 
 
如果p1(x,y)<p2(x,y)，那么分入类别2
 
 
引入贝叶斯定理即为：
 
 
其中，x、y表示特征变量，ci表示分类，p(ci|x,y)表示在特征为x,y的情况下分入类别ci的概率，因此，结合条件概率和贝叶斯定理有：
 
 
如果p(c1|x,y)>p(c2,|x,y)，那么分类应当属于类别c1
 
 
如果p(c1|x,y)<p(c2,|x,y)，那么分类应当属于类别c2
 
 
贝叶斯定理最大的好处是可以用已知的概率去计算未知的概率，而如果仅仅是为了比较p(ci|x,y)和p(cj|x,y)的大小，只需要已知两个概率即可，分母相同，比较p(x,y|ci)p(ci)和p(x,y|cj)p(cj)即可。
 
 7.示例讲解
 
假设存在14天的天气情况和是否能打网球，包括天气、气温、湿度、风等，现在给出新的一天天气情况，需要判断我们这一天可以打网球吗？首先统计出各种天气情况下打网球的概率，如下图所示。
 
 接下来是分析过程，其中包括打网球yse和不打网球no的计算方法。
 
 最后计算结果如下，不去打网球概率为79.5%。
 
 8.优缺点
 
监督学习，需要确定分类的目标
 
对缺失数据不敏感，在数据较少的情况下依然可以使用该方法
 
可以处理多个类别 的分类问题
 
适用于标称型数据
 
对输入数据的形势比较敏感
 
由于用先验数据去预测分类，因此存在误差
 
二. naive_bayes用法及简单案例
 
scikit-learn机器学习包提供了3个朴素贝叶斯分类算法：
 
GaussianNB(高斯朴素贝叶斯)
 
MultinomialNB(多项式朴素贝叶斯)
 
BernoulliNB(伯努利朴素贝叶斯)
 
1.高斯朴素贝叶斯
 
调用方法为：sklearn.naive_bayes.GaussianNB(priors=None)。
 
下面随机生成六个坐标点，其中x坐标和y坐标同为正数时对应类标为2，x坐标和y坐标同为负数时对应类标为1。通过高斯朴素贝叶斯分类分析的代码如下：
 
1# -*- coding: utf-8 -*-
2import numpy as np
3from sklearn.naive_bayes import GaussianNB
4X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
5Y = np.array([1, 1, 1, 2, 2, 2])
6clf = GaussianNB()
7clf.fit(X, Y)      
8pre = clf.predict(X)
9print u"数据集预测结果:", pre
10print clf.predict([[-0.8, -1]])
11
12clf_pf = GaussianNB()
13clf_pf.partial_fit(X, Y, np.unique(Y)) #增加一部分样本
14print clf_pf.predict([[-0.8, -1]])
 
输出如下图所示，可以看到[-0.8, -1]预测结果为1类，即x坐标和y坐标同为负数。
 
 2.多项式朴素贝叶斯
 
多项式朴素贝叶斯：sklearn.naive_bayes.MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)主要用于离散特征分类，例如文本分类单词统计，以出现的次数作为特征值。
 
参数说明：alpha为可选项，默认1.0，添加拉普拉修/Lidstone平滑参数；fit_prior默认True，表示是否学习先验概率，参数为False表示所有类标记具有相同的先验概率；class_prior类似数组，数组大小为(n_classes,)，默认None，类先验概率。
 
3.伯努利朴素贝叶斯
 
伯努利朴素贝叶斯：sklearn.naive_bayes.BernoulliNB(alpha=1.0, binarize=0.0, fit_prior=True,class_prior=None)。类似于多项式朴素贝叶斯，也主要用于离散特征分类，和MultinomialNB的区别是：MultinomialNB以出现的次数为特征值，BernoulliNB为二进制或布尔型特性
 
下面是朴素贝叶斯算法常见的属性和方法。
 
class_prior_属性
 
观察各类标记对应的先验概率，主要是class_prior_属性，返回数组。代码如下：
 
1print clf.class_prior_
2#[ 0.5  0.5]
 
class_count_属性
 
获取各类标记对应的训练样本数，代码如下：
 
1print clf.class_count_
2#[ 3.  3.]
 
theta_属性
 
获取各个类标记在各个特征上的均值，代码如下：
 
1print clf.theta_
2#[[-2.         -1.33333333]
3# [ 2.          1.33333333]]
 
sigma_属性
 
获取各个类标记在各个特征上的方差，代码如下：
 
1print clf.theta_
2#[[-2.         -1.33333333]
3# [ 2.          1.33333333]]
 
fit(X, y, sample_weight=None)
 
训练样本，X表示特征向量，y类标记，sample_weight表各样本权重数组。
 
1#设置样本不同的权重
2clf.fit(X,Y,np.array([0.05,0.05,0.1,0.1,0.1,0.2,0.2,0.2]))
3print clf  
4print clf.theta_  
5print clf.sigma_ 
 
输出结果如下所示：
 
1GaussianNB()
2[[-2.25 -1.5 ]
3 [ 2.25  1.5 ]]
4[[ 0.6875  0.25  ]
5 [ 0.6875  0.25  ]]
 
partial_fit(X, y, classes=None, sample_weight=None)
 
增量式训练，当训练数据集数据量非常大，不能一次性全部载入内存时，可以将数据集划分若干份，重复调用partial_fit在线学习模型参数，在第一次调用partial_fit函数时，必须制定classes参数，在随后的调用可以忽略。
 
1import numpy as np  
2from sklearn.naive_bayes import GaussianNB  
3X = np.array([[-1,-1], [-2,-2], [-3,-3], [-4,-4], [-5,-5], 
4              [1,1], [2,2], [3,3]])  
5y = np.array([1, 1, 1, 1, 1, 2, 2, 2])  
6clf = GaussianNB()  
7clf.partial_fit(X,y,classes=[1,2],
8                sample_weight=np.array([0.05,0.05,0.1,0.1,0.1,0.2,0.2,0.2]))  
9print clf.class_prior_ 
10print clf.predict([[-6,-6],[4,5],[2,5]])  
11print clf.predict_proba([[-6,-6],[4,5],[2,5]])
 
输出结果如下所示：
 
1[ 0.4  0.6]
2[1 2 2]
3[[  1.00000000e+00   4.21207358e-40]
4 [  1.12585521e-12   1.00000000e+00]
5 [  8.73474886e-11   1.00000000e+00]]
 
可以看到点[-6,-6]预测结果为1，[4,5]预测结果为2，[2,5]预测结果为2。同时，predict_proba(X)输出测试样本在各个类标记预测概率值。
 
score(X, y, sample_weight=None)
 
返回测试样本映射到指定类标记上的得分或准确率。
 
1pre = clf.predict([[-6,-6],[4,5],[2,5]])  
2print clf.score([[-6,-6],[4,5],[2,5]],pre)
3#1.0
 
最后给出一个高斯朴素贝叶斯算法分析小麦数据集案例，代码如下：
 
1# -*- coding: utf-8 -*-
2#第一部分 载入数据集
3import pandas as pd
4X = pd.read_csv("seed_x.csv")
5Y = pd.read_csv("seed_y.csv")
6print X
7print Y
8
9#第二部分 导入模型
10from sklearn.naive_bayes import GaussianNB  
11clf = GaussianNB()
12clf.fit(X, Y)      
13pre = clf.predict(X)
14print u"数据集预测结果:", pre
15
16#第三部分 降维处理
17from sklearn.decomposition import PCA
18pca = PCA(n_components=2)
19newData = pca.fit_transform(X)
20print newData[:4]
21
22#第四部分 绘制图形
23import matplotlib.pyplot as plt
24L1 = [n[0] for n in newData]
25L2 = [n[1] for n in newData]
26plt.scatter(L1,L2,c=pre,s=200)
27plt.show()
 
输出如下图所示：
 

 最后对数据集进行评估，主要调用sklearn.metrics类中classification_report函数实现的，代码如下：
 
1from sklearn.metrics import classification_report
2print(classification_report(Y, pre))
 
运行结果如下所示，准确率、召回率和F特征为91%。
 
 
补充下Sklearn机器学习包常用的扩展类。
 
1#监督学习
2sklearn.neighbors #近邻算法
3sklearn.svm #支持向量机
4sklearn.kernel_ridge #核-岭回归
5sklearn.discriminant_analysis #判别分析
6sklearn.linear_model #广义线性模型
7sklearn.ensemble #集成学习
8sklearn.tree #决策树
9sklearn.naive_bayes #朴素贝叶斯
10sklearn.cross_decomposition #交叉分解
11sklearn.gaussian_process #高斯过程
12sklearn.neural_network #神经网络
13sklearn.calibration #概率校准
14sklearn.isotonic #保守回归
15sklearn.feature_selection #特征选择
16sklearn.multiclass #多类多标签算法
17
18#无监督学习
19sklearn.decomposition #矩阵因子分解sklearn.cluster # 聚类
20sklearn.manifold # 流形学习
21sklearn.mixture # 高斯混合模型
22sklearn.neural_network # 无监督神经网络
23sklearn.covariance # 协方差估计
24
25#数据变换
26sklearn.feature_extraction # 特征提取sklearn.feature_selection # 特征选择
27sklearn.preprocessing # 预处理
28sklearn.random_projection # 随机投影
29sklearn.kernel_approximation # 核逼近
 
三. 中文文本数据集预处理
 
假设现在需要判断一封邮件是不是垃圾邮件，其步骤如下：
 
数据集拆分成单词，中文分词技术
 
计算句子中总共多少单词，确定词向量大小
 
句子中的单词转换成向量，BagofWordsVec
 
计算P(Ci)，P(Ci|w)=P(w|Ci)P(Ci)/P(w)，表示w特征出现时，该样本被分为Ci类的条件概率
 
判断P(w[i]C[0])和P(w[i]C[1])概率大小，两个集合中概率高的为分类类标
 
下面讲解一个具体的实例。
 
1.数据集读取
 
假设存在如下所示10条Python书籍订单评价信息，每条评价信息对应一个结果（好评和差评），如下图所示：
 
 数据存储至CSV文件中，如下图所示。
 

 下面采用pandas扩展包读取数据集。代码如下所示：
 
1# -*- coding: utf-8 -*-
2import numpy as np
3import pandas as pd
4
5data = pd.read_csv("data.csv",encoding='gbk')
6print data
7
8#取表中的第1列的所有值
9print u"获取第一列内容"
10col = data.iloc[:,0]  
11#取表中所有值  
12arrs = col.values
13for a in arrs:
14    print a
 
输出结果如下图所示，同时可以通过data.iloc[:,0]获取第一列的内容。
 
2.中文分词及过滤停用词
 
接下来作者采用jieba工具进行分词，并定义了停用词表，即：
 
stopwords = {}.fromkeys([’，’, ‘。’, ‘！’, ‘这’, ‘我’, ‘非常’])
 
完整代码如下所示：
 
1# -*- coding: utf-8 -*-
2import numpy as np
3import pandas as pd
4import jieba
5
6data = pd.read_csv("data.csv",encoding='gbk')
7print data
8
9#取表中的第1列的所有值
10print u"获取第一列内容"
11col = data.iloc[:,0]  
12#取表中所有值  
13arrs = col.values
14#去除停用词  
15stopwords = {}.fromkeys(['，', '。', '！', '这', '我', '非常'])
16
17print u"\n中文分词后结果:"
18for a in arrs:
19    #print a
20    seglist = jieba.cut(a,cut_all=False)     #精确模式  
21    final = ''
22    for seg in seglist:
23        seg = seg.encode('utf-8')
24        if seg not in stopwords: #不是停用词的保留
25            final += seg
26    seg_list = jieba.cut(final, cut_all=False) 
27    output = ' '.join(list(seg_list))         #空格拼接
28    print output
 
然后分词后的数据如下所示，可以看到标点符号及“这”、“我”等词已经过滤。
 
 
3.词频统计
 
接下来需要将分词后的语句转换为向量的形式，这里使用CountVectorizer实现转换为词频。如果需要转换为TF-IDF值可以使用TfidfTransformer类。词频统计完整代码如下所示：
 
1# -*- coding: utf-8 -*-
2import numpy as np
3import pandas as pd
4import jieba
5
6data = pd.read_csv("data.csv",encoding='gbk')
7print data
8
9#取表中的第1列的所有值
10print u"获取第一列内容"
11col = data.iloc[:,0]  
12#取表中所有值  
13arrs = col.values
14#去除停用词  
15stopwords = {}.fromkeys(['，', '。', '！', '这', '我', '非常'])
16
17print u"\n中文分词后结果:"
18corpus = []
19for a in arrs:
20    #print a
21    seglist = jieba.cut(a,cut_all=False)     #精确模式  
22    final = ''
23    for seg in seglist:
24        seg = seg.encode('utf-8')
25        if seg not in stopwords: #不是停用词的保留
26            final += seg
27    seg_list = jieba.cut(final, cut_all=False) 
28    output = ' '.join(list(seg_list))         #空格拼接
29    print output
30    corpus.append(output)
31
32#计算词频
33from sklearn.feature_extraction.text import CountVectorizer
34from sklearn.feature_extraction.text import TfidfTransformer
35
36vectorizer = CountVectorizer() #将文本中的词语转换为词频矩阵  
37X = vectorizer.fit_transform(corpus) #计算个词语出现的次数    
38word = vectorizer.get_feature_names() #获取词袋中所有文本关键词  
39for w in word: #查看词频结果
40    print w,
41print ''
42print X.toarray()  
 
输出结果如下所示，包括特征词及对应的10行数据的向量，这就将中文文本数据集转换为了数学向量的形式，接下来就是对应的数据分析了。
 

 如下所示得到一个词频矩阵，每行数据集对应一个分类类标，可以预测新的文档属于哪一类。
 
 
TF-IDF相关知识推荐我的文章： [python] 使用scikit-learn工具计算文本TF-IDF值（https://blog.csdn.net/eastmount/article/details/50323063）
 
四. 朴素贝叶斯中文文本舆情分析
 
最后给出朴素贝叶斯分类算法分析中文文本数据集的完整代码。
 
1# -*- coding: utf-8 -*-
2import numpy as np
3import pandas as pd
4import jieba
5
6#http://blog.csdn.net/eastmount/article/details/50323063
7#http://blog.csdn.net/eastmount/article/details/50256163
8#http://blog.csdn.net/lsldd/article/details/41542107
9
10####################################
11#         第一步 读取数据及分词
12#
13data = pd.read_csv("data.csv",encoding='gbk')
14print data
15
16#取表中的第1列的所有值
17print u"获取第一列内容"
18col = data.iloc[:,0]  
19#取表中所有值  
20arrs = col.values
21
22#去除停用词  
23stopwords = {}.fromkeys(['，', '。', '！', '这', '我', '非常'])
24
25print u"\n中文分词后结果:"
26corpus = []
27for a in arrs:
28    #print a
29    seglist = jieba.cut(a,cut_all=False)     #精确模式  
30    final = ''
31    for seg in seglist:
32        seg = seg.encode('utf-8')
33        if seg not in stopwords: #不是停用词的保留
34            final += seg
35    seg_list = jieba.cut(final, cut_all=False) 
36    output = ' '.join(list(seg_list))         #空格拼接
37    print output
38    corpus.append(output)
39
40####################################
41#         第二步 计算词频
42#
43from sklearn.feature_extraction.text import CountVectorizer
44from sklearn.feature_extraction.text import TfidfTransformer
45
46vectorizer = CountVectorizer() #将文本中的词语转换为词频矩阵  
47X = vectorizer.fit_transform(corpus) #计算个词语出现的次数    
48word = vectorizer.get_feature_names() #获取词袋中所有文本关键词  
49for w in word: #查看词频结果
50    print w,
51print ''
52print X.toarray()  
53
54
55####################################
56#         第三步 数据分析
57#
58from sklearn.naive_bayes import MultinomialNB  
59from sklearn.metrics import precision_recall_curve  
60from sklearn.metrics import classification_report
61
62#使用前8行数据集进行训练，最后两行数据集用于预测
63print u"\n\n数据分析:"
64X = X.toarray()
65x_train = X[:8]
66x_test = X[8:]
67#1表示好评 0表示差评
68y_train = [1,1,0,0,1,0,0,1]
69y_test = [1,0]
70
71#调用MultinomialNB分类器  
72clf = MultinomialNB().fit(x_train, y_train)
73pre = clf.predict(x_test)
74print u"预测结果:",pre
75print u"真实结果:",y_test
76
77from sklearn.metrics import classification_report
78print(classification_report(y_test, pre))
 
输出结果如下所示，可以看到预测的两个值都是正确的。即“一本优秀的书籍，值得读者拥有。”预测结果为好评（类标1），“很差，不建议买，准备退货。”结果为差评（类标0）。
 
1数据分析:
2预测结果: [1 0]
3真实结果: [1, 0]
4             precision    recall  f1-score   support
5
6          0       1.00      1.00      1.00         1
7          1       1.00      1.00      1.00         1
8
9avg / total       1.00      1.00      1.00         2
 
但存在一个问题，由于数据量较小不具备代表性，而真实分析中会使用海量数据进行舆情分析，预测结果肯定页不是100%的正确，但是需要让实验结果尽可能的好。最后补充一段降维绘制图形的代码，如下：
 
1#降维绘制图形
2from sklearn.decomposition import PCA
3pca = PCA(n_components=2)
4newData = pca.fit_transform(X)
5print newData
6
7pre = clf.predict(X)
8Y = [1,1,0,0,1,0,0,1,1,0]
9import matplotlib.pyplot as plt
10L1 = [n[0] for n in newData]
11L2 = [n[1] for n in newData]
12plt.scatter(L1,L2,c=pre,s=200)
13plt.show()
 
输出结果如图所示，预测结果和真实结果都是一样的，即[1,1,0,0,1,0,0,1,1,0]。
 

条件概率
 
先要从条件概率讲起，条件概率，一般记作P(A|B)，意思是当B事件发生时，A事件发生的概率。其定义为
 
 其中 $P(A\cap B)P(A\cap B)P(A\cap B)$意思是A和B共同发生的概率，称为联合概率。也可以写作 P(A,B) 或 P(AB)。
 
注意，定义中A与B之间不一定有因果或者时间序列关系。
 
条件概率的这个定义如何理解呢？
 
样本空间
 回顾一下，样本空间是一个实验或随机试验所有可能结果的集合。例如，抛掷一枚硬币，那么样本空间就是集合{正面，反面}。如果投掷一个骰子，那么样本空间就是 {1,2,3,4,5,6}。样本空间的任何一个子集都被称为一个事件。
 所以，当我们通常说某个事件的概率时，其实是默认省略了该事件的样本空间。比如说事件A的概率是P(A)，其实是指，在样本空间 Ω 中，事件A的数量占Ω的比率，记作P(A)。比如说骰子掷出3点的概率是1/6，其实是说，在掷骰子所有可能结果的集合中（样本空间）中，出现事件”3点“（子集）的比率是1/6。也就是 size{3} / size{1,2,3,4,5,6} = 1/6。
条件意味着缩小的样本空间，是二级概率
 通常说概率P(A)是针对样本空间 Ω 来说的，而条件概率中的条件，比如P(A|B)，意思是事件B发生的情况下，因此非B的样本空间被这个条件排除掉了，所以这时P(A|B)已经不是针对 样本空间 Ω 了，而是针对缩小的样本空间 B。
 
 
结合上图来理解。原来样本空间是 Ω，事件B发生，意味着样本空间缩小到B的范围，即上图黄色椭圆范围内。同时事件A也发生，也就是上图中 A∩B 蓝色部分，蓝色部分对黄色椭圆的占比，就是条件概率 P(A|B)。可以写作
 
 
如果考虑到
 
 
所以
 
 
公式(2)就是通常条件概率的定义。要注意的是，如果用公式(1)，就是要穷举事件（集合）"A∩B"和"B"的所有情况。如果用公式(2)，要注意P(A∩B)和P(B)都是相对整个样本空间 Ω 来计算其概率P的。
 
 
贝叶斯定理(Bayes)
 
贝叶斯定理是统计学中非常重要的一个定理，以贝叶斯定理为基础的统计学派在统计学世界里占据着重要的地位，和概率学派从事件的随机性出发不同，贝叶斯统计学更多地是从观察者的角度出发，事件的随机性不过是观察者掌握信息不完备所造成的，观察者所掌握的信息多寡将影响观察者对于事件的认知。
 
从条件概率出发很容易推导出贝叶斯定理。
 
 
公式(5)可以理解为 条件概率的比值 = 先验概率的比值 = 椭圆A / 椭圆B。（先验概率指P(A)和P(B)，由于不涉及其它条件，即P(A)与B无关，P(B)与A无关，所以称为先验。条件概率在这里又称为后验概率，因为P(A|B)意味着已知B事件发生之后，P(B|A)意味着已知A事件发生之后）。
 
公式(6)就是通常贝叶斯定理的形式。
 

 
吸毒者案例
 
假设吸毒者每次检测呈阳性（+）的概率为99%。而不吸毒者每次检测呈阴性（-）的概率为99%。某公司雇员有0.5%的吸毒。问检测阳性（+）时，该雇员吸毒的概率是多少？
 
 
 
样本空间：公司所有雇员
 事件+：检测结果阳性
 事件D：雇员为吸毒者
 事件N：雇员为非吸毒者
 
 
根据已知条件
 
P(+|D) = 0.99   吸毒者每次检测呈阳性（+）的概率为99%
P(+|N) = 0.01   不吸毒者每次检测呈阴性（-）的概率为99%，那么检测呈阳性的概率是 1-99%=1%
P(D) = 0.005    公司雇员有0.5%的吸毒
P(N) = 0.995    另外99.5%的雇员不吸毒
 
 
 
求P(D|+) ，即 检测阳性（+）时，该雇员吸毒的概率是多少？
 
 
$$P(D|+)=\frac{P(D)\ast P(+|D)}{P(+)}$$
 其中 P(+) 还需要计算，应用全概率公式，再用贝叶斯公式：
 $$P(+)=P(+\cap D)+P(+\cap N)=P(+|D)\ast P(D)+P(+|N)\ast P(N)=0.99\ast 0.005+0.01\ast 0.995=0.0149$$
 代入公式得
 $$P(D|+)=\frac{P(D)\ast P(+|D)}{P(+)}=\frac{0.005\ast 0.99}{0.0149}=0.3322=33.22\%$$
 即检测呈阳性时，只有33.22%的概率为吸毒者。
 
 
所谓P(D|+) ，就是在检测阳性(+)的范围内，吸毒者D的占比是多少。对照上面示意图来说，就是 (蓝色背景矩形面积) / (红框部分)面积。
 

 
朴素贝叶斯(Naïve Bayes)
 
朴素贝叶斯，它是一种简单但极为强大的预测建模算法。之所以称为朴素贝叶斯，是因为它假设每个输入变量是独立的。这个假设很硬，现实生活中根本不满足，但是这项技术对于绝大部分的复杂问题仍然非常有效。
 
朴素贝叶斯模型由两种类型的概率组成：
 
每个类别的概率$P(C_j)$；
每个属性的条件概率$P(A_i|C_j)$。
 
 
 
我们回归到贝叶死的案例中来，类型概率是患病，不患病；条件概率是：患病的条件下，被检查出阳性的概率，不患病的条件下，检查出阳性的概率（误诊的概率）。要求的被检查出阳性，那么患病的概率（贝叶斯是求后验概率–知道结果，推测原因的概率，“求什么什么是类别，其它的就是属性条件”！）
 
 
为了训练朴素贝叶斯模型，我们需要先给出训练数据，以及这些数据对应的分类。那么上面这两个概率，也就是类别概率和条件概率。他们都可以从给出的训练数据中计算出来。一旦计算出来，概率模型就可以使用贝叶斯原理对新数据进行预测。
 
回到朴素贝叶斯本身，因为每个输入变量是独立的，因此我们可以对我们我们的贝叶斯进行一些简单的推导。
 

 
 
 
吸烟者案列
 

 在全部人中，男性患肺癌的概率是65/100000，女性是48/1000000，即：
 $$P(Cancer|Male)=\frac{65}{1000000}$$
 $$P(Cancer|Female)=\frac{48}{1000000}$$
 
因此我们知道了，性别和得肺癌是不独立的。但我们现在假设吸烟是到导致肺癌的唯一因素。
 
我们想一下，吸烟女性中患肺癌的概率是多少？
 
$$P(Cancer|Female,Smoking)=P(Cancer|Smoking)$$
 
性别和患肺癌以及吸烟还有关系吗？显然是没有关系的，是相互独立的。因此吸烟女性中患肺癌的概率可以进一步化简为求吸烟中患肺癌的概率。
 
 
抛硬币问题
 
现在有两个硬币，一枚硬币为两面全正，一枚硬币为一面正一面反(fair)。
 现在随机摸出一枚硬币，并抛两次。
 
定义三种事件：
 
 
A: 第一次抛掷为正面
 
 
B: 第二次抛掷为正面
 
 
C: 你选择的是fair硬币
 
 
 

 
文本喜好问题
 
 
每一行是一篇文章，a1…an表示每个位置的单词，w表示当前用户是否喜欢。
 
那么我们要根据单词的出现情况判断当前用户喜欢那种类型的文章，不喜欢哪种类型的文章。即：
 
$$P(a_2=king|w=1)$$
 
然而，这里一共有 2×n×|Vocabulary| 项，这…太多了吧！(2表示喜欢，不喜欢两种情况，n表示选取前多少个单词进行计算，|Vocabulary|表示所有常用的单词)
 
 
现在让我们来考虑一下，一个人对文章的喜欢和不喜欢跟单词的位置有关系吗，是不是只跟单词出现的次数有关系？
 
因此我们可以对上述进行优化：
 $$P(V_k|w=w_i)=\frac{n_k+1}{n+|Vocabulary|}$$
 
其中：
 
$V_k$表示某个特定单词，
$w_i$表示用户喜欢还是不喜欢
$n_k$表示当前特定单词出现的次数，+1是为了避免为0，进行了一个拉普拉斯校准
n是选取的单词数量，+n也是因为进行了一个拉普拉斯校准，我们将每个单词出现的次数+1了，因此|Vocabulary|也要加上选取的单词数量n。
|Vocabulary|是常用的单词数量
 
对比一下上面的两种情况，这一种只有2×|Vocabulary|项需要去估计！