机器学习算法( 四、朴素贝叶斯算法)

一、概述  

   前两章我们要求分类器做出艰难决策,给出“该数据实例属于哪一类”这类问题的明确答案。不过,分类器有时会产生错误结果,这时可以要求分类器给出一个最优的类别猜测结果,同时给出这个猜测的概率估计值

  概率论是许多机器学习算法的基础,所以深刻理解这一主题就显得十分重要。第3章在计算特征值取某个值的概率时涉及了一些概率知识,在那里我们先统计特征在数据集中取某个特定值的次数,然后除以数据集的实例总数,就得到了特征取该值的概率。我们将在此基础上深人讨论。
      本章会给出一些使用概率论进行分类的方法。首先从一个最简单的概率分类器开始,然后给出一些假设来学习朴素贝叶斯分类器。我们称之为“朴素”,是因为整个形式化过程只做最原始、最简单的假设。不必担心,你会详细了解到这些假设。我们将充分利用Python的文本处理能力将文档切分成词向量,然后利用词向量对文档进行分类。我们还将构建另一个分类器,观察其在真实的垃圾邮件数据集中的过滤效果,必要时还会回顾一下条件概率。最后,我们将介绍如何从个人发布的大量广告中学习分类器,并将学习结果转换成人类可理解的信息。

  假设现在我们有一个数据集,它由两类数据组成,数据分布如图所示。

  我们现在用p1(x,y)表示数据点(x,y)属于类别1(以图中用圆点表示的类别)的概率,用p2(x,y)表示数据点(x,y)属于类别2 ( 图中用三角形表示的类别)的概率,那么对于一个新数据点(x,y),可以用下面的规则来判断它的类别:

 

也就是说,我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想,即选择具有最高概率的决策。回到图,如果该图中的整个数据使用6个浮点数来表示,并且计算类别概率的python代码只有两行,那么你会更倾向于使用下面哪种方法来对该数据点进行分类?
(1)使用第1章的knn ,进行1000次距离计算;
(2)使用第2章的决策树,分别沿x轴、y轴划分数据;
(3)计算数据点属于每个类别的概率,并进行比较。
     使用决策树不会非常成功;而和简单的概率计算相比,knn的计算量太大。因此,对于上述问题,最佳选择是使用刚才提到的概率比较方法

 

二、优缺点  

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

三、数学公式  

  贝叶斯定理

   了解贝叶斯定理之前,需要先了解下条件概率。P(A|B)表示在事件B已经发生的条件下事件A发生的概率:

  

  假如我们已经知道了P(A|B),但是现在我们想要求P(B|A),也就是在事件A发生的条件下事件B发生的概率,这时贝叶斯定理就派上用场了。

  


 

  前面提到贝叶斯决策理论要求计算两个概率p1(x,y) 和p2(x,y);

  

  但这两个准则并不是贝叶斯决策理论的所有内容。使用p1() p2()只是为了简化描述,而真正需要计算和比较的是p(c1|x,y) 和p(c2|x,y)。 这些符号的意思是:

给定某个x,y表示的数据点,那么该数据点来自类别c1的概率是多少? 来自c2的概率又是多少?

  

 

  现分别有 A、B 两个容器,在容器 A 里分别有 7 个红球和 3 个白球,在容器 B 里有 1 个红球和 9 个白球,现已知从这两个容器里任意抽出了一个球,问这个球是红球且来自容器 A 的概率是多少?
  假设已经抽出红球为事件 B,选中容器 A 为事件 A,则有:P(B) = 8/20,P(A) = 1/2,P(B|A) = 7/10,
  
  按照公式,则有:P(A|B) = (7/10)*(1/2) / (8/20) = 0.875
 

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

   机器学习的一个重要应用就是文档的自动分类。在文档分类中,整个文档(如一封电子邮件)是实例,而电子邮件中的某些元素则构成特征。虽然电子邮件是一种会 不断增加的文本,但我们同样也可以对新闻报道、用户留言、政府公文等其他任意类型的文本进行分类。我们可以观察文档中出现的词,并把每个词的出现或者不出 现作为一个特征,这样得到的特征数目就会跟词汇表中的词目一样多。朴素贝叶斯是上节介绍的贝叶斯分类器的一个扩展,是用于文档分类的常用算法。
使用每个词作为特征并观察它们是否出现,这样得到的特征数目会有多少呢?针对的是哪一种人类语言呢?当然不止一种语言。据估计,仅在英语中,单词的总数就有500000之多。为了能进行英文阅读,估计需要掌握数千单词。

     所谓独立,指的是统计意义上的独立,即一个特征或者单词出现的可能性与它和其他单词相邻没有关系。

     这个假设正是朴素贝叶斯分类器中朴素一词的含义,朴素贝叶斯分类器中的另一个假设是,每个特征同等重要.

  算法一般流程

  1.数据的收集

      2.数据的准备:数值型或布尔型

      3.分析数据

      4.训练算法:计算不同的独立特征的条件概率

      5.测试算法:计算错误率

  6.使用算法:以实际应用为驱动

       朴素贝叶斯伪代码

1.计算各个独立特征在各个分类中的条件概率

      2.计算各类别出现的概率

      3.对于特定的特征输入,计算其相应属于特定分类的条件概率

      4.选择条件概率最大的类别作为该输入类别进行返回

 

五、准备数据:从文本中构建词向量

  我们将把文本看成单词向量或者词条向量,也就是说将句子转换为向量。考虑出现在所有文档中的所有单词,再决定将哪些词纳人词汇表或者说所要的词汇集合,然后必须要将每一篇文档转换为词汇表上的向量。

  词表到向量的转换函数:

 1 def loadDataSet():
 2     postingList=[['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
 3                  ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
 4                  ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
 5                  ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
 6                  ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
 7                  ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
 8     classVec = [0,1,0,1,0,1]    #1 代表侮辱性词, 0 代表正常言论
 9     return postingList,classVec
10                  
11 def createVocabList(dataSet): #根据数据集返回  关键词汇向量
12     vocabSet = set([])  # 创建空的集合
13     for document in dataSet:
14         vocabSet = vocabSet | set(document) # 操作符 | 用来求两个集合的并集
15     return list(vocabSet)  # 返回 集合中 所有不重复的关键词
16 
17 def setOfWords2Vec(vocabList, inputSet):# vocabList=词汇表 ,inputSet = 输入的文档 #文档词汇 转换 成文档 向量
18     returnVec = [0]*len(vocabList) # 生成一个值为0,长度和vocabList一样的集合
19     for word in inputSet:
20         if word in vocabList:
21             returnVec[vocabList.index(word)] = 1
22         else: print "the word: %s is not in my Vocabulary!" % word
23     return returnVec # 返回 输入文档inputSet 的向量

   第一个函数loadDataset()创建了一些实验样本。该函数返回的第一个变量是进行词条切分后的文档集合,这些文档来自斑点犬爱好者留言板。这些留言文本被切分成一系列的词条集合,标点符号从文本中去掉,后面会探讨文本处理的细节。loadDataSet( )函数返回的第二个变量是一个类别标签的集合。这里有两类,侮辱性和非侮辱性。这些文本的类别由人工标注,这些标注信息用于训练程序以便自动检测侮辱性留言。
      下一个函数createVocabList()会创建一个包含在所有文档中出现的不重复词的列表,为此使用了Python 的set数据类型。将词条列表输给set构造数,set()就会返回一个不重复词表。首先,创建一个空集合, 然后将每篇文档返回的新词集合添加到该集合中。操作符丨用于求两个集合的并集,这也是一个按位或(or) 操作符(参见附录0) 。在数学符号表示上,按位或操作与集合求并操作使用相同记号。
      获得词汇表后,便可以使用函数setofWords2Vec(),该函数的输人参数为词汇表及某个文档,输出的是文档向量,向量的每一元素为1或0,分别表示词汇表中的单词在输人文档中是否出现。函数首先创建一个和词汇表等长的向量,并将其元素都设置为0 。接着,遍历文档中的所有单词,如果出现了词汇表中的单词,则将输出的文档向量中的对应值设为1。一切都顺利的话,就不需要检查某个词是否还vobalist中,后边可能会用到这一操作。

  测试代码:

 1 >>> listOPost,listClasses=bayes.loadDataSet()
 2 >>> listOPost
 3 [['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']]
 4 >>> listClasses
 5 [0, 1, 0, 1, 0, 1]
 6 >>> myVocabList=bayes.createVocabList(listOPost)
 7 >>> myVocabList
 8 ['garbage', 'love', 'my', 'dog', 'park', 'buying', 'help', 'is', 'so', 'to', 'ate', 'steak', 'please', 'him', 'not', 'stupid', 'take', 'maybe', 'posting', 'problems', 'worthless', 'I', 'food', 'quit', 'mr', 'dalmation', 'stop', 'has', 'licks', 'how', 'flea', 'cute']
 9 #检查上述的词表发现,这里不会出现重复的单词
10 >>> bayes.setOfWords2Vec(myVocabList,listOPost[0])# 把文档转换成向理
11 [0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0]
12 >>> bayes.setOfWords2Vec(myVocabList,listOPost[3])# 把文档转换成向理
13 [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]

六、训练算法:从词向量计算概率

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

 

  我们将使用上述公式,对每个类计算该值,然后比较这两个概率值的大小。如何计算呢?首先可以通过类别i(侮辱性留言或非侮辱性留言)中文档数除以总的文档数来计算概率p(ci)。接下来计算p(w|ci),这里就要用到朴素贝叶斯假设。如果将w展开为一个个独立特征,那么就可以将上述概率写作p(w0,w1,w2..wN|ci)。这里假设所有词都互相独立,该假设也称作条件独立性假设,它意味着可以使用p(w0|ci)p(w1|ci)p(w2|ci)...p(wN|ci)来计算上述概率,这就极大地简化了计算的过程。

该函数的伪代码如下:

 计算每个类别中的文档数目
对每篇训练文档:
      对每个类别:
            如果词条出现文档中―增加该词条的计数值
            增加所有词条的计数值
      对每个类别:
            对每个词条:
                将该词条的数目除以总词条数目得到条件概率

     还回每个类别的条件概率

  朴素贝叶斯分类器训练函数:

 1 def trainNB0(trainMatrix,trainCategory):  #trainMatrix 所有文档的向量形式  trainCategory 文档的分类 类别向量 #计算不同分类的文档概率,即 P(W|C1) P(W|C0)
 2     numTrainDocs = len(trainMatrix) #  numTrainDocs = 总文档数
 3     numWords = len(trainMatrix[0]) # numWords= 词汇长度
 4     pAbusive = sum(trainCategory)/float(numTrainDocs)  # 计算 分类=1 的文档比例 p(1)的概率,这是一个二分类的问题 p(0)=1-p(1)
 5     p0Num = zeros(numWords); p1Num = zeros(numWords)      #初始化概率, 分子
 6     p0Denom = 0.0; p1Denom = 0.0                        #定义分母
 7     for i in range(numTrainDocs):
 8         if trainCategory[i] == 1: #类别为 1 
 9             p1Num += trainMatrix[i]  # 分子向量累计相加
10             p1Denom += sum(trainMatrix[i])#分母 向量之和
11         else:
12             p0Num += trainMatrix[i]
13             p0Denom += sum(trainMatrix[i])
14     p1Vect = p1Num/p1Denom          # 当类别为 1 时,计算每个文档中出现 词汇的概率
15     p0Vect = p0Num/p0Denom          #
16     return p0Vect,p1Vect,pAbusive

   代码函数中的输入参数为文档矩阵trainMa-trix,以及由每篇文档类别标签所构成的向量train-Category。首先,计算文档属于侮辱性文档(class=1)的概率,即P(1)。因为这是一个二类分类问题,所以可以通过1-P(1)得到P(0)。对于多于两类的分类问题,则需要对代码稍加修改。

  计算p(wi|c1)和p(wi|c0),需要初始化程序中的分子变量和分母变量①。由于w中元素如此众多,因此可以使用NumPy数组快速计算这些值。

  上述程序中的分母变量是一个元素个数等于词汇表大小的NumPy数组。在for循环中,要遍历训练集trainMatrix中的所有文档。一旦某个词语(侮辱性或正常词语)在某一文档中出现,则该词对应的个数(p1Num或者p0Num)就加1,而且在所有的文档中,该文档的总词数也相应加1②。对于两个类别都要进行同样的计算处理。最后,对每个元素除以该类别中的总词数③。利用NumPy可以很好实现,用一个数组除以浮点数即可,若使用常规的Python列表则难以完成这种任务,读者可以自己尝试一下。最后,函数会返回两个向量和一个概率。

  接下来试验一下,在Python提示符下输入:

 1 >>> listOPosts,listClasses=bayes.loadDataSet()
 2 
 3 >>> listOPosts
 4 [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
 5  ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
 6  ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'], 
 7  ['stop', 'posting', 'stupid', 'worthless', 'garbage'], 
 8  ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
 9  ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
10 >>> listClasses
11 [0, 1, 0, 1, 0, 1]
12 
13 >>> myVocabList=bayes.createVocabList(listOPosts)
14 #至此我们构建了一个包含所有词的列表myVocabList。
15 >>> myVocabList
16 ['garbage', 'love', 'my', 'dog', 'park', 'buying', 'help', 'is', 'so', 'to', 'ate', 'steak', 'please', 'him', 'not', 'stupid', 'take', 'maybe', 'posting', 'problems', 'worthless', 'I', 'food', 'quit', 'mr', 'dalmation', 'stop', 'has', 'licks', 'how', 'flea', 'cute']
17 
18 >>> trainMat=[]
19 >>> for postinDoc in listOPosts:
20     trainMat.append(bayes.setOfWords2Vec(myVocabList,postinDoc))
21 
22 >>> trainMat
23 [[0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0], 
24 [0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
25 [0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], 
26 [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 
27 [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0], 
28 [0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]]
29 #该for循环使用词向量来填充trainMat列表。下面给出属于侮辱性文档的概率以及两个类别的概率向量
30 >>> p0V,p1V,pAb=bayes.trainNB0(trainMat,listClasses)
31 >>> pAb  #这就是任意文档属于侮辱性文档的概率。
32 0.5
33 >>> p0V
34 array([ 0.        ,  0.04166667,  0.125     ,  0.04166667,  0.        ,
35         0.        ,  0.04166667,  0.04166667,  0.04166667,  0.04166667,
36         0.04166667,  0.04166667,  0.04166667,  0.08333333,  0.        ,
37         0.        ,  0.        ,  0.        ,  0.        ,  0.04166667,
38         0.        ,  0.04166667,  0.        ,  0.        ,  0.04166667,
39         0.04166667,  0.04166667,  0.04166667,  0.04166667,  0.04166667,
40         0.04166667,  0.04166667])
41 >>> p1V
42 array([ 0.05263158,  0.        ,  0.        ,  0.10526316,  0.05263158,
43         0.05263158,  0.        ,  0.        ,  0.        ,  0.05263158,
44         0.        ,  0.        ,  0.        ,  0.05263158,  0.05263158,
45         0.15789474,  0.05263158,  0.05263158,  0.05263158,  0.        ,
46         0.10526316,  0.        ,  0.05263158,  0.05263158,  0.        ,
47         0.        ,  0.05263158,  0.        ,  0.        ,  0.        ,
48         0.        ,  0.        ])

  首先,我们发现文档属于侮辱类的概率pAb为0.5,该值是正确的。接下来,看一看在给定文档类别条件下词汇表中单词的出现概率,看看是否正确。词汇表中的第一个词是cute,其在类别0中出现1次,而在类别1中从未出现。对应的条件概率分别为0.041 666 67与0.0。该计算是正确的。我们找找所有概率中的最大值,该值出现在P(1)数组第26个下标位置,大小为0.157 89474。在myVocabList的第26个下标位置上可以查到该单词是stupid。这意味着stupid是最能表征类别1(侮辱性文档类)的单词。

 

七、测试算法:根据现实情况修改分类器

  利用贝叶斯分类器对文档进行分类时,要计算多个概率的乘积以获得文档属于某个类别的概率,即计算p(w0|1)p(w1|1)p(w2|1)。如果其中一个概率值为0,那么最后的乘积也为0。为降低这种影响,可以将所有词的出现数初始化为1,并将分母初始化为2。在文本编辑器中打开bayes.py文件,并将trainNB0()的第4行和第5行修改为:

p0Num=ones(numWords);p1Num=ones(numWords)

p0Denom=2.0;p1Denom=2.0

  另一个遇到的问题是下溢出,这是由于太多很小的数相乘造成的。当计算乘积p(w0|ci)p(w1|ci)p(w2|ci)...p(wn|ci)时,由于大部分因子都非常小,所以程序会下溢出或者得到不正确的答案。(读者可以用Python尝试相乘许多很小的数,最后四舍五入后会得到0。)

  一种解决办法是对乘积取自然对数。在代数中有ln(a*b) =ln(a)+ln(b),于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时,采用自然对数进行处理不会有任何损失。图 给出函数f(x)与ln(f(x))的曲线。检查这两条曲线,就会发现它们在相同区域内同时增加或者减少,并且在相同点上取到极值。它们的取值虽然不同,但不影响最终结果。

函数f(x)与ln(f(x))会一块增大。这表明想求函数的最大值时,可以使用该函数的自然对数来替换原函数进行求解

通过修改return前的两行代码,将上述做法用到分类器中:

p1Vect=log(p1Num/p1Denom)

p0Vect=log(p0Num/p0Denom)

  修改后的 trainNB0 代码:

 1 def trainNB0(trainMatrix,trainCategory):
 2     numTrainDocs = len(trainMatrix)
 3     numWords = len(trainMatrix[0])
 4     pAbusive = sum(trainCategory)/float(numTrainDocs)
 5     p0Num = ones(numWords); p1Num = ones(numWords)      #change to ones() 
 6     p0Denom = 2.0; p1Denom = 2.0                        #change to 2.0
 7     for i in range(numTrainDocs):
 8         if trainCategory[i] == 1:
 9             p1Num += trainMatrix[i]
10             p1Denom += sum(trainMatrix[i])
11         else:
12             p0Num += trainMatrix[i]
13             p0Denom += sum(trainMatrix[i])
14     p1Vect = log(p1Num/p1Denom)          #change to log()
15     p0Vect = log(p0Num/p0Denom)          #change to log()
16     return p0Vect,p1Vect,pAbusive

 

  现在已经准备好构建完整的分类器了。当使用NumPy向量处理功能时,这一切变得十分简单。打开文本编辑器,将下面的代码添加到bayes.py中:

  朴素贝叶斯分类函数

 

 1 def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):  #根据 输入的 文档 对文档进行分类 预测 P(W|C0)=p0Vec  P(W|C1)=p0Vec
 2     p1 = sum(vec2Classify * p1Vec) + log(pClass1)    #element-wise mult
 3     p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
 4     if p1 > p0:
 5         return 1
 6     else: 
 7         return 0
 8     
 9 def testingNB():
10     listOPosts,listClasses = loadDataSet()
11     myVocabList = createVocabList(listOPosts)
12     trainMat=[]
13     for postinDoc in listOPosts:
14         trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
15     p0V,p1V,pAb = trainNB0(array(trainMat),array(listClasses))
16     testEntry = ['love', 'my', 'dalmation']
17     thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
18     print (testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
19     testEntry = ['stupid', 'garbage']
20     thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
21     print (testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))

 

   classifyNB代码有4个输入:要分类的向量vec2Clas-sify以及使用函数trainNB0()计算得到的三个概率。使用NumPy的数组来计算两个向量相乘的结果①。这里的相乘是指对应元素相乘,即先将两个向量中的第1个元素相乘,然后将第2个元素相乘,以此类推。接下来将词汇表中所有词的对应值相加,然后将该值加到类别的对数概率上。最后,比较类别的概率返回大概率对应的类别标签。

  下面来看看实际结果。将程序清单4-3中的代码添加之后,在Python提示符下输入:

1 >>> imp.reload(bayes)
2 'bayes' from 'F:\\99999_算法\\《机器学习实战》源代码\\machinelearninginaction\\Ch04\\bayes.py'>
3 >>> bayes.testingNB()
4 ['love', 'my', 'dalmation'] classified as:  0
5 ['stupid', 'garbage'] classified as:  1

 

八、文档词袋模型

   目前为止,我们将每个词的出现与否作为一个特征,这可以被描述为词集模型(set-of-words model)。如果一个词在文档中出现不止一次,这可能意味着包含该词是否出现在文档中所不能表达的某种信息,这种方法被称为词袋模型(bag-of-wordsmodel)。在词袋中,每个单词可以出现多次,而在词集中,每个词只能出现一次。为适应词袋模型,需要对函数setOf-Words2Vec()稍加修改,修改后的函数称为bagOfWords2Vec()。下面的程序清单给出了基于词袋模型的朴素贝叶斯代码。它与函数setOfWords2Vec()几乎完全相同,唯一不同的是每当遇到一个单词时,它会增加词向量中的对应值,而不只是将对应的数值设为1。

  朴素贝叶斯词袋模型

def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

 

九、示例:使用朴素贝叶斯过滤垃圾邮件

 

 

转载于:https://www.cnblogs.com/netuml/p/5725650.html

你可能感兴趣的:(机器学习算法( 四、朴素贝叶斯算法))