机器学习之朴素贝叶斯（四）

主要内容：

·使用概率分布进行分类
·学习朴素贝叶斯分类器
·解析RSS源数据
·使用朴素贝叶斯来分析不同地区的态度

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

---

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

朴素贝叶斯

• 优点：在数据较少的情况下仍然有效，可以处理多类问题。

• 缺点：对于输入的数据的准备方式较为敏感。

• 适用数据类型：标称型数据。

我们先来了解一下贝叶斯决策理论。

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

假设我们图中有两类数据统计参数。

用p1(x,y)表示数据点(x,y)属于类别1(图中圆点表示的类别)的概率，

用p2(x,y)表示数据点(x,y)属于类别2(图中三角形表示类别的)的概率。

• 如果p1(x,y) > p2(x,y)，那么类别为1；
• 如果p2(x,y) > p1(x,y)，那么类别为2.。

以上也说明了贝叶斯决策理论的核心思想，我们选择具有最高概率的决策。

如果上面这个图中，使用6个参数来表示，你会更加想使用哪种方法类进行分类呢？

如果是kNN算法，计算量就比较大；如果是使用决策树，不会非常成功。

那么最佳的方法其实是使用贝叶斯决策理论。

4.2 条件概率

我们来复习一下本科时候学习的概率论中的条件概率。

---

假设现在有一个装了7块石头的的罐子，其中3块是白的，4块是黑色的。如果我们从罐子中随机取出一块石头，那么白色石头的可能性是多少？黑色的又是多少？

显然，取得黑色是概率是4/7 ； 取得白色的概率是 3/7 ；

如果我们的石头放在两个桶中，那么上述的概率又该如何计算呢？

我们先设，取得黑色的概率为P(black) ， 取得白色的概率为P(white) 。

那么如何计算黑色或者白色取得的概率问题，就是条件概率。

假设计算的是从B桶取到白色石头的概率，此概率可以记为P(white | bucketsB) ， 并称之为“在已知石头出自B桶的条件下，取出白色石头的概率”。

此时

P(white | bucketsA) = 2/4 ; P(white | bucketsB) = 1/3 ;

那么条件概率的计算公式就如下：

P(white | bucketsB) = P(white and bucketsB) / P bucketsB)

我们是需要验证折合后公式的合理性，

P(white and bucketsB) = 1/7 这个就是B桶的白色石头除以两个桶的石头数量总和。再次，B桶有3个石头，总石头数是7，那么 公式就是

P(white | bucketsB) = P(white and bucketsB) / P bucketsB) = (1/7)
/(3/7) = 1/3

另外一种计算条件概率的方法称之为贝叶斯准则。公式如下：

P (c|x ) = P (x|c) * p(c) / p(x)

4.3 使用条件概率来分类

假设我们图中有两类数据统计参数。

用p1(x,y)表示数据点(x,y)属于类别1(图中圆点表示的类别)的概率，

用p2(x,y)表示数据点(x,y)属于类别2(图中三角形表示类别的)的概率。

如果p1(x,y) > p2(x,y)，那么类别为C1；
如果p2(x,y) > p1(x,y)，那么类别为C2.。

上面只是为了简化问题。

使用贝叶斯准则来交换概率中条件与结果：

应用贝叶斯准则得到，如下：

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

如果 P(c1,x|y)>P(c2|x,y)，那么属于类别c1 。
如果 P(c1,x|y)

def loanDataSet():
   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']]
   classVec = [0,1,0,1,0,1]  #1代表侮辱性文字，0代表正常言论
   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:
           returnVec[VocabList.index(word)] = 1
       else:
           print "the word:%s is not in my Vocabulary!" % word
   return returnVec

分析：

1.第一个函数创建了一些实验样本。其中第一个变量是进行词条切分后的文档集合，第二个变量是一个类别标签的集合。

2.第二个函数会创建一个包含在所有文档中出现的不重复词的列表。set也会返回一个不重复词表。

3.第三个函数的输入参数为词汇表以及某个文档。创建一个其中所含元素都为0的向量并与词汇表等长，

然后函数会创建一个遍历文档中所有单词，如果出现了词汇中的表中的单词，输出向量为1.

来测试代码：

In [6]: import bayes

In [7]: reload(bayes)
Out[7]: <module 'bayes' from 'bayes.py'>

In [8]: listOposts,listClasses = bayes.loadDataSet()

In [10]: myVocabList = bayes.createVocabList(listOposts)

In [11]: myVocabList 
Out[11]: 
['cute', 'love', 'help',
'garbage', 'quit', 'I', 'problems', 'is', 'park', 'stop', 'flea', 'dalmation', 'licks', 'food', 'not', 'him',
'buying', 'posting', 'has', 'worthless', 'ate', 'to', 'maybe', 'please', 'dog', 'how', 'stupid', 'so',
'take', 'mr','steak', 'my']

In [13]: bayes.setOfWords2Vec(myVocabList,listOposts[0])
Out[13]: 
[0,0,1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0,0, 0, 
1, 0, 0, 0, 0, 1, 1, 0,0,0, 0, 0, 0, 1]

In [15]: bayes.setOfWords2Vec(myVocabList,listOposts)
the word:['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'] is not in my Vocabulary!
the word:['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'] is not in my Vocabulary!
the word:['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'] is not in my Vocabulary!
the word:['stop', 'posting', 'stupid', 'worthless', 'garbage'] is not in my Vocabulary!
the word:['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'] is not in my Vocabulary!
the word:['quit', 'buying', 'worthless', 'dog', 'food', 'stupid'] is not in my Vocabulary!
Out[15]: 
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]

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

函数的伪代码如下：

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

代码如下：

# 朴素贝叶斯的=分类器训练函数

def trainNB0(trainMatrix,trainCategory):
   numTrainDocs = len(trainMatrix)
   numWords = len(trainMatrix[0])
   pAbusive = sum(trainCategory)/float(numTrainDocs)
   #初始化概率
   p0Num = zeros(numWords)
   p1Num = zeros(numWords)
   p0Denom = 0.0 
   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])
   p1Vect = p1Num/p1Denom
   p0Vect = p0Num/p0Denom
   return p0Vect,p1Vect,pAbusive

解析：

1.代码函数中输入参数为文档矩阵 trainMatrix ，以及由每篇文档类别标签的所构成的向量trainCategory

2.计算文档属于侮辱性文档（class=1）的概率，即p（1）

3.计对每个元素的除以该类别中的总词数。

In [1]: from numpy import *

In [4]: import bayes

In [5]: reload(bayes)
Out[5]: 'bayes' from 'bayes.pyc'>

In [6]: listOposts,listClasses = bayes.loadDataSet()

In [7]: myVocabList = bayes.createVocabList(listOposts)

In [8]: trainMat = []

In [10]: for postinDoc in listOposts:
   ...:     trainMat.append(bayes.setOfWords2Vec(myVocabList,postinDoc))
...:

#给出侮辱性文档的概率以及两个类别的概率向量
In [11]: pov,p1v,pAb = bayes.trainNB0(trainMat,listClasses)

In [12]: pAb
Out[12]: 0.5




#任意文档的侮辱性概率值
In [13]: pov
Out[13]: 
array([ 0.04166667,  0.04166667,  0.04166667, ...,  0.04166667,
       0.04166667,  0.125     ])

In [14]: p1v
Out[14]: array([ 0.,  0.,  0.,0.053 ...,  0.052，0.,  0.,  0.])

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

贝叶斯分类器对文档进行分类的时，要计算多个概率的乘积以获得文档属于某个类别的概率。

即是计算 p(w0|1)p(w1|1)p(w2|1) ，如果其中一个概率为0，那么最终的乘积也为0，为了降低这种影响，我们可以将所有词的出现次数初始化为1，将分母初始化为2。

我们改变bayes.py文件的第4行和第5行，修改为：

#初始化概率
   p0Num = ones(numWords)
   p1Num = ones(numWords)
   p0Denom = 2.0 
   p1Denom = 2.0

另外一个问题是下溢出（这是由于太多的很小的数相乘，最后四舍五入就会得到0）。解决办法就是取自然对数。

我们将采取取自然对数来处理。（通过求对数可以避免）

至此，我们可以修改bayes.py文件中return前的两行代码：

  p1Vect = log(p1Num/p1Denom)
   p0Vect = log(p0Num/p0Denom)

我们继续增加代码：

#朴素贝叶斯分类函数            
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
   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,'classified as: ',classifyNB(thisDoc,p0v,p1v,pAb)
   testEntry = ['stupid','garbage']
   thisDoc = array(setOfWords2Vec(myVocabList,testEntry))
   print testEntry,'classified as: ',classifyNB(thisDoc,p0v,p1v,pAb)    

testingNB()函数是一个便利函数，这个函数封装所有操作，以节省输入上述代码的时间。

运行代码，看看结果：

In [14]: reload(bayes)
Out[14]: <module 'bayes' from 'bayes.py'>

In [15]: bayes.testingNB()
['love', 'my', 'dalmation'] classified as: 0
['stupid', 'garbage'] classified as: 1

4.5.4 准备数据：文档词袋模型

（1）词集模型：Set Of Words（SOW），单词构成的集合，集合自然每个元素都只有一个，也即词集中的每个单词都只有一个
（2）词袋模型：Bag Of Words（BOW），如果一个单词在文档中出现不止一次，并统计其出现的次数（频数）

在词集中，每个词只能出现一次。

在词袋中，每个单词可以出现多次。

代码4-4 朴素贝叶斯词袋模型（基于词袋模型的朴素贝叶斯代码）

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

通过上述代码，我们已经构建好了分类器。

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

使用朴素贝叶斯对电子邮件进行分类：

步骤：

1.收集数据：提供文本文件

2.准备数据：将文本文件解析成词条向量

3.分析数据：检查词条确保解析的正确性

4.训练算法：使用我们之前建立的trainNB0()函数

5.测试算法：使用classifyNB()，构建一个新的测试函数来计算文档集的错误率

6.使用算法：构建一条完整的程序对一组文档进行分类，将错分的文档输出到屏幕上

4.6.1 准备数据：切分文本

对于一个文本文档，我们可以使用python的string.split()方法将其切分。

In [17]: mysent = 'This book is the best book on python or M.L. I have ever laid eyes upon.'

In [18]: mysent.split()
Out[18]:
['This','book','is','the','best','book','on','python',
'or','M.L.','I','have','ever','laid','eyes','upon.']

我们看到已经切分开了，但是标点符号被成了词的一部分，我们利用正则表达式来切分，去除除了单词或者数字之外的任意字符串。

In [19]: import re

In [20]: regEx = re.compile('\\W*')

In [21]: listOfTokens = regEx.split(mysent)

In [22]: listOfTokens
Out[22]:
['This','book','is','the','best','book','on','python',
'or','M','L''I','have','ever','laid','eyes','upon','']

我们看到有很多空字符串，我们可以，先转换为小写，然后返回长度大于0的字符

In [23]: [i.lower() for i in listOfTokens if len(i) > 0]
Out[23]:
['this','book''is','the','best','book','on','python',
'or','m','l','i','have','ever','laid','eyes','upon']

我们导入一封电子邮件，然后用正则表达式简单的处理一下,最终的结果，我们可以进入spyder里面看看。

In [27]: emailTxt = open(r'E:\ML\ML_source_code\mlia\Ch04\email\ham\6.txt').read()

In [28]: listof = regEx.split(emailTxt)

In [29]: listofo = [i.lower() for i in listof if len(i) > 3]

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

# 文本解析及完整的垃圾邮件的测试函数
def textParse(bigString):
   listOfTokens = re.split(r'\W*',bigString)
   return [x.lower() for x in listOfTokens if len(x) > 2]

def spamTest():
   docList = []; classList = []; fullText = []
   #导入文件并解析文本
   for i in range(1,26):
       wordList = textParse(open(r'E:\ML\ML_source_code\mlia\Ch04\email\spam\%d.txt' % i).read())
       docList.append(wordList)
       fullText.extend(wordList)
       classList.append(1)
       wordList = textParse(open(r'E:\ML\ML_source_code\mlia\Ch04\email\ham\%d.txt' % i).read())
       docList.append(wordList)
       fullText.extend(wordList)
       classList.append(0)
   vocabList = createVocabList(docList)
   traningSet = range(50); testSet = []
   #随机的构建训练集
   for i in range(10):
       randIndex = int(random.uniform(0,len(traningSet)))
       testSet.append(traningSet[randIndex])
       del(traningSet[randIndex])

   trainMat = []; trainClasses = []
   for docIndex in traningSet:
       trainMat.append(setOfWords2Vec(vocabList,docList[docIndex]))
       trainClasses.append(classList[docIndex])
   p0v,p1v,pSpam = trainNB0(array(trainMat),array(trainClasses))
   errorCount = 0

   for docIndex in testSet:
       wordVector = setOfWords2Vec(vocabList,docList[docIndex])
       if classifyNB(array(wordVector),p0v,p1v,pSpam) != classList[docIndex]:
           errorCount += 1
   print 'the error rate is:',float(errorCount)/len(testSet)

textParse() 函数接受一个大字符串并将其解析为字符串列表。
spamTest()函数对贝叶斯垃圾邮件分类器进行自动化处理。
算法的训练方法是从总的数据集中随机选择数字，将其添加到测试集中，同时将其从测试机中删除。这种随机选择数据的一部分作为训练集，而剩余部分作为测试集的过程称之为 留存交叉验证。

In [42]: reload(bayes)
Out[42]: <module 'bayes' from 'bayes.py'>

In [43]: bayes.spamTest()
the error rate is: 0.0

In [44]: reload(bayes)
Out[44]: <module 'bayes' from 'bayes.py'>

In [45]: bayes.spamTest()
the error rate is: 0.1

代码会对10封电子邮件进行分类，获得的错误率0.1,0.2,0.1等，我做了10词最终平均了一下，错误了吧大概为5% 。这里一直出现的错误率其实就是将垃圾邮件误判为正常邮件。

4.7 使用朴素贝叶斯分类器从个人广告中获取区域性倾向

我们分别从美国的两个城市中选取一些人，通过分析他们发布的征婚信息，来比较两个城市的人们在征婚广告用词上有什么不同。

步骤：

收集数据：从RSS源收集内容，这里需要对RSS源构建一个接口
准备数据：将文本文件解析成词条向量
分析数据：检查词条确保解析的正确性
训练算法：使用我们之前建立的trainNB0()函数
测试算法：观察错误率，确保分类器可用
使用算法：构建一个完整的程序，封装所有内容

4.7.1 收集数据：导入RSS源

先安装feedparser这个模块。然后进入这个RSS源

In [62]: import feedparser
In [63]: ny = feedparser.parse('http://newyork.craigslist.org/stp/index.rss')
In [64]: len(ny['entries'])
Out[64]: 25

# 使用RSS源分类器及高频词去除函数
ny = feedparser.parse('http://newyork.craigslist.org/stp/index.rss')
sf = feedparser.parse('http://sfbay.craigslist.org/stp/index.rss')

def calcMostFre(vocabList,fullText):
   """
   函数遍历词汇表中出现的每个词语的次数，
   并排序，返回次数最高的30个词
   """
   freqDict = {}
   for token in vocabList:
       freqDict[token] = fullText.count(token)
   sortedFreq = sorted(freqDict.iteritems(),key = operator.itemgetter(1),reverse = True)
   return sortedFreq[:30]

def localWords(feed1,feed0):
   docList = [];classList = [];fullText = []
   minLen = min(len(feed1['entries']),len(feed0['entries']))
   for i in range(minLen):
       #每次只去访问一条RSS源
       wordList = textParse(feed1['entries'][i]['summary'])
       docList.append(wordList)
       fullText.extend(wordList)
       classList.append(1)
       wordList = textParse(feed0['entries'][i]['summary'])
       docList.append(wordList)
       fullText.extend(wordList)
       classList.append(0)      
   vocabList = createVocabList(docList)
   #去掉那些出现次数最高的那些词
   top30Words = calcMostFre(vocabList,fullText)
   for pairW in top30Words:
       if pairW[0] in vocabList:
           vocabList.remove(pairW[0])
   trainingSet = range(2*minLen); testSet = []
   for i in range(20):
       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 'the error rate is: ',float(errorCount)/len(testSet)
   return vocabList,p0v,p1v

辅助函数calcMostFre遍历词汇表中出现的每个词语的次数， 并排序，返回次数最高的30个词
函数localWords()与spamTest()最大的区别在于，函数里面访问的RSS源，不是文件。
函数calcMostFre()获取次数最高的30个词随后移除。

如果我们注释掉 移除移除高频词的三行代码，比较注释前后的分类性能会发现，错误率会大大的提升的。比如注释之前大概是50%左右，注释后，就是70%左右。

主要原因是这些高频词占了我们所有用词的30% 。主要原因是因为英文语言本身大部分都是冗余或小黄人结构性辅助词。

In [3]: import bayes

In [4]: reload(bayes)
Out[4]: <module 'bayes' from 'bayes.pyc'>

In [8]: ny = feedparser.parse('http://newyork.craigslist.org/stp/index.rss')
  ...: sf = feedparser.parse('http://sfbay.craigslist.org/stp/index.rss')

In [14]: vocabList,pSF,pNY = bayes.locWords(ny,sf)
the error rate is: 0.45

In [15]: vocabList,pSF,pNY = bayes.locWords(ny,sf)
the error rate is: 0.3

In [16]: vocabList,pSF,pNY = bayes.locWords(ny,sf)
the error rate is: 0.4

In [17]: vocabList,pSF,pNY = bayes.locWords(ny,sf)
the error rate is: 0.5

In [18]: vocabList,pSF,pNY = bayes.locWords(ny,sf)
the error rate is: 0.25

我们发现这里的错误率是比邮件分类的错误率是要高的，这里关注的是单词概率而不是实际分类，可以通过辅助函数改变要移除的单词数目，相应的，错误率就会降低。

4.7.2 分析数据：显示地域相关的用词

可以先对向量pSF与pNY进行排序，然后按照顺序将词打印出来。

# 最具表征性的词汇显示函数

def getTopWords(ny,sf):
   vocabList,p0V,p1V = localWords(ny,sf)
   topNY = []; topSF = []
   for i in range(len(p0V)):
       if p0V[i] > -6.0:
           topSF.append((vocabList[i],p0V[i]))
       if p1V[i] > -6.0:
           topNY.append((vocabList[i],p1V[i]))
   sortedSF = sorted(topSF,key = lambda pair: pair[1], reverse = True)
   print "SF**SF****SF**SF**SF****SF**SF**SF****SF**SF**SF****SF**SF**SF****SF**SF"

   for item in sortedSF:
       print item[0]
   sortedNY = sorted(topNY,key = lambda pair: pair[1], reverse = True)
   print "NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY"

   for item in sortedNY:
       print item[0] 

这个代码之前的排名最高的X个单词不同，这里可以返回大于某个阈值的所有词。

In [29]: reload(bayes)
Out[29]: 'bayes' from 'bayes.pyc'>

In [30]: bayes.getTopWords(ny,sf)
the error rate is:  0.45
SF**SF****SF**SF**SF****SF**SF**SF****SF**SF**SF****SF**SF**SF****SF**SF
felt
stay
develops
chris
friends
pool
younger
age
hello
depth
NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY
chris
pool
ago
younger
longer
together
curvy
depth
lives

4.8 总结

对于分类而言，使用概率的方法要比使用硬规则更为有效。贝叶斯概率以及贝叶斯准则提供了一套利用已知的值来估计位置概率的有效方法。