朴素贝叶斯法原理及其python实现
文章目录
- 一、模型描述与假设
- 模型描述
- 期望风险最小化
- 生成式模型
- 朴素假设
- 二、模型学习与参数估计
- 伯努利模型（文本型）
- 多项式模型（词频型）
- 高斯模型
- 三、Python实现
- 伯努利模型
- 多项式模型
- 高斯模型
- 四、多项式模型之文本分类
一、模型描述与假设
模型描述
假设输入随机向量X⊂X∈RnX\sub{\mathcal X}\in \R^nX⊂X∈Rn，输出随机向量Y⊂Y={c1,c2,⋯,cK}Y\sub\mathcal Y=\{c_1,c_2,\cdots,c_K\}Y⊂Y={c1,c2,⋯,cK}，P(X,Y)P(X, Y)P(X,Y)是XXX和YYY的联合概率分布，训练集T={(x1,y1),⋯,(xN,yN)}T=\{(x_1,y_1),\cdots,(x_N,y_N)\}T={(x1,y1),⋯,(xN,yN)}由P(X,Y)P(X, Y)P(X,Y)独立同分布产生。
对于给定的输入x={x1,x2,⋯,xn}\bm x=\{x^1, x^2, \cdots, x^n\}x={x1,x2,⋯,xn}，朴素贝叶斯分类算法通过联合概率分布P(X,Y)P(X,Y)P(X,Y)，计算输入x\bm xx下各类别ckc_kck的概率P(ck∣x)P(c_k|\bm x)P(ck∣x)，并通过期望风险最小化准则，决定最终输出类别（具有最大概率的类别），即f:X→Yf:\mathcal X \to \mathcal Yf:X→Y。
期望风险最小化
假设模型fff对训练集XXX的预测类别为f(X)f(X)f(X)，训练集XXX的真实类别为YYY，模型fff的损失函数为L(Y,f(X))L(Y, f(X))L(Y,f(X))。对于单一样本x\bm xx，若模型fff基于后验概率P(c∣x)P(c|\bm x)P(c∣x)将样本的类别预测为ccc，则损失为
R(c∣x)=∑k=1KL(ck,f(x)=c)P(ck∣x)R(c|\bm x) = \sum_{k=1}^K L(c_k, f(\bm x) = c)P(c_k|\bm x)R(c∣x)=k=1∑KL(ck,f(x)=c)P(ck∣x)
实际的预测任务应使得总体风险最小，显然，若对单一样本x\bm xx的预测都能保证风险最小，则最终的总体风险也一定是最小。因此，朴素贝叶斯算法的预测判定准则为：对每个样本选择使条件风险R(c∣x)R(c|\bm x)R(c∣x)最小的类别标记，即
f(x)=argminc∈YR(c∣x)f(\bm x)=\arg\min_{c\in\mathcal Y}R(c|\bm x)f(x)=argc∈YminR(c∣x)
若损失函数L(Y,f(X))L(Y, f(X))L(Y,f(X))为 0/10/10/1损失，即当预测类别ccc等于真实类别时，损失为0，否则损失为1，则
f(x)=argminc∈Y∑k=1KP(ck≠c∣x)=argminc∈Y(1−P(ck=c∣x))=argmaxc∈YP(c∣x)\begin{aligned}f(\bm x) &=\arg\min_{c\in\mathcal Y}\sum_{k=1}^KP(c_k \neq c|\bm x) \\ &= \arg\min_{c\in\mathcal Y}(1-P(c_k=c|\bm x)) \\ &= \arg\max_{c\in\mathcal Y}P(c|\bm x) \end{aligned}f(x)=argc∈Ymink=1∑KP(ck=c∣x)=argc∈Ymin(1−P(ck=c∣x))=argc∈YmaxP(c∣x)
由上式结果可见，为使总体期望风险最小化，朴素贝叶斯算法对输入x，输出类别为具有后验概率最大的类别。
生成式模型
基于有限训练集，对于给定的x\bm xx估计后验概率P(ck∣x)P(c_k|\bm x)P(ck∣x)有两种策略：
- 直接建模预测P(ck∣x)P(c_k| \bm x)P(ck∣x)，这种模型称之为
判别式模型； - 先建模求出联合概率分布P(Y,X)P(Y,X)P(Y,X)，再通过联合概率分布求解P(ck∣x)P(c_k|\bm x)P(ck∣x)，这种模型称之为
生成式模型；
朴素贝叶斯分类算法属于生成式模型，给定样本x\bm xx，其属于类别ckc_kck的概率为
P(ck∣x)=P(ck,x)P(x)=P(x∣ck)P(ck)∑k=1KP(x∣ck)P(ck)P(c_k|\bm x) =\frac{P(c_k, \bm x)}{P(\bm x)} =\frac{P(\bm x|c_k)P(c_k)}{\sum_{k=1}^KP(\bm x|c_k)P(c_k)} P(ck∣x)=P(x)P(ck,x)=∑k=1KP(x∣ck)P(ck)P(x∣ck)P(ck)
上式中，先验概率P(ck)P(c_k)P(ck)和条件概率P(x∣ck)P(\bm x|c_k)P(x∣ck)为未知量，其计算方法（训练集的统计量）是朴素贝叶斯算法的核心。
朴素假设
基于贝叶斯公式估计后验概率P(ck∣x)P(c_k|\bm x)P(ck∣x)，涉及到条件概率P(x∣ck)P(\bm x|c_k)P(x∣ck)的计算，由于P(x1,⋯,xn∣ck)P(x^1, \cdots, x^n|c_k)P(x1,⋯,xn∣ck)是所有属性上的联合概率，难以从有限的训练集中直接估计得到。
若每个特征取值范围的较大，在计算上也会遭遇组合爆炸和样本稀疏等问题，如对于nnn维的输入x\bm xx，每个特征xjx^jxj有SjS_jSj种取值，YYY可取值有KKK种，则模型参数量（不同的概率数）为K∏j=1nSjK\prod_{j=1}^nS_jK∏j=1nSj。
为了简化条件概率的计算，朴素贝叶斯算法提出朴素假设：用于分类的特征在类别确定条件下相互独立，即
P(x∣ck)=P(x1,x2,⋯,xn∣ck)=∏j=1nP(xj∣ck)\begin{aligned}P(\bm x|c_k) & = P(x^1,x^2, \cdots,x^n|c_k) \\ & = \prod_{j=1}^n P(x^j |c_k) \end{aligned}P(x∣ck)=P(x1,x2,⋯,xn∣ck)=j=1∏nP(xj∣ck)
朴素假设下，模型参数量变为K∑j=1nSjK\sum_{j=1}^nS_jK∑j=1nSj。此时，模型变为
f(x)=argmaxck∈YP(ck∣x)=argmaxck∈YP(x∣ck)⋅P(ck)P(x,ck)=argmaxck∈YP(x∣ck)⋅P(ck)∑k=1KP(x∣ck)⋅P(ck)=argmaxck∈YP(ck)∏j=1nP(xj∣ck)∑k=1KP(ck)∏j=1nP(xj∣ck)\begin{aligned}f(\bm x) &=\arg\max_{c_k\in\mathcal Y}P(c_k|\bm x) =\arg\max_{c_k\in\mathcal Y}\frac{P(\bm x|c_k) \cdot P(c_k)}{P(\bm x,c_k)} \\[1ex] & = \arg\max_{c_k\in\mathcal Y}\frac{P(\bm x|c_k) \cdot P(c_k)}{\displaystyle\sum_{k=1}^KP(\bm x |c_k)\cdot P(c_k)}\\[1ex] & = \arg\max_{c_k\in\mathcal Y}\frac{P(c_k)\displaystyle\prod_{j=1}^n P(x^j|c_k)}{\displaystyle\sum_{k=1}^K P(c_k)\displaystyle\prod_{j=1}^n P(x^j|c_k)}\end{aligned} f(x)=argck∈YmaxP(ck∣x)=argck∈YmaxP(x,ck)P(x∣ck)⋅P(ck)=argck∈Ymaxk=1∑KP(x∣ck)⋅P(ck)P(x∣ck)⋅P(ck)=argck∈Ymaxk=1∑KP(ck)j=1∏nP(xj∣ck)P(ck)j=1∏nP(xj∣ck)
分母对所有的ckc_kck具有相同值，且多个条件概率的乘积可能导致浮点数下界溢出，一般是将概率对数化，最终得到决策模型
f(x)=argmaxck∈Y[logP(ck)+∑j=1nlogP(xj∣ck)]f(\bm x)=\arg\max_{c_k\in\mathcal Y}[\log P(c_k)+\sum_{j=1}^n\log P(x^j|c_k)]f(x)=argck∈Ymax[logP(ck)+j=1∑nlogP(xj∣ck)]
二、模型学习与参数估计
假设样本集X={x1,⋯,xN}X=\{\bm x_1, \cdots, \bm x_N\}X={x1,⋯,xN}，样本xi={xi1,⋯,xin}\bm x_i=\{x_i^1, \cdots, x_i^n\}xi={xi1,⋯,xin}，特征xij∈{aj1,⋯,ajSj}x_i^j \in \{a_j^1, \cdots, a_j^{S_j}\}xij∈{aj1,⋯,ajSj}，标签集Y={y1,y2,⋯,yN}Y=\{y_1, y_2, \cdots, y_N\}Y={y1,y2,⋯,yN}，标签yi∈{c1,⋯,cK}y_i\in\{c_1, \cdots, c_K\}yi∈{c1,⋯,cK}。
朴素贝叶斯算法的学习，意味着由给定的样本信息估计出先验概率P(ck)P(c_k)P(ck)和类条件概率P(ajl∣ck)P(a_j^l|c_k)P(ajl∣ck)。
由于朴素贝叶斯有多种模型，各模型中计算先验概率和类条件概率的方法有所不同，如伯努利模型（文本型）和多项式模型（词频型），由于朴素贝叶斯多用于文档分类，因此才有了文本性和词频型的区分，其实这些模型并不局限于文本分类。当特征值存在连续值时，可使用高斯模型。
伯努利模型（文本型）
伯努利模型中每个特征的取值范围为{0,1}\{0,1\}{0,1}，即Sj=2S_j=2Sj=2，忽略了特征出现的次数。伯努利模型以实例数（文本数）为粒度，在计算类条件概率时，对于未出现的特征（特征值为0），依旧需要参与概率的计算。
文本可理解为训练集中的样例，由极大似然估计可得
P(ck)=类ck下所有样本数训练集所有样本数P(ajl∣ck)=类ck下第j个特征为ajl的样本数类ck下所有样本数P(c_k)=\frac{类c_k下所有样本数}{训练集所有样本数} \\ \,\\ P(a_j^l |c_k) = \frac{类c_k下第j个特征为a_j^l的样本数}{类c_k下所有样本数}P(ck)=训练集所有样本数类ck下所有样本数P(ajl∣ck)=类ck下所有样本数类ck下第j个特征为ajl的样本数
考虑到训练集容量有限，直接计算先验概率和条件概率可能出现概率值为0的情况，概率计算引入平滑因子λ\lambdaλ
P(ajl∣ck)=类ck下第j个特征为ajl的样本数+λ类ck下所有样本数+2λP(a_j^l |c_k) = \frac{类c_k下第j个特征为a_j^l的样本数+\lambda}{类c_k下所有样本数+2\lambda}P(ajl∣ck)=类ck下所有样本数+2λ类ck下第j个特征为ajl的样本数+λ
特殊地，当λ=1\lambda=1λ=1时，上式称为拉普拉斯平滑，分母加2，可理解为对于任何一类均添加包含所有特征和不包含所有特征的两个样本。注：sklearn源码实现，先验概率未引入平滑因子。
引理：先验概率P(ck)P(c_k)P(ck)的极大似然估计
令θ=P(y=ck)\theta=P(y =c_k)θ=P(y=ck)，显然1−θ=P(y≠ck)1 - \theta=P(y\neq c_k)1−θ=P(y=ck)，因此可将标签集YYY看作为服从0-1分布，即
P(y)=θI(y=ck)(1−θ)1−I(y=ck)P(y)=\theta^{I(y=c_k)}(1-\theta)^{1-I(y=c_k)}P(y)=θI(y=ck)(1−θ)1−I(y=ck)
上式中，III为指示函数，即当y=cky=c_ky=ck时指示函数为1，否则为0。因此，θ\thetaθ的对数似然函数
logP(Y∣θ)=log∏i=1NθI(yi=ck)(1−θ)1−I(yi=ck)\log P(Y|\theta) = \log\prod_{i=1}^N \theta^{I(y_i=c_k)}(1-\theta)^{1-I(y_i=c_k)}logP(Y∣θ)=logi=1∏NθI(yi=ck)(1−θ)1−I(yi=ck)
求θ\thetaθ的偏导并令其为0，得θ=∑i=1NI(yi=ck)/N\theta=\displaystyle\sum_{i=1}^N I(y_i=c_k)/Nθ=i=1∑NI(yi=ck)/N。
实例1
| No. | doc | label |
|---|---|---|
| 1 | apple orange apple | fruit |
| 2 | apple orange potato | fruit |
| 3 | orange orange grape | fruit |
| 4 | potato cabbage | vegetable |
词集：【apple，cabbage，grape，orange，potato】，标签集：【fruit，vegetable】，求【apple apple grape】的类别？
解： 将每一个文档向量化（特征值为0或1），则四个文档的特征向量分别为
| No. | apple | cabbage | grape | orange | potato | label |
|---|---|---|---|---|---|---|
| 1 | 1 | 0 | 0 | 1 | 0 | fruit |
| 2 | 1 | 0 | 0 | 1 | 1 | fruit |
| 3 | 0 | 0 | 1 | 1 | 0 | fruit |
| 4 | 0 | 1 | 0 | 0 | 1 | vegetable |
待预测实例【apple apple grape】的特征向量为[1, 0, 1, 0, 0]，因此
P(apple∣fruit)=2+13+2=35,P(cabbage∣fruit)=0+13+2=15,P(grape∣fruit)=1+13+2=25P(orange∣fruit)=3+13+2=45,P(potato∣fruit)=1+13+2=25,P(fruit)=34\begin{aligned} &P({\sf {apple}}|{\sf fruit}) =\frac{2+1}{3+2}=\frac{3}{5},\quad P({\sf \xcancel{cabbage}}|{\sf fruit}) =\frac{0+1}{3+2}=\frac{1}{5},\quad P({\sf {grape}}|{\sf fruit}) =\frac{1+1}{3+2}=\frac{2}{5}\\\,\\ &P({\sf \xcancel{orange}}|{\sf fruit}) =\frac{3+1}{3+2}=\frac{4}{5},\quad P({\sf \xcancel{potato}}|{\sf fruit}) =\frac{1+1}{3+2}=\frac{2}{5},\quad P({\sf fruit})=\frac{3}{4} \end{aligned}P(apple∣fruit)=3+22+1=53,P(cabbage∣fruit)=3+20+1=51,P(grape∣fruit)=3+21+1=52P(orange∣fruit)=3+23+1=54,P(potato∣fruit)=3+21+1=52,P(fruit)=43
因此
P(apple,apple,grape∣fruit)=P(apple∣fruit)⋯P(potato∣fruit)P(fruit)=35⋅15⋅25⋅45⋅25⋅34=0.01152\begin{aligned}P({\sf apple, apple, grape|fruit}) &=P({\sf {apple}}|{\sf fruit}) \cdots P({\sf \xcancel{potato}}|{\sf fruit})P({\sf fruit})\\ &=\frac{3}{5}\cdot\frac{1}{5}\cdot\frac{2}{5}\cdot\frac{4}{5}\cdot\frac{2}{5}\cdot\frac{3}{4}=0.01152 \end{aligned}P(apple,apple,grape∣fruit)=P(apple∣fruit)⋯P(potato∣fruit)P(fruit)=53⋅51⋅52⋅54⋅52⋅43=0.01152
同理
P(apple,apple,grape∣vegetable)=P(apple∣vegetable)⋯P(potato∣vegetable)P(vegetable)=13⋅13⋅13⋅13⋅13⋅14=0.00103\begin{aligned}P({\sf apple, apple, grape|vegetable}) &=P({\sf {apple}}|{\sf vegetable}) \cdots P({\sf \xcancel{potato}}|{\sf vegetable})P({\sf vegetable})\\ &=\frac{1}{3}\cdot\frac{1}{3}\cdot\frac{1}{3}\cdot\frac{1}{3}\cdot\frac{1}{3}\cdot\frac{1}{4}=0.00103 \end{aligned}P(apple,apple,grape∣vegetable)=P(apple∣vegetable)⋯P(potato∣vegetable)P(vegetable)=31⋅31⋅31⋅31⋅31⋅41=0.00103
显然，样本【apple apple grape】属于fruit的概率更大。
多项式模型（词频型）
多项式模型中特征值为该特征出现的次数。多项式模型以特征数（词频）为粒度，在计算类条件概率时，对于未出现的特征（特征值为0），不需要参与概率的计算。
词频可理解为某特征出现的次数，概率计算公式如下：
P(ck)=类ck下所有特征数训练集所有特征数P(aj∣ck)=类ck下第j个特征aj出现的次数之和类ck下所有特征数P(c_k)=\frac{类c_k下所有特征数}{训练集所有特征数} \\\,\\ P(a_j |c_k) = \frac{类c_k下第j个特征a_j出现的次数之和}{类c_k下所有特征数} P(ck)=训练集所有特征数类ck下所有特征数P(aj∣ck)=类ck下所有特征数类ck下第j个特征aj出现的次数之和
对于输入向量x∈Rn\bm x \in R^nx∈Rn，加入平滑因子λ\lambdaλ，如下：
P(aj∣ck)=类ck下第j个特征aj出现的次数之和+λ类ck下所有特征数+λnP(a_j |c_k) = \frac{类c_k下第j个特征a_j出现的次数之和 + \lambda}{类c_k下所有特征数 + \lambda n} P(aj∣ck)=类ck下所有特征数+λn类ck下第j个特征aj出现的次数之和+λ
因此，对于实例1中的文档，使用多项式模型向量化得
| No. | apple | cabbage | grape | orange | potato | label |
|---|---|---|---|---|---|---|
| 1 | 2 | 0 | 0 | 1 | 0 | fruit |
| 2 | 1 | 0 | 0 | 1 | 1 | fruit |
| 3 | 0 | 0 | 1 | 2 | 0 | fruit |
| 4 | 0 | 1 | 0 | 0 | 1 | vegetable |
待预测实例【apple apple grape】的特征向量为[2, 0, 1, 0, 0]，因此
P(apple∣fruit)=2+19+5=314,P(grape∣fruit)=1+19+5=214,P(fruit)=911\begin{aligned} &P({\sf {apple}}|{\sf fruit}) =\frac{2+1}{9+5}=\frac{3}{14 },\quad P({\sf {grape}}|{\sf fruit}) =\frac{1+1}{9+5}=\frac{2}{14},\quad P({\sf fruit})=\frac{9}{11} \end{aligned}P(apple∣fruit)=9+52+1=143,P(grape∣fruit)=9+51+1=142,P(fruit)=119
因此
P(apple,apple,grape∣fruit)=P(apple∣fruit)2P(garpe∣fruit)P(fruit)=(314)2⋅214⋅911=0.00537\begin{aligned}P({\sf apple, apple, grape|fruit}) &=P({\sf {apple}}|{\sf fruit})^2P(\sf{garpe|fruit})P({\sf fruit})\\ &=(\frac{3}{14})^2\cdot\frac{2}{14}\cdot\frac{9}{11}=0.00537 \end{aligned}P(apple,apple,grape∣fruit)=P(apple∣fruit)2P(garpe∣fruit)P(fruit)=(143)2⋅142⋅119=0.00537
同理
P(apple,apple,grape∣vegetable)=P(apple∣vegetable)2P(garpe∣vegetable)P(vegetable)=(114)2⋅114⋅211=0.00007\begin{aligned}P({\sf apple, apple, grape|vegetable}) &=P({\sf {apple}}|{\sf vegetable})^2P(\sf{garpe|vegetable})P({\sf vegetable})\\ &=(\frac{1}{14})^2\cdot\frac{1}{14}\cdot\frac{2}{11}=0.00007 \end{aligned}P(apple,apple,grape∣vegetable)=P(apple∣vegetable)2P(garpe∣vegetable)P(vegetable)=(141)2⋅141⋅112=0.00007
显然，样本【apple apple grape】属于fruit的概率更大。
高斯模型
对连续属性可考虑概率密度函数，假设P(aj∣c)∼N(μc,j,σc,j2)P(a_j|c)\sim \mathcal N(\mu_{c,j},\sigma_{c,j}^2)P(aj∣c)∼N(μc,j,σc,j2)，其中μc,j\mu_{c,j}μc,j和σc,j2\sigma_{c,j}^2σc,j2分别是类ccc样本下第jjj个属性取值的均值和方差。则有
P(aj∣c)=12πσc,jexp(−(aj−uc,j)22σc,j2)P(a_j|c) = \frac{1}{\sqrt{2\pi}\sigma_{c,j}}\exp\left(-\frac{(a_j-u_{c,j})^2}{2\sigma_{c,j}^2}\right)P(aj∣c)=2πσc,j1exp(−2σc,j2(aj−uc,j)2)
三、Python实现
伯努利模型
# -*- coding: utf-8 -*-
import numpy as npclass BernoulliNB(object):def fit(self, X, y, alpha=1.0):"""模型训练"""X = self._check_array(X)self.classes_, Y = self.labelbin(y)if not np.any((X != 0) | (X != 1)):raise ValueError("Input X must be 0 or 1.")self.feature_count_ = np.dot(Y.T, X)self.class_count_ = Y.sum(axis=0)smoothed_fc = self.feature_count_ + alphasmoothed_cc = self.class_count_ + alpha * 2self.p_feature = (np.log(smoothed_fc) -np.log(smoothed_cc.reshape(-1, 1)))self.p_feature_neg = np.log(1 - np.exp(self.p_feature))self.p_class = (np.log(self.class_count_) -np.log(self.class_count_.sum()))def predict(self, X):"""类别预测"""if not hasattr(self, 'p_feature'):raise ValueError('Instance must be fitted.')X = self._check_array(X)n_classes, n_features = self.p_feature.shapen_samples, n_features_X = X.shapeif n_features_X != n_features:raise ValueError('Expect input with %d features.' % n_samples)p = np.dot(X, (self.p_feature - self.p_feature_neg).T)p += self.p_class + self.p_feature_neg.sum(axis=1)return self.classes_[np.argmax(p, axis=1)]def _check_array(self, array):"""检查输入格式"""array = np.asarray(array)if array.ndim != 2:raise ValueError('Expected 2D array.')return array@staticmethoddef labelbin(y):"""标签二进制化"""Y = np.ravel(y)classes = np.array(sorted(set(Y)))indices = np.searchsorted(classes, Y)n_samples = Y.shape[0]n_classes = len(classes)Y = np.zeros((n_samples, n_classes), dtype=int)rows = np.arange(n_samples)Y[rows, indices] = 1return classes, Yif __name__ == '__main__':X = np.random.randint(2, size=(6, 100))y = np.array([1, 2, 3, 4, 4, 5])clf = BernoulliNB()clf.fit(X, y)print(clf.predict(X[2:3]))
多项式模型
# -*- coding: utf-8 -*-
import numpy as npclass MultinomialNB(object):def fit(self, X, y, alpha=1.0):"""模型训练"""X = self._check_array(X)if np.any(X < 0):raise ValueError("Input X must be non-negative")self.classes_, Y = self.labelbin(y)self.feature_count_ = np.dot(Y.T, X)self.class_count_ = Y.sum(axis=0)smoothed_fc = self.feature_count_ + alphasmoothed_cc = smoothed_fc.sum(axis=1)self.p_feature = (np.log(smoothed_fc) -np.log(smoothed_cc.reshape(-1, 1)))cc = self.feature_count_.sum(axis=1)self.p_class = np.log(cc) - np.log(cc.sum())def predict(self, X):"""类别预测"""X = self._check_array(X)if not hasattr(self, 'p_feature'):raise ValueError('Instance must be fitted.')n_classes, n_features = self.p_feature.shapen_samples, n_features_X = X.shapeif n_features_X != n_features:raise ValueError('Expect input with %d features.' % n_samples)p = np.dot(X, self.p_feature.T) + self.p_classreturn self.classes_[np.argmax(p, axis=1)]def _check_array(self, array):"""检查输入格式"""array = np.asarray(array)if array.ndim != 2:raise ValueError('Expected 2D array.')return array@staticmethoddef labelbin(y):"""标签二进制化"""Y = np.ravel(y)classes = np.array(sorted(set(Y)))indices = np.searchsorted(classes, Y)n_samples = Y.shape[0]n_classes = len(classes)Y = np.zeros((n_samples, n_classes), dtype=int)rows = np.arange(n_samples)Y[rows, indices] = 1return classes, Yif __name__ == '__main__':X = np.random.randint(5, size=(6, 100))y = np.array([1, 1, 3, 3, 5, 6])clf = MultinomialNB()clf.fit(X, y)print(clf.predict(X[2:3]))
高斯模型
# -*- coding: utf-8 -*-
import numpy as npclass GaussianNB(object):def fit(self, X, y):"""模型训练"""y = np.ravel(y)X = self._check_array(X)self.classes_ = np.array(sorted(set(y)))n_features = X.shape[1]n_classes = len(self.classes_)self.mu_ = np.zeros((n_classes, n_features))self.var_ = np.zeros((n_classes, n_features))self.class_count_ = np.zeros(n_classes, dtype=np.float64)for i, y_i in enumerate(self.classes_):X_i = X[y == y_i]self.class_count_[i] = np.shape(X_i)[0]self.mu_[i] = np.mean(X_i, axis=0)self.var_[i] = np.var(X_i, axis=0)epsilon = 1e-9 * np.var(X, axis=0).max()self.var_ += epsilonself.p_class = self.class_count_ / self.class_count_.sum()def predict(self, X):"""类别预测"""X = self._check_array(X)n_samples = X.shape[0]n_classes = self.classes_.shape[0]p_log = np.zeros((n_classes, n_samples))for i in range(n_classes):cc_log = np.log(self.p_class[i])fc_log = -0.5 * np.sum(np.log(2 * np.pi * self.var_[i]))fc_log -= 0.5 * np.sum((X - self.mu_[i]) ** 2 / self.var_[i], axis=1)p_log[i] = cc_log + fc_logreturn self.classes_[np.argmax(p_log, axis=0)]def _check_array(self, array):"""检查输入格式"""array = np.asarray(array)if array.ndim != 2:raise ValueError('Expected 2D array.')return arrayif __name__ == '__main__':X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])Y = np.array([1, 1, 1, 2, 2, 2])clf = GaussianNB()clf.fit(X, Y)print(clf.predict(X))
四、多项式模型之文本分类
文本的特征是词列表，应首先将文本向量化，文本特征向量的长度等于词表（所有文本中不重复的单次）长度。
class Words2Vec(object):def fit(self, X):vob = sorted(set(w for ws in X for w in ws))self.vec_length = len(vob)self.vob_dict = dict(zip(vob, range(self.vec_length)))def words2vec(self, n_words):"""文本词列表转换为词向量"""if not hasattr(self, 'vob_dict'):raise ValueError('Instance must be fitted.')n_samples = len(n_words)vectors = np.zeros((n_samples, self.vec_length), dtype=int)for i, words in enumerate(n_words):vec = vectors[i]for w in words:index = self.vob_dict.get(w, None)if index is not None:vec[index] += 1return vectorsX = [['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']]
y = ['0', '1', '0', '1', '0', '1']wv = Words2Vec()
wv.fit(X)
X = wv.words2vec(X)clf = MultinomialNB()
clf.fit(X, y)
print(clf.predict(X))X = wv.words2vec([['dog', 'dog', 'ate']])
print(clf.predict(X))
朴素贝叶斯法原理及其python实现相关推荐
- 朴素贝叶斯算法原理以及python实现
朴素贝叶斯 一.朴素贝叶斯概述 二.概率论知识 三.朴素贝叶斯算法原理 四.参数估计方法 五.示例分析 六.拉普拉斯平滑修正 七.算法优缺点 八.python实现 8.1 sklearn贝叶斯 8.2 ...
- 朴素贝叶斯法的参数估计——贝叶斯估计及其Python实现
统计学习方法--朴素贝叶斯法原理 1. 贝叶斯估计 1.1 为什么要用贝叶斯估计(极大似然的缺点) 1.2 贝叶斯估计原理 贝叶斯估计的算法过程合极大似然估计的算法过程一模一样,代码也几乎一模一样,只 ...
- python朴素贝叶斯分布对数据的要求_统计学习方法与Python实现（三）——朴素贝叶斯法...
统计学习方法与Python实现(三)--朴素贝叶斯法 1.定义 朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法. 对于给定的训练数据集,首先基于特征条件独立假设学习输入输出的联合概率分布.然 ...
- java mllib 算法_朴素贝叶斯算法原理及Spark MLlib实例(Scala/Java/Python)
朴素贝叶斯 算法介绍: 朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法. 朴素贝叶斯的思想基础是这样的:对于给出的待分类项,求解在此项出现的条件下各个类别出现的概率,在没有其它可用信息下,我 ...
- 朴素贝叶斯法及python实现
文章目录 朴素贝叶斯法概述 1. 定理及公式推导 1.1 定理: 1.2 朴素贝叶斯 1.3 条件独立的假设是: 1.4 先验概率后验概率 1.5 极大似然估计 2. python实现 朴素贝叶斯法概 ...
- 朴素贝叶斯法分类器的Python3 实现
本篇文章是我在读了李航的<统计学习方法>后手写的算法实现之一 原理请参考统计学习方法第四章朴素贝叶斯法-李航 代码如下: # - * - coding: utf - 8 -*- # # 作 ...
- 线性分类（五）-- 朴素贝叶斯法
贝叶斯分类是一类分类算法的总称,这类算法均以贝叶斯定理为基础,故统称为贝叶斯分类.贝叶斯分类法是统计学分类方法,它可以预测类隶属关系的概率,如一个给定元组属于一个特定类的概率.而朴素贝叶斯分类是贝叶斯 ...
- 机器学习理论《统计学习方法》学习笔记：第四章 朴素贝叶斯法
机器学习理论<统计学习方法>学习笔记:第四章 朴素贝叶斯法 4 朴素贝叶斯法 4.1 朴素贝叶斯法的学习与分类 4.1.1 基本方法 4.1.2 后验概率最大化的含义 4.2 朴素贝叶斯法 ...
- 机器学习之朴素贝叶斯法
转载请注明出处:http://www.cnblogs.com/Peyton-Li/ 朴素贝叶斯法是机器学习模型中一个比较简单的模型,实现简单,比较常用. 是定义在输入空间上的随机向量,是定义在输出空间 ...
最新文章
- 网络编程五种IO模型之poll模型
- Quartz.net基于数据库的任务调度管理(Only.Jobs)
- integer对应java类型_Java中的Integer和int等包装类和基本数据类型简单比较
- [修复] Firemonkey 使用 DrawPath 断线问题（Android iOS 平台）
- ab753变频器中文说明书_怎样快速学习使用和维修变频器
- 关于PCBLayout的一些具体细节的认识（能力有限，请大家多多指点）
- TF-IDF算法原理和公式
- 国内十大上市移动医疗企业盘点
- Cesium 源码解析 Model（二）
- c语言.jpg图片转成数组_怎么把Word转成PDF？一个PDF转换软件就能搞定！
- 移动硬盘文件夹不见了怎么办?
- 耿建超英语语法---定语从句
- 行业调研：Platform Ops
- 风无定，人无常，人生如浮萍，聚散两茫茫——元组类型、字典类型的内置方法，第九天
- android 读取歌词.qrc,教程1：如何制作QRC歌词.doc
- SAP与金蝶星瀚：ERP销售业务实现技术方式区别
- letswave教程：脑电数据图形绘制、批处理以及脚本生成
- 【API】聊天机器人接口
- 左值右值将亡值泛左值
- 微信浏览器中唤醒APP到指定页