朴素贝叶斯算法原理以及python实现

一、朴素贝叶斯概述

朴素贝叶斯算法（Naive Bayesian algorithm) 是应用最为广泛的分类算法之一。

朴素贝叶斯方法是在贝叶斯算法的基础上进行了相应的简化，即假定给定目标值时属性之间相互条件独立。也就是说没有哪个属性变量对于决策结果来说占有着较大的比重，也没有哪个属性变量对于决策结果占有着较小的比重。虽然这个简化方式在一定程度上降低了贝叶斯分类算法的分类效果，但是在实际的应用场景中，极大地简化了贝叶斯方法的复杂性。

对于给定的训练集，首先基于特征条件独立假设学习输入输出的联合概率分布（朴素贝叶斯法这种通过学习得到模型的机制，显然属于生成模型）；然后基于此模型，对给定的输入 x，利用贝叶斯定理求出后验概率最大的输出 y。

相关知识思维导图：

二、概率论知识

• 条件概率：就是事件 $A$ 在另外一个事件 $B$ 已经发生条件下的发生概率。条件概率表示为 $P(A\mid B)$ ，读作在 $B$ 发生的条件下 $A$ 发生的概率"。
• 联合概率: 表示两个事件共同发生 (数学概念上的交集) 的概率。 $A$ 与 $B$ 的联合概率表示为联合概率$P(AB)$
  $$P(AB)=P(A\mid B)P(B)=P(B\mid A)P(A)$$
  若$A$与$B$独立
  $$P(AB)=P(A)P(B)$$
• 全概率公式: $P(X)={\sum }_{k}P\left(X\mid Y=Y_k\right)P\left(Y_k\right)$, 其中 ${\sum }_{k}P\left(Y_k\right)=1$

贝叶斯公式推导示例 :
已知某学校学生总人数为U，其中男生 : $60\%$，女生 : $40\%$
男生总是穿长裤, 女生则一半穿长裤一半穿裙子

正向概率: 随机选取一个学生, 他 (她) 穿长裤的概率和穿裙子的概率是多大
逆向概率: 迎面走来一个穿长裤的学生, 你只看得见他 (她) 穿的是否长裤, 而无法确定他 (她) 的性别, 你能够推断出他（她）是女生的概率是多大吗?

穿长裤的（男生): $U\ast P(Boy)\ast P(Pants\mid Boy)$
$\mathrm{P}($ Boy) 是男生的概率 $=60\%$
$\mathrm{P}$ (Pants|Boy) 是条件概率, 即在 Boy 这个条件下穿长裤的概 率是多大, 这里是 $100\%$, 因为所有男生都穿长裤
穿长裤的（女生) : $U\ast P(Girl)\ast P(Pants\mid Girl)$

求解: 穿长裤的人里面有多少女生
穿长裤总数：$U\ast P(Boy)\ast P(Pants\mid Boy)+U\ast P(Girl)\ast P(Pants\mid Girl)$
$P(Girl|Pants)=U\ast P(Girl)\ast P(Pants\mid Girl)/$ 穿长裤总数
$U^{\ast }P(Girl)\ast P(Pants\mid Girl)/[U\ast P(Boy)\ast P(Pants\mid Boy)+U\ast P(Girl)\ast P(Pants\mid Girl)]$
$=P(Girl)\ast P(Pants\mid Girl)/[P(Boy)\ast P(Pants\mid Boy)+P(Girl)\ast P(Pants\mid Girl)]$
可以发现最终结果与总人数无关。
由以上示例可推导出贝叶斯公式，此公式将$P(A|B)$与$P(B|A)$联系起来。

贝叶斯定理：贝叶斯理论是以18世纪的一位神学家托马斯.贝叶斯(Thomas Bayes)命名。通常，事件A在事件B (发生) 的条件下的概率， 与事件B在事件A (发生) 的条件下的概率是不一样的。然而，这两者是有确是的关系的，贝叶斯定理就是这种关系的阵述。
$$P(A\mid B)=\frac{P(B\mid A)P(A)}{P(B)}$$

• $\mathrm{P}(\mathrm{A})$ : 先验概率。先验概率（prior probability) 是指事情还没有发生，求这件事情发生的可能性的大小，是先验概率。它往往作 为"由因求果"问题中的"因"出顼。
• $\mathrm{P}(\mathrm{A}\mid \mathrm{B})$ : 后验概率。后验概率是指事情已经发生，求这件事情发生的原因是由某个因素引起的可能性的大小。后验概率的计算要 以先验概率为基础
• $\mathrm{P}(\mathrm{B}\mid \mathrm{A})$ : 条件概率，又叫似然概率，一般是通过历史数据统计得到。一般不把它叫做先验概率，但从定义上也符合先验定义。

三、朴素贝叶斯算法原理

朴素贝叶斯方法是其于贝叶斯定理和特征条件独立假设的分类方法。对于给定的训练数据集，首先其于特征条件独立假设学习输入输出的联合概率分布；然后基于此模型，对于给定的输入 $x$ ，通过学习到的模型计算后验概率分布 $P(Y=c_k\mid X=$ $x$ )，将后验概率最大的类作为 $x$ 的类输出。其中后验概率计算根据贝叶斯定理进行:

条件概率(条件独立)：
$$P\left(X=x\mid Y=c_k\right)=P\left(X^{(1)=}{x}^{(1)},\dots ,X^{(n)=}{x}^{(n)}\mid Y=c_k\right)=\prod _{j=1}^{n}P\left(X^{(j)}=x^j\mid Y=c_k\right)$$
$$P\left(Y=c_k\mid X=x\right)=\frac{P\left(X=x\mid Y=c_k\right)P\left(Y=c_k\right)}{{\sum }_{k}P\left(Y=c_k\right){\prod }_{j}P\left(X^{(j)}=x^{(j)}\mid Y=c_k\right)}$$
然后，最后的朴素贝叶斯分类模型为:
$$y=f(x)={arg\; max}_{c_k}\frac{P\left(Y=c_k\right){\prod }_{j}P\left(X^{(j)}=x^{(j)}\mid Y=c_k\right)}{{\sum }_{k}P\left(Y=c_k\right){\prod }_{j}P\left(X^{(j)}=x^{(j)}\mid Y=c_k\right)}$$
针对贝叶斯定理，由于所有类别的全概$P(x)$部分相同，那么
$$y={arg\; max}_{c_k}P\left(Y=c_k\right)\prod _{j=1}^{d}P\left(X^{(j)}=x^{(j)}\mid Y=c_k\right)$$

四、参数估计方法

极大似然估计（Maximum Likelihood Estimation，MLE）和贝叶斯估计（Bayesian Estimation）是统计推断中两种最常用的参数估计方法。

1. 极大似然估计
   最大似然估计的目的就是：利用已知的样本结果，反推最有可能（最大概率）导致这样结果的参数值。
   原理：极大似然估计是建立在极大似然原理的基础上的一个统计方法，是概率论在统计学中的应用。极大似然估计提 供了一种给定观察数据来评估模型参数的方法，即：“模型已定，参数末知"。通过若干次试验，观察其结果，利用试验 结果得到某个参数值能够使样本出现的概率为最大，则称为极大似然估计。
   由于样本集中的样本都是独立同分布，可以只考虑一类样本集$D$，来估计参数向量 $\theta$ 。记已知的样本集为：
   $$D=\left\{x_1,x_2,\cdots ,x_N\right\}$$
   似然函数 (linkehood function) : 联合概率密度函数 $P(D\mid \theta )$，称为相对于 $\left\{x_1,x_2,\cdots ,x_N\right\}$的 $\theta$ 的似然函数。
   $$l(\theta )=P(D\mid \theta )=P(x_1\mid \theta )P(x_2\mid \theta )\cdots P(x_n\mid \theta )=\prod _{i=1}^{N}P\left(x_i\mid \theta \right)$$ 如果 $\hat{\theta }$ 是参数空间中能使似然函数 $l(\theta )$ 最大的 $\theta$ 值，则 $\hat{\theta }$ 应该是 “最可能” 的参数值，那么 $\hat{\theta }$ 就是 $\theta$ 的极大似然估计量。它是样本集的函数，记作：
   $$\hat{\theta }=d\left(x_1,x_2,\cdots ,x_N\right)=d(D)$$
   $\hat{\theta }\left(x_1,x_2,\cdots ,x_N\right)$ 称作极大似然函数估计值
   求解极大似然函数
   $ML$ 估计：求使得出现该组样本的概率最大的 $\theta$ 值。
   $$\hat{\theta }=\arg \underset{\theta }{\max }l(\theta )=\arg \underset{\theta }{\max }\prod _{i=1}^{N}P\left(x_i\mid \theta \right)$$
   实际中为了便于分析，定义了对数似然函数:
   $$\begin{array}{c}H(\theta )=\ln l(\theta )\\ \hat{\theta }=\arg \underset{\theta }{\max }H(\theta )=\arg \underset{\theta }{\max }\ln l(\theta )=\arg \underset{\theta }{\max }\prod _{i=1}^{N}P\left(x_i\mid \theta \right)\end{array}$$
   末知参数只有一个 ($\theta$ 为标量 )
   在似然函数满足连续、可微的正则条件下，极大似然估计量是下面微分方程的解:
   $$\frac{dl(\theta )}{d\theta }=0\text{ 或者等价于 }\frac{dH(\theta )}{d\theta }=\frac{d\ln l(\theta )}{d\theta }=0$$
   末知参数有多个 ( $\theta$ 为向量)
   则 $\theta$ 可表示为具有 $S$ 个分量的末知向量:
   $$\theta ={\left[{\theta }_1,{\theta }_2,\cdots ,{\theta }_S\right]}^T$$
   记梯度:
   $${\nabla }_{\theta }={\left[\frac{\partial }{\partial {\theta }_1},\frac{\partial }{\partial {\theta }_2},\cdots ,\frac{\partial }{\partial {\theta }_S}\right]}^T$$
   若似然函数满足连续可导的条件，则最大似然估计量就是如下方程的解。
   $${\nabla }_{\theta }H(\theta )={\nabla }_{\theta }\ln l(\theta )=\sum _{i=1}^N{\nabla }_{\theta }\ln P\left(x_i\mid \theta \right)=0$$
   方程的解只是一个估计值，只有在样本数趋于无限多的时候，它才会接近于真实值。
2. 贝叶斯估计
   不同于ML估计，不再把参数$\theta$看成一个未知的确定变量，而是看成未知的随机变量，通过对第$i$类样本$D_i$的观察，使概率密度分布$P(D_i|\theta )$转化为后验概率$P\left(\theta \mid D_i\right)$ ，再求贝叶斯估计。
   假设: 将待估计的参数看作符合某种先验概率分布的随机变量。
   基本原理：
   
   贝叶斯估计的本质: 贝叶斯估计的本质是通过贝叶斯决策得到参数 $\theta$ 的最优估计，使得总期望风险最小。
   $\mathrm{P}(\theta )$ 是待估计参数 $\theta$ 的先验概率, $\theta$ 取值与样本集 $D=\left\{x_1,x_2,\cdots x_N\right\}$ 有关, $\lambda (\hat{\theta },\theta )$ 是$\hat{\theta }$ 作为 $\theta$ 的估计量时的损失函数。
   定义样本下的条件风险为:
   $$R(\hat{\theta }\mid x)={\int }_{\theta }\lambda (\hat{\theta },\theta )P(\theta \mid x)d\theta$$
   则有：
   $$R={\int }_{E^d}R(\hat{\theta }\mid x)P(x)dx$$
   又$R(\hat{\theta }\mid x)$ 非负, 则由贝叶斯决策知, 求 $\mathrm{R}$ 最小即求 $R(\hat{\theta }\mid x)$ 最小。
   即：
   $${\theta }^{\ast }=\arg \min R(\hat{\theta }\mid x)$$
   可得最优估计： $${\theta }^{\ast }={\int }_{\Theta }\theta P(\theta \mid x)d\theta$$
   损失函数: 通常规定函数是一个二次函数，即平方误差损失函数:
   $$\lambda (\hat{\theta },\theta )=(\theta -\hat{\theta }{)}^2$$
   可以证明，如果采用平方误差损失函数，则的贝叶斯估计值 $\hat{\theta }$ :是在给定x时 $\Theta$ 的条件期望。
   $$\hat{\theta }=E[\theta \mid x]={\int }_{\Theta }\theta P(\theta \mid x)d\theta$$
   同理可得，在给定样本集D下， $\theta$ 的贝叶斯估计值是:
   $$\hat{\theta }=E[\theta \mid D]={\int }_{\Theta }\theta P(\theta \mid D)d\theta$$
   贝叶斯估计的基本步骤（基于平方误差损失函数）
   1、确定参数 $\theta$ 的先验分布 $P(\theta )$;
   2、由样本集 $D=\left\{x_1,x_2,\cdots x_N\right\}$ 求出样本联合分布 $P(D\mid \theta )$, 它是 $\theta$ 的函数:
   $$P(D\mid \theta )=\prod _{n=1}^{N}P\left(x_n\mid \theta \right)$$
   3、利用贝叶斯公式, 求 $\theta$ 的后验分布:
   $$P(\theta \mid D)=\frac{P(D\mid \theta )P(\theta )}{{\int }_{\Theta }P(D\mid \theta )P(\theta )d\theta }$$
   4、求出贝叶斯估计值:
   $$\hat{\theta }={\int }_{\Theta }\theta P(\theta \mid D)d\theta$$

五、示例分析

以西瓜书机器学习示例来了解朴素贝叶斯算法过程
数据集：

测试数据：

概率分布函数
对连续属性可考虑概率密度函数, 假定 $p\left(x_i\mid c\right)\sim \mathcal{N}\left({\mu }_{c,i},{\sigma }_{c,i}^2\right)$, 其中 ${\mu }_{c,i}$ 和 ${\sigma }_{c,i}^2$ 分别是第 $c$ 类样本在第 $i$ 个属性上取值的均值和方差, 则有
$$p\left(x_i\mid c\right)=\frac{1}{\sqrt{2\pi }{\sigma }_{c,i}}\exp \left(-\frac{{\left(x_i-{\mu }_{c,i}\right)}^2}{2{\sigma }_{c,i}^2}\right)$$

1. 先验概率$P(c)$
   $P($ 好瓜 $=$ 是 $)=\frac{8}{17}\approx 0.471$
   $P($ 好瓜 $=$ 否 $)=\frac{9}{17}\approx 0.529$
2. 每个属性条件概率 $P\left(x_i\mid c\right)$ :
   $P_{\text{青绿 }\mid \text{ 是 }}=P($ 色泽 $=$ 青绿 $\mid$ 好瓜 $=$ 是 $)=\frac{3}{8}=0.375$,
   $P_{\text{青绿|否 }}=P($ 色泽 $=$ 青绿 $\mid$ 好瓜 $=$ 否 $)=\frac{3}{9}\approx 0.333$ ，
   $P_{\text{蜷缩|是 }}=P($ 根蒂 $=$ 蜷缩 $\mid$ 好瓜 $=$ 是 $)=\frac{5}{8}=0.375$,
   $P_{\text{蜷缩|否 }}=P($ 根蒂 $=$ 蜷缩 $\mid$ 好瓜 $=$ 否 $)=\frac{3}{9}\approx 0.333$,
   $P_{\text{浊响|是 }}=P($ 敲声 $=$ 浊响 $\mid$ 好瓜 $=$ 是 $)=\frac{6}{8}=0.750$,
   $P_{\text{浊响|否 }}=P($ 敲声 $=$ 浊响 $\mid$ 好瓜 $=$ 否 $)=\frac{4}{9}\approx 0.444$,
   $P_{\text{清晰 }\mid \text{ 是 }}=P($ 纹理 $=$ 清晰 $\mid$ 好瓜 $=$ 是 $)=\frac{7}{8}=0.875$,
   $P_{\text{清晰 }\mid \text{ 否 }}=P($ 纹理 $=$ 清晰 $\mid$ 好瓜 $=$ 否 $)=\frac{2}{9}\approx 0.222$,
   $P_{\text{凹陷|是 }}=P($ 脐部 $=$ 凹陷 $\mid$ 好瓜 $=$ 是 $)=\frac{6}{8}=0.750$,
   $P_{\text{凹陷|否 }}=P($ 脐部 $=$ 凹陷 $\mid$ 好瓜 $=$ 否 $)=\frac{2}{9}\approx 0.222$,
   $P_{\text{硬滑|是 }}=P($ 触感 $=$ 硬滑 $\mid$ 好瓜 $=$ 是 $)=\frac{6}{8}=0.750$,
   $P_{\text{硬滑|否 }}=P($ 触感 $=$ 硬滑 $\mid$ 好瓜 $=$ 否 $)=\frac{6}{9}\approx 0.667$,
   $p_{\text{密度: }0.697\mid \text{ 是 }}=p($ 密度 $=0.697\mid$ 好瓜 $=$ 是 $)$
   $$=\frac{1}{\sqrt{2\pi }\cdot 0.129}\exp \left(-\frac{(0.697-0.574{)}^2}{2\cdot 0.129^2}\right)\approx 1.959\text{, }$$
   $p_{\text{密度: }0.697\mid \text{ 否 }}=p($ 密度 $=0.697\mid$ 好瓜 $=$ 否 $)$
   $$=\frac{1}{\sqrt{2\pi }\cdot 0.195}\exp \left(-\frac{(0.697-0.496{)}^2}{2\cdot 0.195^2}\right)\approx 1.203\text{, }$$
   $p_{\text{含糖: }0.460\mid \text{ 是 }}=p($ 含糖率 $=0.460\mid$ 好瓜 $=$ 是 $)$
   $$=\frac{1}{\sqrt{2\pi }\cdot 0.101}\exp \left(-\frac{(0.460-0.279{)}^2}{2\cdot 0.101^2}\right)\approx 0.788$$
   $p_{\text{含磧: }0.460\mid \text{ 否 }}=p($ 含糖率 $=0.460\mid$ 好瓜 $=$ 否 $)$
   $$=\frac{1}{\sqrt{2\pi }\cdot 0.108}\exp \left(-\frac{(0.460-0.154{)}^2}{2\cdot 0.108^2}\right)\approx 0.066$$
3. 朴素贝叶斯计算
   $P(\text{好瓜}=\text{是})\times P_{青绿\mid 是}\times P_{蜷缩\mid 是}\times P_{浊响\mid 是}\times P_{清晰\mid 是}\times P_{凹陷\mid 是}\times P_{硬滑\mid 是}\times p_{密度:0.697\mid 是}\times p_{含糖:0.460\mid 是}\approx 0.038$
   $P(\text{好瓜}=\text{否})\times P_{青绿\mid 否}\times P_{蜷缩\mid 否}\times P_{浊响\mid 否}\times P_{清晰\mid 否}\times P_{凹陷\mid 否}\times P_{硬滑\mid 否}\times p_{密度:0.697\mid 否}\times p_{含糖:0.460\mid 否}\approx 6.8\times 10^{-5}$
   由于 $0.038>6.80\times 10^{-5}$, 因此, 朴素贝叶斯分类器将测试样本 “测 1 ” 判别为 “好瓜”.

六、拉普拉斯平滑修正

对离散属性而言, 令 $D_{c,x_i}$ 表示 $D_c$ 中在第 $i$ 个属性上取值为 $x_i$ 的样本组成的 集合, 则条件概率 $P\left(x_i\mid c\right)$ 可估计为
$$P\left(x_i\mid c\right)=\frac{\left|D_{c,x_i}\right|}{\left|D_c\right|}$$
若某个属性值在训练集中没有与某个类同时出现过, 则直接基于进行概率估计, 再根据朴素贝叶斯进行判别将出现问题. 例如, 在使用西瓜数据集训练朴素贝叶斯分类器时, 对一个 “敲声=清脆” 的测试例, 有
$$P_{\text{清晰|是 }}=P(\text{ 敲声 }=\text{ 清脆 }\mid \text{ 好瓜 }=\text{ 是 })=\frac{0}{8}=0,$$
由于朴素贝叶斯的连乘式计算出的概率值为零, 因此, 无论该样本的其他属性是什 么, 哪怕在其他属性上明显像好瓜, 分类的结果都将是 “好瓜=否”, 这显然不太合理.

为了避免其他属性携带的信息被训练集中末出现的属性值“抺去”, 在估计概率值时通常要进行 “平滑”, 常用 “拉普拉斯修正” . 具体来说, 令 $N$ 表示训练集 $D$ 中可能的类别数, $N_i$ 表示第 $i$ 个属性可能的取值数, 参数估计修正为
$$\begin{array}{rl}\hat{P}(c)& =\frac{\left|D_c\right|+1}{|D|+N},\\ \hat{P}\left(x_i\mid c\right)& =\frac{\left|D_{c,x_i}\right|+1}{\left|D_c\right|+N_i}.\end{array}$$
先验概率可估计为
$$\hat{P}(\text{ 好瓜 }=\text{ 是 })=\frac{8+1}{17+2}\approx 0.474,\hat{P}(\text{ 好瓜 }=\text{ 否 })=\frac{9+1}{17+2}\approx 0.526\text{. }$$
$P_{\text{青绿}\mid \text{是}}和P_{\text{青绿}\mid \text{否}}$可估计为
$${\hat{P}}_{\text{青绿}\mid \text{是}}=\hat{P}(\text{ 色泽 }=\text{ 青绿 }\mid \text{ 好瓜 }=\text{ 是 })=\frac{3+1}{8+3}\approx 0.364$$
$${\hat{P}}_{\text{青绿 }\mid \text{ 否 }}=\hat{P}(\text{ 色泽 }=\text{ 青绿 }\mid \text{ 好瓜 }=\text{ 否 })=\frac{3+1}{9+3}\approx \mathrm{0.333.}$$
$${\hat{P}}_{\text{清脆|是}}=\hat{P}(\text{ 敲声 }=\text{ 清脆 }\mid \text{ 好瓜 }=\text{ 是 })=\frac{0+1}{8+3}\approx \mathrm{0.091.}$$
拉普拉斯修正避免了因训练集样本不充分而导致概率估值为零的问题, 并且在训练集变大时, 修正过程所引入的先验(prior)的影响也会逐渐变得可忽略, 使得估值渐趋向于实际概率值.

七、算法优缺点

优点

• 朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。
• 对小规模的数据表现很好，能个处理多分类任务，适合增量式训练。
• 对缺失数据不太敏感，算法也比较简单，常用于文本分类。

缺点

• 理论上，朴素贝叶斯模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此，这是因为朴素贝叶斯模型给定输出类别 的情况下，假设属性之间相互独立，这个假设在实际应用中往往是不成立的，在属性个数比较多或者属性之间相关性较大时，分类效 果不好。而在属性相关性较小时，朴素贝叶斯性能最为良好。
• 需要知道先验概率，且先验概率很多时候取决于假设，假设的模型可以有很多种，因此在某些时候会由于假设的先验模型的原因导致 预测效果不佳。
• 由于是通过先验和数据来决定后验的概率从而决定分类，所以分类决策存在一定的错误率。
• 对输入数据的表达形式很敏感。

八、python实现

8.1 sklearn贝叶斯

常用的有3个朴素贝叶斯的分类算法：

算法名称	适用条件
高斯分布的朴素贝叶斯(GaussianNB)	样本特征的分布大部分是连续值，适合正态分布
多项式分布的朴素贝叶斯(MultinomialNB)	样本特征的分大部分是多元离散值，适合二项式分布
伯努利分布的朴素贝叶斯(BernoulliNB)	样本特征是二元离散值或者很稀疏的多元离散值，适合二项分布

naive_bayes.GaussianNB
参数：

先验概率priors，对应$Y$的各个类别的先验概率 $P(Y=c_k)$ 。这个值默认不给出，如果不给出此时 $P(Y=c_k)=mk/m$ 。
其中 $m$ 为训练集样本总数量， $mk$ 为输出为第 $k$ 类别的训练集样本数。
预测方法：

• predict: 方法就是我们最常用的预测方法，直接给出测试集的预测类别输出。
• predict_proba：则不同，它会给出测试集样本在各个类别上预测的概率。容易理解，predict_proba预测出的各个类别概率里的最大 值对应的类别，也就是predict方法得到类别。
• predict_log_proba: 和predict_proba类似它会给出测试集样本在各个类别上预测的概率的一个对数转化。转化后predict_log_proba 预测出的各个类别对数概率里的最大值对应的类别，也就是predict方法得到类别。

重要方法：
partial_fit：如果训练集数据量非常大，一次不能全部载入内存的时候。可以把训练集分成若干等分，重复调用partial_fit来一步步的学习训练集。

naive_bayes.MultinomialNB
参数：
alpha浮点型可选参数，默认为1.0，其实就是添加拉普拉斯平滑，如果这个参数设置为0，就是不添加平滑；布尔参数fit_prior表示是否要考虑先验概率，如果是false， 则所有的样本类别输出都有相同的类别先验概率。否则可以自己用第三个参数class_prior输入先验概率，或者不输入第三个参数 class_priori让MultinomialNB自己从训练集样本来计算先验概率，此时的先验概率为 $\mathrm{P}(\mathrm{Y}={\mathrm{c}}_{\mathrm{k}})=\mathrm{mk}/\mathrm{m}$ 。其中 $\mathrm{m}$ 为训练集样本总数量， $\mathrm{mk}$ 为输出为第k类别的训练集样本数。

fit_prior	class_prior	最终先验概率
False	填或不填没有意义	$P(Y=c_k)=1/kP(Y=c_k)=1/k$
True	不填	$P(Y=c_k)=mk/mP(Y=c_k)=mk/m$
True	填	$P(Y=c_k)=p(Y=c_k)=class\_prior$

naive_bayes.BernoulliNB
BernoulliNB一共有4个参数，其中3个参数的名字和意义和MultinomialNB完全相同。唯一增加的一个参数是binarize。这个参数主要是用来帮BernoulliNB处理二项分布的，可以是数值或者不输入。如果不输入，则BernoulliNB认为每个数据特征都已经是二元的。否则的话，小于binarize的会归为一类，大于binarize的会归为另外一类。

在使用BernoulliNB的fit或者partial_fit方法拟合数据后，我们可以进行预测。此时预测有三种方法，包括predict，predict_log_proba和predict_proba。方法和GaussianNB完全一样。

8.2 文本情感分析示例

数据来源情感分析-朴素贝叶斯

1. 导入数据
   数据包括评论内容以及分类标签

import pandas as pd
data = pd.read_excel('data_test_train.xlsx')
data.head()

                                             comment                               sentiment
0  口味：不知道是我口高了，还是这家真不怎么样。??我感觉口味确实很一般很一般。上菜相当快，我敢...          0
1                                 菜品丰富质量好，服务也不错！很喜欢！          1
2                        说真的，不晓得有人排队的理由，香精香精香精香精，拜拜！          0
3  菜量实惠，上菜还算比较快，疙瘩汤喝出了秋日的暖意，烧茄子吃出了大阪烧的味道，想吃土豆片也是口...          1
4  先说我算是娜娜家风荷园开业就一直在这里吃??每次出去回来总想吃一回??有时觉得外面的西式简餐...          1

2. 数据预处理
   对中文数据进行切分成词，导入jieba库
   jieba.cut(s) 精确模式：把文本精确的切分开，不存在冗余单词；
   jieba.lcut(s,cut_all=True) 全模式：把文本中所有可能的词语都扫描出来，有冗余；
   jieba.lcut_for_search(s) 搜索引擎模式：在精确模式基础上，对长词再次切分

#根据需要做处理,去重、去除停用词
# jieba分词
import jieba
def chinese_word_cut(mytext):
    return " ".join(jieba.cut(mytext))
data['cut_comment'] = data.comment.apply(chinese_word_cut)
data.head()

                                             comment  ...                                        cut_comment
0  口味：不知道是我口高了，还是这家真不怎么样。??我感觉口味确实很一般很一般。上菜相当快，我敢...  ...  口味 ： 不 知道 是 我口 高 了 ， 还是 这家 真 不怎么样 。 ? ? 我 感觉 口...
1                                 菜品丰富质量好，服务也不错！很喜欢！  ...                      菜品 丰富 质量 好 ， 服务 也 不错 ！ 很 喜欢 ！
2                        说真的，不晓得有人排队的理由，香精香精香精香精，拜拜！  ...         说真的 ， 不 晓得 有人 排队 的 理由 ， 香精 香精 香精 香精 ， 拜拜 ！
3  菜量实惠，上菜还算比较快，疙瘩汤喝出了秋日的暖意，烧茄子吃出了大阪烧的味道，想吃土豆片也是口...  ...  菜量 实惠 ， 上菜 还 算 比较 快 ， 疙瘩汤 喝出 了 秋日 的 暖意 ， 烧茄子 吃...
4  先说我算是娜娜家风荷园开业就一直在这里吃??每次出去回来总想吃一回??有时觉得外面的西式简餐...  ...  先说 我 算是 娜娜 家风 荷园 开业 就 一直 在 这里 吃 ? ? 每次 出去 回来 总...

3. 提取特征
   CountVectorizer是属于常见的特征数值计算类，是一个文本特征提取方法。对于每一个训练文本，它只考虑每种词汇在该训练文本中出现的频率。
   CountVectorizer会将文本中的词语转换为词频矩阵，它通过fit_transform函数计算各个词语出现的次数。
   CountVectorizer是通过fit_transform函数将文本中的词语转换为词频矩阵，矩阵元素a[i][j] 表示j词在第i个文本下的词频。即各个词语出现的次数，通过get_feature_names()可看到所有文本的关键字，通过toarray()可看到词频矩阵的结果。

CountVectorizer参数:

CountVectorizer(input='content', encoding='utf-8',  decode_error='strict', strip_accents=None, lowercase=True, preprocessor=None, tokenizer=None, stop_words=None, 
token_pattern='(?u)\b\w\w+\b', ngram_range=(1, 1), analyzer='word', max_df=1.0, min_df=1, max_features=None, vocabulary=None, binary=False, dtype=<class 'numpy.int64'>)

参数	作用
analyzer	一般使用默认，可设置为string类型，如’word’, ‘char’, ‘char_wb’，还可设置为callable类型，比如函数是一个callable类型
preprocessor	设为None或callable类型
tokenizer	设为None或callable类型
ngram_range	词组切分的长度范围，待详解
stop_words	设置停用词，设为english将使用内置的英语停用词，设为一个list可自定义停用词，设为None不使用停用词，设为None且max_df∈[0.7, 1.0)将自动根据当前的语料库建立停用词表
lowercase	将所有字符变成小写
token_pattern	过滤规则，表示token的正则表达式，需要设置analyzer == ‘word’，默认的正则表达式选择2个及以上的字母或数字作为token，标点符号默认当作token分隔符，而不会被当作token
max_df	可以设置为范围在[0.0 1.0]的float，也可以设置为没有范围限制的int，默认为1.0。这个参数的作用是作为一个阈值，当构造语料库的关键词集的时候，如果某个词的document frequence大于max_df，这个词不会被当作关键词。如果这个参数是float，则表示词出现的次数与语料库文档数的百分比，如果是int，则表示词出现的次数。如果参数中已经给定了vocabulary，则这个参数无效
min_df	类似于max_df，不同之处在于如果某个词的document frequence小于min_df，则这个词不会被当作关键词
max_features	默认为None，可设为int，对所有关键词的term frequency进行降序排序，只取前max_features个作为关键词集
vocabulary	默认为None，自动从输入文档中构建关键词集，也可以是一个字典或可迭代对象？
binary	默认为False，一个关键词在一篇文档中可能出现n次，如果binary=True，非零的n将全部置为1，这对需要布尔值输入的离散概率模型的有用的
dtype	使用CountVectorizer类的fit_transform()或transform()将得到一个文档词频矩阵，dtype可以设置这个矩阵的数值类型

属性表	作用
vocabulary_	词汇表；字典型
get_feature_names()	所有文本的词汇；列表型
stop_words_	返回停用词表

方法表	作用
fit_transform(X)	拟合模型，并返回文本矩阵
fit(raw_documents[, y])	Learn a vocabulary dictionary of all tokens in the raw documents.
fit_transform(raw_documents[, y])	Learn the vocabulary dictionary and return term-document matrix.

from sklearn.feature_extraction.text import CountVectorizer
def get_custom_stopwords(stop_words_file):
    with open(stop_words_file) as f:
        stopwords = f.read()
    stopwords_list = stopwords.split('\n')
    custom_stopwords_list = [i for i in stopwords_list]
    return custom_stopwords_list
stop_words_file = '哈工大停用词表.txt'
stopwords = get_custom_stopwords(stop_words_file)
vect = CountVectorizer(max_df = 0.8, 
                       min_df = 3, 
                       token_pattern=u'(?u)\\b[^\\d\\W]\\w+\\b', 
                       stop_words=frozenset(stopwords))

4. 划分数据集

X = data['cut_comment']
y = data.sentiment
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=22)

5. 特征展示

test = pd.DataFrame(vect.fit_transform(X_train).toarray(), columns=vect.get_feature_names())
test.head()

   ipad  ok  ps  wifi  一下  一个个  一个半  一个多  ...  麻酱  麻麻  黄瓜  黄盖  黄色  黏糊糊  黑椒  默默
0     0   0   0     0   0    0    0    0  ...   0   0   0   0   0    0   0   0
1     0   0   0     0   0    0    0    0  ...   0   0   0   0   0    0   0   0
2     0   0   0     0   0    0    0    0  ...   0   0   0   0   0    0   0   0
3     0   1   0     0   0    0    0    0  ...   0   0   0   0   0    0   0   0
4     0   0   0     0   0    0    0    0  ...   0   0   0   0   0    0   0   0

6. 训练模型

from sklearn.naive_bayes import MultinomialNB
nb = MultinomialNB()
X_train_vect = vect.fit_transform(X_train)
nb.fit(X_train_vect, y_train)
train_score = nb.score(X_train_vect, y_train)
train_score

训练得分

0.899375

7. 测试模型

X_test_vect = vect.transform(X_test)
nb.score(X_test_vect, y_test)

0.8275

8. 分析数据

data = pd.read_excel("data.xlsx")
data['cut_comment'] = data.comment.apply(chinese_word_cut)
X=data['cut_comment']
X_vec = vect.transform(X)
nb_result = nb.predict(X_vec)
data['nb_result'] = nb_result
test = pd.DataFrame(vect.fit_transform(X).toarray(), columns=vect.get_feature_names())
test.head()
# 结果写入excel
data.to_excel("data_result.xlsx",index=False)

8.3 CountVectorizer()函数

from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer
texts=["orange banana apple grape","banana apple apple","grape", 'orange apple'] 
cv = CountVectorizer()
cv_fit=cv.fit_transform(texts)
print(cv.vocabulary_)
print(cv_fit)
print(cv_fit.toarray())

输出如下：

{'orange': 3, 'banana': 1, 'apple': 0, 'grape': 2} #这里是根据首字母顺序，将texts变量中所有单词进行排序，apple首字母为a所以                                                                          # 排第一，banana首字母为b所以排第二
  (0, 2)    1   # (0, 2)  1 中0表示第一个字符串"orange banana apple grape"；2对应上面的'grape': 2；1表示出现次数1。整体理                       # 解为第一字符串的顺序为二的词语在出现次数为1
  (0, 0)    1
  (0, 1)    1
  (0, 3)    1
  (1, 0)    2
  (1, 1)    1
  (2, 2)    1
  (3, 0)    1
  (3, 3)    1
[[1 1 1 1]     # 第一个字符串，排名0,1,2,3词汇（apple，banana，grape，orange）出现的频率都为1
 [2 1 0 0]    #第二个字符串，排名0,1,2,3词汇（apple，banana，grape，orange）出现的频率为2,1,00
 [0 0 1 0]
 [1 0 0 1]]