机器学习 —— 朴素贝叶斯简单入门

• 1. 概念理解
• • 1.1 数理基础
  • • 1.1.1 贝叶斯概率
    • • 1.1.1.1 条件概率
      • 1.1.1.2 什么是条件概率
      • 1.1.1.3 怎样计算条件概率
      • 1.1.1.4 乘法定理
      • 1.1.1.5 一些计算题
    • 1.1.2 全概率公式
    • • 1.1.2.1 引例
      • 1.1.2.2 全概率公式
    • 1.1.3 贝叶斯公式
    • • 1.1.3.1 选择题
• 2. 例子解析
• • 2.1 好瓜坏瓜都是西瓜
  • • 2.1.1 朴素贝叶斯分类算法的预测流程
    • 2.1.2 朴素贝叶斯分类算法的训练流程
  • 2.2 好坏西瓜都要平滑
  • 2.3 新闻文本主题分类
  • • 2.3.1 数据简介
    • 2.3.2 文本向量化
    • 2.3.3 MultinomialNB
• 3. 代码实例
• • 3.1 好瓜坏瓜都是西瓜
  • • 3.1.1 编程要求
    • 3.1.2 测试说明
    • 3.1.3 实际代码
  • 3.2 好坏西瓜都要平滑
  • • 3.2.1 代码示例
  • 3.3 新闻文本主题分类
  • • 3.3.1 编程要求
    • 3.3.2 测试说明
    • 3.3.3 代码示例
• 4. 应用举例
• • 4.1 垃圾邮件过滤
• 5. Python学习

1. 概念理解

1.1 数理基础

很无聊，不想看的可以不看。

1.1.1 贝叶斯概率

1.1.1.1 条件概率

朴素贝叶斯分类算法是基于贝叶斯定理与特征条件独立假设的分类方法，因此想要了解朴素贝叶斯分类算法背后的算法原理，就不得不用到概率论的一些知识，首当其冲就是条件概率。接下来就开启我们的条件概率之旅吧。

1.1.1.2 什么是条件概率

概率指的是某一事件A发生的可能性，表示为P(A)。而条件概率指的是某一事件A已经发生了条件下，另一事件B发生的可能性，表示为P(B|A)，举个例子：

今天有25%的可能性下雨，即P(下雨)=0.25;
今天75%的可能性是晴天，即P(晴天)=0.75;
如果下雨，我有75%的可能性穿外套，即P(穿外套|下雨)=0.75;
如果下雨，我有25%的可能性穿T恤，即P(穿T恤|下雨)=0.25;

从上述例子可以看出，条件概率描述的是 | 右边的事件已经发生之后，左边的事件发生的可能性，而不是两个事件同时发生的可能性！

1.1.1.3 怎样计算条件概率

设A，B是两个事件，且P(A)>0，称P(B|A)=P(AB)/P(A)为在事件A发生的条件下，事件B发生的条件概率。(其中P(AB)表示事件A和事件B同时发生的概率)

举个例子，现在有一个表格，表格中统计了甲乙两个厂生产的产品中合格品数量、次品数量的数据。数据如下：

现在想要算一下已知产品是甲厂生产的，那么产品是次品的概率是多少。这个时候其实就是在算条件概率，计算非常简单。

假设事件A为产品是甲厂生产的，事件B为产品是次品。则根据表中数据可知P(AB)=25/1200，P(A)=500/1200。则P(B|A)=P(AB)/P(A)=25/500。

1.1.1.4 乘法定理

将条件概率的公式两边同时乘以P(A)，就变成了乘法定理，即P(AB)=P(B|A)*P(A)。那么乘法定理怎么用呢？举个例子：

现在有一批产品共100件，次品有10件，从中不放回地抽取2次，每次取1件。现在想要算一下第一次为次品，第二次为正品的概率。

从问题来看，这个问题问的是第一次为次品，第二次为正品这两个事件同时发生的概率。所以可以用乘法定理来解决这个问题。

假设事件A为第一次为次品，事件B为第二次为正品。则P(AB)=P(A)P(B|A)=(10/100)(90/99)=0.091。

1.1.1.5 一些计算题

1、P(AB)表示的是事件A与事件B同时发生的概率，P(A|B)表示的是事件B已经发生的条件下，事件A发生的概率。

A、对
B、错

2、从1,2,…,15中小明和小红两人各任取一个数字，现已知小明取到的数字是5的倍数，请问小明取到的数大于小红取到的数的概率是多少？

A、7/14
B、8/14
C、9/14
D、10/14

1.1.2 全概率公式

贝叶斯公式是朴素贝叶斯分类算法的核心数学理论，在了解贝叶斯公式之前，我们需要先了解全概率公式的相关知识。

1.1.2.1 引例

小明从家到公司上班总共有三条路可以直达，如下图：

但是每条路每天拥堵的可能性不太一样，由于路的远近不同，选择每条路的概率如下所示：
L1：0.5 ；L2：0.3 ；L3：0.2。
每天从上述三条路去公司时不堵车的概率如下所示：
L1不堵车 ：0.2 ；L2不堵车 ：0.4 ；L3不堵车：0.7。

如果不堵车就不会迟到，现在小明想要算一算去公司上班不会迟到的概率是多少，应该怎么办呢？
其实很简单，假设事件C为小明不迟到，事件A1为小明选L1这条路并且不堵车，事件A2为小明选L2这条路并且不堵车，事件A3为小明选L3这条路并且不堵车。那么很显然P©=P(A1)+P(A2)+P(A3)。

那么问题来了，P(A1)、P(A2)和P(A3)怎么算呢？其实只要会算P(A1)其他的就都会算了。我们同样可以假设事件D1为小明选择L1路，事件E1为不堵车。那么P(A1)=P(D1)*P(E1)。但是在从表格中我们只知道P(D1)=0.5，怎么办呢？

回忆一下上一关介绍的乘法定理，不难想到P(A1)=P(D1)P(E1|D1)。从表格中可以看出P(E1|D1)=0.2。因此P(A1)=0.50.2=0.1。

然后依葫芦画瓢可以很快算出，P(A2)=0.30.4=0.12，P(A3)=0.20.7=0.14。所以P©=0.1+0.12+0.14=0.36。

1.1.2.2 全概率公式

当为了达到某种目的，但是达到目的有很多种方式，如果想知道通过所有方式能够达到目的的概率是多少的话，就需要用到全概率公式（上面的例子就是这种情况！）。全概率公式的定义如下：

若事件B1 ,B2 ,…,Bn 两两互不相容，并且其概率和为1。那么对于任意一个事件C都满足：

引例中小明选择哪条路去公司的概率是两两互不相容的（只能选其中一条路去公司），并且和为1。所以小明不迟到的概率可以通过全概率公式来计算，而引例中的计算过程就是用的全概率公式。

1.1.3 贝叶斯公式

当已知引发事件发生的各种原因的概率，想要算该事件发生的概率时，我们可以用全概率公式。但如果现在反过来，已知事件已经发生了，但想要计算引发该事件的各种原因的概率时，我们就需要用到贝叶斯公式了。

贝叶斯公式定义如下，其中A表示已经发生的事件，Bi 为导致事件A发生的第i个原因：

贝叶斯公式看起来比较复杂，其实非常简单，分子部分是乘法定理，分母部分是全概率公式（分母等于P(A)）。

如果我们对贝叶斯公式进行一个简单的数学变换（两边同时乘以分母，再两边同时除以P(Bi )）。就能够得到如下公式：

这个公式是朴素贝叶斯分类算法的核心数学公式。

1.1.3.1 选择题

1、对以往数据分析结果表明，当机器调整得良好时，产品的合格率为98%，而当机器发生某种故障时，产品的合格率为55%。每天早上机器开动时，机器调整得良好的概率为95%。计算已知某日早上第一件产品是合格时，机器调整得良好的概率是多少？

A、0.94
B、0.95
C、0.96
D、0.97

2、一批产品共8件，其中正品6件，次品2件。现不放回地从中取产品两次，每次一件，求第二次取得正品的概率。

A、1/4
B、1/2
C、3/4
D、1

2. 例子解析

2.1 好瓜坏瓜都是西瓜

在炎热的夏天你可能需要买一个大西瓜来解暑，但虽然你的挑西瓜的经验很老道，但还是会有挑错的时候。尽管如此，你可能还是更愿意相信自己经验。假设现在在你面前有一个纹路清晰，拍打西瓜后声音浑厚，按照你的经验来看这个西瓜是好瓜的概率有80%，不是好瓜的概率有20%。那么在这个时候你下意识会认为这个西瓜是好瓜，因为它是好瓜的概率大于不是好瓜的概率。

2.1.1 朴素贝叶斯分类算法的预测流程

朴素贝叶斯分类算法的预测思想和引例中挑西瓜的思想一样，会根据以往的经验计算出待预测数据分别为所有类别的概率，然后挑选其中概率最高的类别作为分类结果。

假如现在一个西瓜的数据如下表所示：

若想使用朴素贝叶斯分类算法的思想，根据这条数据中颜色、声音和纹理这三个特征来推断是不是好瓜，我们需要计算出这个西瓜是好瓜的概率和不是好瓜的概率。

假设事件A1为好瓜，事件B为绿，事件C为清脆，事件D为清晰，则这个西瓜是好瓜的概率为P(A1|BCD)。根据上一关中最后提到的公式可知:

同样，假设事件A2为不是好瓜，事件B为绿，事件C为清脆，事件D为清晰，则这个西瓜不是好瓜的概率为P(A2|BCD)。根据上一关中最后提到的公式可知:

朴素贝叶斯分类算法的思想是取概率最大的类别作为预测结果，所以如果满足下面的式子，则认为这个西瓜是好瓜，否则就不是好瓜：

从上面的式子可以看出，P(BCD)是多少对于判断哪个类别的概率高没有影响，所以式子可以简化成如下形式：

所以在预测时，需要知道P(A1)，P(A2)，P(B|A_1)，P(C|A_1)，P(D|A_1)等于多少。而这些概率在训练阶段可以计算出来。

2.1.2 朴素贝叶斯分类算法的训练流程

训练的流程非常简单，主要是计算各种条件概率。假设现在有一组西瓜的数据，如下表所示：

从表中数据可以看出：
P(是好瓜)=4/6，
P(颜色绿|是好瓜)=3/4，
P(颜色黄|是好瓜)=1/4，
P(声音清脆|是好瓜)=1/2，
P(声音浑厚|是好瓜)=1/2，
P(纹理清晰|是好瓜)=1/2，
P(纹理模糊|是好瓜)=1/2，
P(不是好瓜)=2/6，
P(颜色绿|不是好瓜)=1/2，
P(颜色黄|是好瓜)=1/2，
P(声音清脆|不是好瓜)=1/2，
P(声音浑厚|不是好瓜)=1/2，
P(纹理清晰|不是好瓜)=1/2，
P(纹理模糊|不是好瓜)=1/2。

当得到以上概率后，训练阶段的任务就已经完成了。我们不妨再回过头来预测一下这个西瓜是不是好瓜。

假设事件A1为好瓜，事件B为绿，事件C为清脆，事件D为清晰。则有：

假设事件A2为不是好瓜，事件B为绿，事件C为清脆，事件D为清晰。则有：

由于 1/8 > 1/24，所以这个西瓜是好瓜。

2.2 好坏西瓜都要平滑

拉普拉斯平滑
假设现在有这样一批西瓜的数据，如果根据上一关中所提到的知识您应该能很快的知道应该怎样训练模型。

但是需要注意的是，在不是好瓜的数据中没有一条数据中纹理是模糊的，也就是说 P(模糊|否)=0 。很显然，如果不做任何处理，那么在预测时，只要预测数据中的纹理的值是模糊，模型预测出不是好瓜的概率就一定是 0 （概率是连乘的，只要有一项是 0 那么结果就是 0 ）。这显然是不合理的，所以我们要进行平滑处理，而最常用的方法就是拉普拉斯平滑。

拉普拉斯平滑指的是，假设N表示训练数据集总共有多少种类别， Ni 表示训练数据集中第i列总共有多少种取值。则训练过程中在算类别的概率时分子加 1 ，分母加 N ，算条件概率时分子加 1 ，分母加 Ni 。

接下来用上面的西瓜数据来模拟一下，从表格知
N=2，N1=2，N2=2，N3=2。

P(是好瓜)=(4+1)/(6+2)，
P(颜色绿|是好瓜)=(3+1)/(4+2)，
P(颜色黄|是好瓜)=(1+1)/(4+2)，
P(声音清脆|是好瓜)=(1+1)/(2+2)，
P(声音浑厚|是好瓜)=(1+1)/(2+2)，
P(纹理清晰|是好瓜)=(1+1)/(2+2)，
P(纹理模糊|是好瓜)=(1+1)/(2+2)，
P(不是好瓜)=(2+1)/(6+2)，
P(颜色绿|不是好瓜)=(1+1)/(2+2)，
P(颜色黄|是好瓜)=(1+1)/(2+2)，
P(声音清脆|不是好瓜)=(1+1)/(2+2)，
P(声音浑厚|不是好瓜)=(1+1)/(2+2)，
P(纹理清晰|不是好瓜)=(1+1)/(2+2)，
P(纹理模糊|不是好瓜)=(0+1)/(2+2)。

可以看出，经过拉普拉斯平滑后， P(模糊|否) 平滑成了 1/4 ，使得模型更加合理。

2.3 新闻文本主题分类

需要掌握如何使用 sklearn 提供的 MultinomialNB 类与文本向量化。

2.3.1 数据简介

本关使用的是 20newsgroups 数据集， 20newsgroups 数据集是用于文本分类、文本挖据和信息检索研究的国际标准数据集之一。数据集收集了 18846 篇新闻组文档，均匀分为 20 个不同主题（比如电脑硬件、中东等主题）的新闻组集合。
部分数据如下：

From: Mamatha Devineni Ratnam <mr47+@andrew.cmu.edu>
Subject: Pens fans reactions
Organization: Post Office, Carnegie Mellon, Pittsburgh, PA
Lines: 12
NNTP-Posting-Host: po4.andrew.cmu.edu
I am sure some bashers of Pens fans are pretty confused about the lack
of any kind of posts about the recent Pens massacre of the Devils. Actually,
I am bit puzzled too and a bit relieved. However, I am going to put an end
to non-PIttsburghers relief with a bit of praise for the Pens. Man, they
are killing those Devils worse than I thought. Jagr just showed you why
he is much better than his regular season stats. He is also a lot
fo fun to watch in the playoffs. Bowman should let JAgr have a lot of
fun in the next couple of games since the Pens are going to beat the pulp out of Jersey anyway. I was very disappointed not to see the Islanders lose the final
regular season game. PENS RULE!!!

其中新闻文本对应的主题标签，已经用0-19这20个数字表示。

2.3.2 文本向量化

由于数据集中每一条数据都是很长的一个字符串，所以我们需要对数据进行向量化的处理。例如，I have a apple！ I have a pen! 可能需要将该字符串转换成向量如[10, 7, 0, 1, 2, 6, 22, 100, 8, 0, 1, 0]。

sklearn 提供了实现词频向量化功能的 CountVectorizer 类。想要对数据进行向量化，代码如下：

from sklearn.feature_ext\fraction.text import CountVectorizer
#实例化向量化对象
vec = CountVectorizer()
#将训练集中的新闻向量化
X_train = vec.fit_transform(X_train)
#将测试集中的新闻向量化
X_test = vec.transform(X_test)

但是仅仅通过统计词频的方式来将文本转换成向量会出现一个问题：长的文章词语出现的次数会比短的文章要多，而实际上两篇文章可能谈论的都是同一个主题。

为了解决这个问题，我们可以使用 tf-idf 来构建文本向量， sklearn 中已经提供了 tf-idf 的接口，示例代码如下：

from sklearn.feature_ext\fraction.text import TfidfTransformer
#实例化tf-idf对象
tfidf = TfidfTransformer()
#将训练集中的词频向量用tf-idf进行转换
X_train = tfidf.fit_transform(X_train_count_vectorizer)
#将测试集中的词频向量用tf-idf进行转换
X_test = vec.transform(X_test_count_vectorizer)

2.3.3 MultinomialNB

MultinomialNB 是 sklearn 中多项分布数据的朴素贝叶斯算法的实现，并且是用于文本分类的经典朴素贝叶斯算法。在本关中建议使用 MultinomialNB 来实现文本分类功能。

在 MultinomialNB 实例化时alpha是一个常用的参数。

• alpha: 平滑因子。
  • 当等于1时，做的是拉普拉斯平滑；
  • 当小于1时做的是 Lidstone 平滑；
  • 当等于0时，不做任何平滑处理。

MultinomialNB 类中的 fit 函数实现了朴素贝叶斯分类算法训练模型的功能，predict 函数实现了法模型预测的功能。

其中fit函数的参数如下：

• X ：大小为 [样本数量,特征数量] 的 ndarry，存放训练样本
• Y ：值为整型，大小为 [样本数量] 的 ndarray，存放训练样本的分类标签

而predict函数有一个向量输入：

• X ：大小为 [样本数量,特征数量] 的 ndarry，存放预测样本

MultinomialNB 的使用代码如下：

clf = MultinomialNB()
clf.fit(X_train, Y_train)
result = clf.predict(X_test)

3. 代码实例

3.1 好瓜坏瓜都是西瓜

3.1.1 编程要求

根据提示，完成 fit 与 predict 函数，分别实现模型的训练与预测。（PS:在 fit 函数中需要将预测时需要的概率保存到 self.label_prob 和 self.condition_prob 这两个变量中）

其中fit函数参数解释如下：

• feature：训练集数据，类型为ndarray；
• label：训练集标签，类型为ndarray；
• return：无返回。

predict函数参数解释如下：

• feature：测试数据集所有特征组成的ndarray。（PS：feature中有多条数据）；
• return：模型预测的结果。（PS：feature中有多少条数据，就需要返回长度为多少的list或者ndarry）。

3.1.2 测试说明

部分训练数据如下
(PS:数据以ndarray的方式存储，不包含表头。其中颜色这一列用1表示绿色，2表示黄色；声音这一列用1表示清脆，2表示浑厚。纹理这一列用1表示清晰，2表示模糊，3表示一般)：

3.1.3 实际代码

import numpy as np


class NaiveBayesClassifier(object):
    def __init__(self):
        '''
        self.label_prob表示每种类别在数据中出现的概率
        例如，{0:0.333, 1:0.667}表示数据中类别0出现的概率为0.333，类别1的概率为0.667
        '''
        self.label_prob = {}
        '''
        self.condition_prob表示每种类别确定的条件下各个特征出现的概率
        例如训练数据集中的特征为 [[2, 1, 1],
                              [1, 2, 2],
                              [2, 2, 2],
                              [2, 1, 2],
                              [1, 2, 3]]
        标签为[1, 0, 1, 0, 1]
        那么当标签为0时第0列的值为1的概率为0.5，值为2的概率为0.5;
        当标签为0时第1列的值为1的概率为0.5，值为2的概率为0.5;
        当标签为0时第2列的值为1的概率为0，值为2的概率为1，值为3的概率为0;
        当标签为1时第0列的值为1的概率为0.333，值为2的概率为0.666;
        当标签为1时第1列的值为1的概率为0.333，值为2的概率为0.666;
        当标签为1时第2列的值为1的概率为0.333，值为2的概率为0.333,值为3的概率为0.333;
        因此self.label_prob的值如下：     
        {
            0:{
                0:{
                    1:0.5
                    2:0.5
                }
                1:{
                    1:0.5
                    2:0.5
                }
                2:{
                    1:0
                    2:1
                    3:0
                }
            }
            1:
            {
                0:{
                    1:0.333
                    2:0.666
                }
                1:{
                    1:0.333
                    2:0.666
                }
                2:{
                    1:0.333
                    2:0.333
                    3:0.333
                }
            }
        }
        '''
        self.condition_prob = {}
    def fit(self, feature, label):
        '''
        对模型进行训练，需要将各种概率分别保存在self.label_prob和self.condition_prob中
        :param feature: 训练数据集所有特征组成的ndarray
        :param label:训练数据集中所有标签组成的ndarray
        :return: 无返回
        '''


        #********* Begin *********#
        row_num = len(feature)
        col_num = len(feature[0])
        for c in label:# 每个类别出现的次数
            if c in self.label_prob:
                self.label_prob[c] += 1
            else:
                self.label_prob[c] = 1

        for key in self.label_prob.keys():
            # 计算每种类别在数据集中出现的概率
            self.label_prob[key] /= row_num
            # 构建self.condition_prob中的key，初始化各个大括号
            self.condition_prob[key] = {}# 上面字典套字典的第二个大括号，01类别
            for i in range(col_num):
                self.condition_prob[key][i] = {}# 第三个大括号
                for k in np.unique(feature[:, i], axis=0):# axis=0 见5.[1]
                    self.condition_prob[key][i][k] = 0# 第三个大括号内的不同特征的条件概率

		# 记录特征，feature的每组里面的每个元素分别是哪个，需要放到对应的condition_prob的哪个位置，记录个数
        for i in range(len(feature)):
            for j in range(len(feature[i])):
                if feature[i][j] in self.condition_prob[label[i]]:
                    self.condition_prob[label[i]][j][feature[i][j]] += 1
                else:
                    self.condition_prob[label[i]][j][feature[i][j]] = 1

		# 除以总数，得各个概率
        for label_key in self.condition_prob.keys():
            for k in self.condition_prob[label_key].keys():
                total = 0
                for v in self.condition_prob[label_key][k].values():
                    total += v
                for kk in self.condition_prob[label_key][k].keys():
                    #计算每种类别确定的条件下各个特征出现的概率
                    self.condition_prob[label_key][k][kk] /= total

        #********* End *********#


    def predict(self, feature):
        '''
        对数据进行预测，返回预测结果
        :param feature:测试数据集所有特征组成的ndarray
        :return:
        '''
        # ********* Begin *********#
        result = []
        #对每条测试数据都进行预测
        for i, f in enumerate(feature):# 见5.[4]，遍历每条数据数组
            #可能的类别的概率
            prob = np.zeros(len(self.label_prob.keys()))
            ii = 0
            for label, label_prob in self.label_prob.items():
                #计算概率
                prob[ii] = label_prob
                for j in range(len(feature[0])):
                    prob[ii] *= self.condition_prob[label][j][f[j]]
                ii += 1
            #取概率最大的类别作为结果
            result.append(list(self.label_prob.keys())[np.argmax(prob)])# 见5.[5]
        return np.array(result)
        
        #********* End *********#

第二种

import numpy as np

class NaiveBayesClassifier(object):
    def __init__(self):
        self.label_prob = {}
        self.condition_prob = {}
    def fit(self, feature, label):
        #********* Begin *********#
        
        feature0_index=np.where(label==0)
        
        feature1_index=np.where(label==1)
        
        feature0=feature[feature0_index]
        
        feature1=feature[feature1_index]
        
        self.label_prob[0]=len(feature0)/len(feature)
        self.label_prob[1]=len(feature1)/len(feature)
        sum0={}
        for f0 in feature0:
            for i in range(len(f0)):
                if i in sum0:
                    sum0[i][f0[i]] = sum0[i].get(f0[i], 0) + 1 / len(feature0)
                else:
                    sum0[i] = {}
                    sum0[i][f0[i]] = sum0[i].get(f0[i], 0) + 1 / len(feature0)
        sum1={}
        for f1 in feature1:
            for i in range(len(f1)):
                if i in sum1:
                    sum1[i][f1[i]] = sum1[i].get(f1[i], 0) + 1 / len(feature1)
                else:
                    sum1[i] = {}
                    sum1[i][f1[i]] = sum1[i].get(f1[i], 0) + 1 / len(feature1)
        self.condition_prob[0]=sum0;
        self.condition_prob[1]=sum1;

        #********* End *********#


    def predict(self, feature):
        # ********* Begin *********#
        result=[]
        for f in feature:
            result1=self.label_prob[1]
            result0=self.label_prob[0]
            for i in range(len(f)):
                result0*=self.condition_prob[0][i].get(f[i],0)
                result1*=self.condition_prob[1][i].get(f[i],0)
            if result0>result1:
                result.append(0)
            else:
                result.append(1)
        return np.array(result)
        #********* End *********#

3.2 好坏西瓜都要平滑

编程要求和测试说明同3.1一致，不再赘述

3.2.1 代码示例

第一种

import numpy as np

class NaiveBayesClassifier(object):
    def __init__(self):
        self.label_prob = {}
        self.condition_prob = {}

    def fit(self, feature, label):
        #********* Begin *********#
        row_num = len(feature)
        col_num = len(feature[0])
        unique_label_count = len(set(label)) # 见5.[7]

        for c in label:
            if c in self.label_prob:
                self.label_prob[c] += 1
            else:
                self.label_prob[c] = 1

        for key in self.label_prob.keys():
            # 计算每种类别在数据集中出现的概率，拉普拉斯平滑
            self.label_prob[key] += 1
            self.label_prob[key] /= (unique_label_count+row_num) # 类别计数加上，因为是拉普拉斯平滑

            # 构建self.condition_prob中的key
            self.condition_prob[key] = {}
            for i in range(col_num):
                self.condition_prob[key][i] = {}
                for k in np.unique(feature[:, i], axis=0):
                    self.condition_prob[key][i][k] = 1


        for i in range(len(feature)):
            for j in range(len(feature[i])):
                if feature[i][j] in self.condition_prob[label[i]]:
                    self.condition_prob[label[i]][j][feature[i][j]] += 1

        for label_key in self.condition_prob.keys():
            for k in self.condition_prob[label_key].keys():
                #拉普拉斯平滑，不同于之前total=0，首先给他赋上该类别的种类数
                total = len(self.condition_prob[label_key].keys())
                for v in self.condition_prob[label_key][k].values():
                    total += v
                for kk in self.condition_prob[label_key][k].keys():
                    # 计算每种类别确定的条件下各个特征出现的概率
                    self.condition_prob[label_key][k][kk] /= total
        #********* End *********#


    def predict(self, feature):
        result = []
        # 对每条测试数据都进行预测
        for i, f in enumerate(feature):
            # 可能的类别的概率
            prob = np.zeros(len(self.label_prob.keys()))
            ii = 0
            for label, label_prob in self.label_prob.items():
                # 计算概率
                prob[ii] = label_prob
                for j in range(len(feature[0])):
                    prob[ii] *= self.condition_prob[label][j][f[j]]
                ii += 1
            # 取概率最大的类别作为结果
            result.append(list(self.label_prob.keys())[np.argmax(prob)])
        return np.array(result)

第二种

import numpy as np

class NaiveBayesClassifier(object):
    def __init__(self):
        self.label_prob = {}
        self.condition_prob = {}

    def fit(self, feature, label):
        #********* Begin *********#

        row_num = len(feature)
        col_num = len(feature[0])
        unique_label_count = len(set(label))

        for c in label:
            if c in self.label_prob:
                self.label_prob[c] += 1
            else:
                self.label_prob[c] = 1

        for key in self.label_prob.keys():
            # 计算每种类别在数据集中出现的概率，拉普拉斯平滑
            self.label_prob[key] += 1
            self.label_prob[key] /= (unique_label_count+row_num)

            # 构建self.condition_prob中的key
            self.condition_prob[key] = {}
            for i in range(col_num):
                self.condition_prob[key][i] = {}
                for k in np.unique(feature[:, i], axis=0):
                    self.condition_prob[key][i][k] = 1


        for i in range(len(feature)):
            for j in range(len(feature[i])):
                if feature[i][j] in self.condition_prob[label[i]]:
                    self.condition_prob[label[i]][j][feature[i][j]] += 1

        for label_key in self.condition_prob.keys():
            for k in self.condition_prob[label_key].keys():
                #拉普拉斯平滑
                total = len(self.condition_prob[label_key].keys())
                for v in self.condition_prob[label_key][k].values():
                    total += v
                for kk in self.condition_prob[label_key][k].keys():
                    # 计算每种类别确定的条件下各个特征出现的概率
                    self.condition_prob[label_key][k][kk] /= total
        #********* End *********#


    def predict(self, feature):
        result = []
        # 对每条测试数据都进行预测
        for i, f in enumerate(feature):
            # 可能的类别的概率
            prob = np.zeros(len(self.label_prob.keys()))
            ii = 0
            for label, label_prob in self.label_prob.items():
                # 计算概率
                prob[ii] = label_prob
                for j in range(len(feature[0])):
                    prob[ii] *= self.condition_prob[label][j][f[j]]
                ii += 1
            # 取概率最大的类别作为结果
            result.append(list(self.label_prob.keys())[np.argmax(prob)])
        return np.array(result)

3.3 新闻文本主题分类

3.3.1 编程要求

填写news_predict(train_sample, train_label, test_sample)函数完成新闻文本主题分类任务，其中：

• train_sample：原始训练样本，类型为 ndarray；
• train_label：训练标签，类型为 ndarray；
• test_sample：原始测试样本，类型为 ndarray。

3.3.2 测试说明

只需返回预测结果即可，程序内部会检测您的代码，预测正确率高于 0.8 视为过关。

3.3.3 代码示例

from sklearn.feature_extraction.text import CountVectorizer  # 从sklearn.feature_extraction.text里导入文本特征向量化模块
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfTransformer


def news_predict(train_sample, train_label, test_sample):
    '''
    训练模型并进行预测，返回预测结果
    :param train_sample:原始训练集中的新闻文本，类型为ndarray
    :param train_label:训练集中新闻文本对应的主题标签，类型为ndarray
    :test_sample:原始测试集中的新闻文本，类型为ndarray
    '''

    # ********* Begin *********#
    vec = CountVectorizer()
    train_sample = vec.fit_transform(train_sample)
    test_sample = vec.transform(test_sample)

    tfidf = TfidfTransformer()

    train_sample = tfidf.fit_transform(train_sample)
    test_sample = tfidf.transform(test_sample)

    mnb = MultinomialNB(alpha=0.01)  # 使用默认配置初始化朴素贝叶斯
    mnb.fit(train_sample, train_label)  # 利用训练数据对模型参数进行估计
    predict = mnb.predict(test_sample)  # 对参数进行预测
    return predict
    # ********* End *********#

第二种

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfTransformer


def news_predict(train_sample, train_label, test_sample):
    vec = CountVectorizer()
    X_train = vec.fit_transform(train_sample)
    X_test = vec.transform(test_sample)

    tfidf=TfidfTransformer()
    X_train = tfidf.fit_transform(X_train)
    X_test=tfidf.transform(X_test)

    clf = MultinomialNB(alpha = 0.01)
    clf.fit(X_train, train_label)
    result = clf.predict(X_test)

    return result

4. 应用举例

4.1 垃圾邮件过滤

贝叶斯分类器经常会被用来进行垃圾邮件过滤，此时训练数据的特征就是邮件内容本身，而类别标签只有两类，即是垃圾邮件或不是垃圾邮件。
朴素贝叶斯假设表达的含义就是邮件内容中的每个单词在已经知道邮件是否为垃圾邮件的情况下都是条件独立的。很显然这个假设实际上是不成立的，因为在写邮件的时候，我们不是从词库中独立地随机挑选单词来构成句子，而是根据上下文的关联性来组织单词。
尽管朴素贝叶斯假设是违背现实的，但是在用朴素贝叶斯法进行实践的时候，却还有着不错的效果。

5. Python学习

[1] axis=0代表往跨行（down)，而axis=1代表跨列（across)

• 使用0值表示沿着每一列或行标签\索引值向下执行方法
• 使用1值表示沿着每一行或者列标签模向执行对应的方法

下图代表在DataFrame当中axis为0和1时分别代表的含义:

[2] numpy.unique 函数用于去除数组中的重复元素。

[3] list indices must be integers or slices, not tuple解决方案:

用numpy里的array转化下，转成元组 ： dataSet=np.array(dataSet)
或者将dataSet转化为矩阵：mat(dataSet)

[4] enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

[5] argmax函数，沿给定轴返回最大元素的索引。

[6] numpy.zeros 创建指定大小的数组，数组元素以 0 来填充：

[7] set()

>>>a = [1,2,3,4,5,6]
>>>print(len(set(a)))
6
>>>print(set(a))
{1, 2, 3, 4, 5, 6}