前言

前面的算法我们要求分类器对于“该数据属于哪一个分类”这类问题做出明确回答。不过，分类器有时会产生错误结果，这时可以要求分类器给出一个最优的类别猜测结果，同时给出这个猜测的概率估计值。

概率论是许多机器学习算法的基础，所以深刻理解这一主题就显得十分重要。

基于贝叶斯决策理论的分类方法

朴素贝叶斯

优点：在数据较少的情况下依然有效，可以处理多类别问题
缺点：对于输入数据的准备方式较为敏感
适用数据类型：标称型数据。

朴素贝叶斯是贝叶斯决策论的一部分，所以在讲述朴素贝叶斯之前有必要快速了解一下贝叶斯决策理论。

假设有人找到了描述图中两类数据的统计参数¹。现在我们使用 $P_1(x,y)$ 表示数据。点 $(x,y)$ 属于类别 1 （图中用圆形表示的类别）的概率，用 $P_2(x,y)$ 表示数据点 $(x,y)$ 属于类别 2 （图中用菱形表示的类别）的概率。那么对于一个新的数据点 $(x,y)$ ，可以使用下面的规则来判断它的类别：

如果 $\large P_1(x,y) > P_2(x,y)$ ，那么类别为 1
如果 $\large P_2(x,y) > P_1(x,y)$ ，那么类别为 2

也就是说，我们会选择高概率对应的类型。这就是贝叶斯²决策理论的核心思想，即选择具有高概率的决策。

接下来，我们必须要讲述 $P_1$ 及其概率的计算方法了。为了能够计算 $P_1$ 和 $P_2$ ，有必要讨论一下条件概率。

条件概率

接下来，我们花点时间来讲述概率和条件概率。如果你对于 $P(x,y|c_1)$ 符号很熟悉，就可以跳过这个部分。

如上图所示，现在我们盒子里有 7 个球，我们根据初中的知识就可以很清楚的得到，取出黑色球的概率是：$\large \frac{3}{7}$ （其概率值可以通过黑色球的数目除以总数来得到）。同样的，对于下面的情况我们也可以快速的计算出“ B 桶摸出出黑球的概率”。不难得到：$\large P_A = \frac{2}{4}$ ，$\large P_B = \frac{1}{3}$ 。

我们可以通过条件概率公式得到如上结果：$\large P(黑球|B桶) = \frac{P(黑球且 B桶)}{P(B桶)}$ ，不难得到 $\large P(黑球且 B桶) = \frac{1}{7}$ ，$\large P(B桶)=\frac{3}{7}$，从而得到 $\large P(黑球|B桶)=\frac{1}{3}$。虽然这个公式对于这个简单的例子来说有些“多此一举”，但是当存在更多特征的时候它会非常有效。

另一种有效计算条件概率的方法称为贝叶斯准则（贝叶斯公式），贝叶斯准则告诉我们如何交互条件概率中的条件与结果（某种程度上来说，贝叶斯公式是根据结果来计算某个条件发生的概率），即如果已知 $\large P(x|c)$ 要求 $\large P(c|x)$ ，那么就可以使用这个计算方法：$\large P(c|x) = \frac{P(x|c)P(c)}{P(x)}$ 。

如果你对此还是感到疑惑，不需要烦恼，因为它确实挺绕的，可以参考使用贝叶斯公式的正确姿势和「一个模型」教你搞定贝叶斯和全概率公式就可以大大帮助你来理解，另外一个有趣的三门问题，如果你感兴趣的话，也可以查看【三门问题】条件概率｜贝叶斯统计｜manim动画（我记得我在学习《智慧之门》这本书的时候，它的第一个抛砖引玉的问题就是这个，非常有趣）

接下来我们来讨论如何结合贝叶斯决策理论使用条件概率，如果将其应用到分类器中。

使用条件概率来分类

前面我们提到贝叶斯决策理论要求计算两个概率 $P_1(x,y)$ 和 $P_2(x,y)$ ：

如果 $\large P_1(x,y) > P_2(x,y)$ ，那么类别为 1
如果 $\large P_2(x,y) > P_1(x,y)$ ，那么类别为 2

但是这两个准则并不是贝叶斯决策理论的所有内容。使用 $P_1()$ 和 $P_2()$ 只是为了尽可能简化描述，而真正需要计算和比较的是 $P(c_1 | x,y)$ 和 $P(c_2 |x,y)$ 。这些符号所代表的具体意义是：给定某个由 x , y 表示的数据点，那么该数据点来自类别 $c_1$ 的概率是多少？数据点来自 $c_2$ 的概率又是多少？注意，这些概率和之前给出的概率 $p(x,y|c_1)$ 并不一样，不过可以使用贝叶斯准则（贝叶斯公式）来交互概率中的条件与结果。具体的来说：$\large P(c_i|x,y) = \frac{P(x,y|c_i)P(c_i)}{P(x,y)}$ 。

使用这些定义，可以定义贝叶斯分类准则为：

如果 $\large P(c_1|x,y) > P(c_2|x,y)$ ，那么就属于类别 $\large c_1$
如果 $\large P(c_1|x,y) < P(c_2|x,y)$ ，那么就属于类别 $\large c_2$

使用贝叶斯准则（公式），可以通过已知的三个概率值来计算未知的概率值。后面就会给出利用贝叶斯准则来计算概率并对数据进行分类的代码。

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

机器学习的一个重要应用就是文档的自动分类。在文档分类中，整个文档是实例，而文档中的某些元素则构成特征。我们可以观察文档中出现的词，并把每个词的出现或者不出现作为一个特征，这样的得到的特征数目就会跟词汇表中的词语一样多。朴素贝叶斯是贝叶斯分类器的一个拓展，是用于文档分类的常用算法。

使用每个词作为特征并观察它们是否出现，这样得到的特征数目有多少呢？就英语而言，据估计，英文的单词总数就有超过 500000 个。为了能够进行英文阅读，估计需要掌握数千个单词。

假设词汇表有 1000 个单词。要得到好的概率分布，就需要足够的数据样本，假定样本数为 N 。由统计学可知，如果每个特征需要 N 个样本，那么对于 10 个特征将需要 $N^{10}$ 个样本，对于包含 1000 个特征的词汇表将需要 $N^1000$ 个样本³。可以看到，所需要的样本数量会随着特征数目的增大而迅速增大。

如果特征之间相互独立，那么样本数就可以从 $N^{1000}$ 减少到 $N \times 1000$ 。所谓独立，指的是统计意义上的独立，即一个特征或者单词出现的可能性与它和其他单词相邻没有关系。举例子来讲，假设单词 bacon⁴ 出现在 unhealthy 后面与出现在 delicious 后面的概率相同。当然，我们知道这种假设并不正确，bacon 经常出现在 delicious 附件，而很少出现在 unhealthy 附件，这个假设正是朴素贝叶斯分类器中朴素一词的含义。朴素贝叶斯分类器中的另一个假设是，每个特征同等重要⁵。其实这个假设也有问题。如果要判断留言板的留言是否得当，那么可能不需要看完所有的 1000 个单词，只需要看 10-20 个特征就足以做出判断了。尽管上述假设有一些小瑕疵，但朴素贝叶斯的实际效果却很好。

到目前为止，你已经了解足够多的知识，可以开始编写代码了。如果还不清楚，那么了解代码的实际效果也会有助于你的理解。

使用 Python 进行文本分类

要从文本中获取特征，需要先拆分文本。具体如何做呢？这里的特征是来自文本的词条（token），一个词条是字符的任意组合。可以把词条想象为单词，也可以使用非单词词条，例如 URL，IP地址或者任意其他字符串。然后将每一个文本片段表示为一个词条向量，其中值为 1 表示词条出现在文档中，0 表示词条未出现。

以在线社区的留言板为例。为了不影响社区的发展，我们要屏蔽侮辱性言论，所以要构建一个快速过滤器，如果某条留言使用了负面或者侮辱性的言语，那么就将该留言表示为内容不当。过滤这类内容是一个很常见的需求。对此问题建立两个类别：侮辱类和非侮辱类，使用 1 和 0 分别表示。

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

我们将文本看成单词向量或者词条向量，也就是说将句子转换为向量。考虑出现在所有文档中的所有单词，再决定将哪些词汇或者说所要的词汇集合，然后必须要将每一篇文档转换为词汇表上的向量。现在我们打开编辑器，创建一个 bayes.py 的文件，写入下面的代码：

# 加载数据，返回词条向量和对应的类别
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']]
    # 1表示有侮辱性，0表示没有侮辱性
    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):
    # 创建一个和唯一值集合相同大小的列表，初始化为 0
    returnVec = [0] * len(vocabList)
    # 遍历词汇表中每个单词
    for word in inputSet:
        # 如果单词在唯一值集合（文档）中
        if word in vocabList:
            # 就让这个返回值列表对应的位置值=1，1表示出现了该单词
            returnVec[vocabList.index(word)] = 1
        else:
            # 否则就输出文档中并不存在词汇表的词语
            print("the word: %s is not in my Vocabulary!" % word)
    # 返回向量化后的列表
    return returnVec

第一个函数loadDataSet()负责返回文档及其特征标签（人工标注），即这些文本是不是有侮辱性的，具有侮辱性的用 1 表示。其中这个文档来自斑点犬爱好者的留言板中。这些信息是用来训练程序以自动检测侮辱性留言。其中那些留言的翻译如下所示：

"我的狗有跳蚤问题，请帮忙。",
"也许不要带他去狗公园，太傻了。",
"我的大麦犬太可爱了，我爱他。",
"停止发布愚蠢、毫无价值的垃圾。",
"莱克斯先生吃了我的牛排，怎么阻止他。",
"不要再买毫无价值的狗粮，太傻了。"

第二个函数createVocabList()将文档的“词”，唯一化处理，并返回唯一化数据集。需要注意的是，set()唯一化数据集的时候是无序的。

第三个函数createVocabList()负责将对应文档和我们的词汇表做比较，然后生成一份文档的“量化”表，用 1 表示文档中某个词是词汇表中的，用 0 表示该词没有出现在词汇表中。

现在我们运行如下代码，进行测试一下，看看运行结果：

# 获取数据
listPosts,listClass = loadDataSet()
# 唯一化数据
tempUn = createVocabList(listPosts)
# 词汇表测试
print(setOfWords2Vec(tempUn,listPosts[0]))

运行结果：[0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0]。

这个由文档转换为 0,1被称为词向量（是对于文档中词语的一种量化）。

训练算法：从词向量计算概率

前面介绍了如何将一组单词转换为一组数字（量化），接下来看看如何使用这些数字计算概率。现在已经知道一个词是否出现在一篇文档中，也知道该文档所属的类别。还记得前面提到的贝叶斯准则吗？我们现在重写贝叶斯准则，将之前的 $x,y$ 替换为 $\large \textcolor{blue}{\omega}$ ，蓝色 $\large \textcolor{blue}{\omega}$ 表示这是一个向量，即它是由多个数值组成。在这个例子中，数值个数与词汇表中词的个数相同。

$\Large P(c_i|\textcolor{blue}{\omega}) = \frac{P(\textcolor{blue}{\omega}|c_i)P(c_i)}{P(\textcolor{blue}{\omega})}$

我们将使用上述公式，对每个类别计算该值，然后比较这两个概率值的大小。如何计算呢？首先可以通过类别 $i$ （侮辱性或者非侮辱性留言）中的词数除以总的词数来计算概率 $P(c_i)$ 。接下来计算 $P(\textcolor{blue}{\omega}|C_i)$ ，这里就要用到朴素贝叶斯假设。如果 $\textcolor{blue}{\omega}$ 展开为一个个独立特征，那么就可以将上述概率写作 $P(\textcolor{blue}{\omega_1}, \textcolor{blue}{\omega_2},\textcolor{blue}{\omega_3}…|C_i)$ 。这里假设所有词都相互独立，它就意味着可以使用 $p(\textcolor{blue}{\omega_0}|c_i)p(\textcolor{blue}{\omega_1}|c_i)p(\textcolor{blue}{\omega_2}|c_i)…$ 来计算上述概率，这就极大的简化了计算的过程。

什么？看不懂？没关系，可以参考一下这个视频有助于理解 [5分钟学算法] #02 朴素贝叶斯写作业还得看小明或者【机器学习】动画讲解贝叶斯分类器，虽然后者是盗的 Youtube 上博主的视频，还不知廉耻的打上水印盖住，但是学习的角度，可以参考，行为就算了

现在我们来用代码实现上述过程，将下面的代码，添加到之前创建的 bayes.py 文件中，请确保在此之前，将 from numpy import * 写在了文件的开头。

def trainNB0(trainMatrix,trainCategory):
    # 词总数
    numTrainDocs = len(trainMatrix)
    # 拿到文档第一行
    numWords = len(trainMatrix[0])
    # 计算某个类别的概率
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    # 用来记录分类 0 的每个词总数
    p0Num = zeros(numWords)
    # 用来记录分类 1 的每个词词总数
    p1Num = zeros(numWords)
    # 用来记录分类 0 的词汇总数
    p0Denom = 0.0
    # 用来记录分类 1 的词汇总数
    p1Denom = 0.0
    # 遍历所有文档
    for i in range(numTrainDocs):
        # 判断是侮辱性类别吗
        if trainCategory[i] == 1:
            # 记录每个词的次数
            p1Num += trainMatrix[i]
            # 记录统计总数
            p1Denom += sum(trainMatrix[i])
        else:
            # 记录每个词的次数
            p0Num += trainMatrix[i]
            # 记录统计总数
            p0Denom += sum(trainMatrix[i])
    # 计算类别 1 的条件概率
    p1Vect = p1Num/p1Denom
    # 计算类别 0 的条件概率
    p0Vect = p0Num/p0Denom
    return p0Vect,p1Vect,pAbusive

因为这是一个二分类问题，可以通过 $1-P(1)$ 得到 $P(0)$ 。对于多分类问题，代码则需要稍加修改。现在我们使用如下代码，来测试上述代码：

# 获取数据
listPosts,listClass = loadDataSet()
# 唯一化数据
myVocabList = createVocabList(listPosts)
trainMat=[]
for postinDoc in listPosts:
    trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
print(trainNB0(trainMat,listClass))

其输出结果如下所示：

(array([0.04166667, 0.04166667, 0.04166667, 0.04166667, 0.        ,
       0.04166667, 0.04166667, 0.04166667, 0.        , 0.08333333,
       0.04166667, 0.04166667, 0.04166667, 0.        , 0.04166667,
       0.04166667, 0.04166667, 0.        , 0.        , 0.04166667,
       0.04166667, 0.        , 0.04166667, 0.        , 0.125     ,
       0.        , 0.        , 0.04166667, 0.04166667, 0.        ,
       0.04166667, 0.        ]), array([0.        , 0.10526316, 0.        , 0.        , 0.10526316,
       0.        , 0.05263158, 0.        , 0.15789474, 0.05263158,
       0.        , 0.        , 0.        , 0.05263158, 0.        ,
       0.        , 0.05263158, 0.05263158, 0.05263158, 0.        ,
       0.        , 0.05263158, 0.        , 0.05263158, 0.        ,
       0.05263158, 0.05263158, 0.        , 0.        , 0.05263158,
       0.        , 0.05263158]), 0.5)

可以以看到，语句属于侮辱类的概率是 $0.5$ ，该值是正确的。解析下来看看个别词汇的概率，例如：$0.15789474$ 的下标对应的 myVocabList 位置的词语是 'stupid' ，这意味着 'stupid' 是最能代表类别 1（侮辱性）的词汇。

在使用该函数进行分类之前，我们还需要解决函数中的一些缺陷。

测试算法：根据现实情况修改分类器

利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算 $p(\textcolor{blue}{\omega_0}|c_i)p(\textcolor{blue}{\omega_1}|c_i)p(\textcolor{blue}{\omega_2}|c_i)…$ 。如果其中一个的概率值为 0，那么最后的乘积也为 0。为降低这种影响，可以将所有单词的出现数初始化为 1，并将分母初始化为 2。

其中 “将所有单词的出现数初始化为 1，并将分母初始化为 2” 这个操作被称为 **拉普拉斯平滑⁶**。

在拉普拉斯平滑中，我们将所有特征的出现数初始化为1，这样即使某个特征在训练数据中没有出现，它的概率也不会变为零。同时，为了保持概率的总和为1，我们将分母初始化为特征总数加上特征的可能取值个数。

现在将我们的代码，其中的相关部分修改为如下所示：

# 拉普拉斯平滑处理
p0Num = ones(numWords)
p1Num = ones(numWords)
p0Denom = 2.0
p1Denom = 2.0

另一个遇到的问题就是下溢出，这是由于太多太小的数相乘造成的。当计算 $p(\textcolor{blue}{\omega_0}|c_i)p(\textcolor{blue}{\omega_1}|c_i)p(\textcolor{blue}{\omega_2}|c_i)…$ 时，由于大部分因子都非常小，所以程序会下溢出或者得到不正确的答案。

一种解决办法是对乘积取自然对数。在代数中有 $\large \ln{(ab)} = \ln{a} + \ln{b}$ ，于是通过求对数可以避免下溢出的问题。同时采用自然对数进行处理不会有任何损失。如下图所示，将原函数用 $log$ 处理后，它们的极值点是一致的，且增加或者减少的区域是相同的。

对数可以将乘法问题转换为加法问题，这样可以避免非常小的概率相乘导致的下溢出问题。如果并不了解我说的什么意思，可以查看这个视频对数运算到底方便在哪里？

现在我们修改原来 bayes.py 文件中的代码为如下所示：

# 计算类别 1 的条件概率
p1Vect = log(p1Num/p1Denom)
# 计算类别 0 的条件概率
p0Vect = log(p0Num/p0Denom)

现在已经准备好构建完整分类器了，继续向 bayes.py 文件中添加如下代码：

# classifyNB 的英文全称是 "Naive Bayes Classifier"「朴素贝叶斯分类器」。
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    # 我不理解他为什么要加起来，虽然是log(ab)=log(a)+log(b)，但是前面点积说不通
    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,'类别是: ',classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry,'类别是 ',classifyNB(thisDoc,p0V,p1V,pAb))

运行测试分类器tesingNB()后，其结果如下所示：

1 2	['love', 'my', 'dalmation'] 类别是: 0 ['stupid', 'garbage'] 类别是 1

这个例子展示了朴素贝叶斯分类器的工作原理，接下来，对代码做些修改，使分类器工作更好。

准备数据：文档词袋模型

目前为止，我们将一个词是否出现作为特征，这可以描述为词集模型（set of words model）。**如果一个词在文档中不止出现一次，我们需要多次记录被称为词袋模型(bag of words model)**。为了适应词袋模型，需要对setOfWords2Vec()函数做一些修改，新修改的函数称为bagOfWords2VecMN()。

下面的代码给出了基于词袋模型的朴素贝叶斯代码，它与setOfWords2Vec()函数几乎完全相同，唯一不同的是每当遇到一个单词时，它会增加词向量中的对应值，而不是只将对应的数值设为 1。

# 词袋模型
def bagOfWords2VecMN(vocabList, inputSet):
    # 创建同等长度初始化为 0 的列表
    returnVec = [0]*len(vocabList)
    # 遍历记录出现次数
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

现在分类器已经构建好了，我们接下来利用这个分类器来过滤垃圾邮件。

使用朴素贝叶斯过滤垃圾邮件

准备数据：切分文本

前面介绍了如何创建词向量，并基于这些词向量进行朴素贝叶斯分类的过程。前面的部分词向量是预先给定的，下面介绍如何从文本文档中构建自己的词列表。

对于一个文本字符串，可以使用 Python 的 string.split() 方法将其切分。下面是运行效果：

txt = "This book , is the best book"
print(txt.split())

# 输出
['This', 'book', ',', 'is', 'the', 'best', 'book']

可以看到，切分的结果不错，但是标点符号也被当成了词的一部分。可以使用正则表达式来切分句子，其中分隔符是除单词，数字外的任意字符串。

import re
txt = "This book , is the best book"
regEx = re.compile('\\W+')
listTokens = regEx.split(txt)
print(listTokens)

# 输出结果
['This', 'book', 'is', 'the', 'best', 'book']

如果你不了解什么是正则表达式，可以查看正则表达式。

现在还需要解决的一个问题就是第一个单词是大写的，如果是按词袋来比较的话，我们需要让词的形式统一起来，不论它们是在什么位置。

Python 中有一些内嵌的方法，可以将字符串全部转换成小写（.lower()）或者大写（.upper()），借助这些方法可以达到我们的目的。于是，我们可以做如下操作：

import re
txt = "This book , is the best book"
regEx = re.compile('\\W+')
listTokens = regEx.split(txt)
print([token.lower() for token in listTokens])

# 输出
['this', 'book', 'is', 'the', 'best', 'book']

测试算法：使用朴素贝叶斯进行交叉验证

测试使用的数据点我下载。将文件解压缩到和 bayes.py 同路径下。交叉验证的代码如下所示：

def textParse(bigString):  # input is big string, #output is word list
    import re
    listOfTokens = re.split(r'\W*', bigString)
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]


def spamTest():
    docList = []
    classList = []
    fullText = []
    for i in range(1, 26):
        wordList = textParse(open('email/spam/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList = textParse(open('email/ham/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    vocabList = createVocabList(docList)
    trainingSet = range(50)
    testSet = []
    for i in range(10):
        randIndex = int(random.uniform(0, len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del (trainingSet[randIndex])
    trainMat = []
    trainClasses = []
    for docIndex in trainingSet:
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
    errorCount = 0
    for docIndex in testSet:
        wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
        if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
            errorCount += 1
            print("classification error", docList[docIndex])
    print('the error rate is: ', float(errorCount) / len(testSet))

如上代码是《机器学习实战》中作者给的代码，他使用的是python2.x版本，所以我在尝试运行这段代码，全是报错，主要问题在于读取文本的格式问题，我在尝试使用UTF-8编码后，无果。遂放弃了尝试这段代码。

如果你感兴趣的话，可以尝试修改正确，我放弃了😥

【4.0】基于概率论的分类方法：朴素贝叶斯

前言