機器學習實戰筆記(Python實現)-03-朴素貝葉斯

本文轉載自查看原文 2016-12-18 21:18 17304 機器學習

---------------------------------------------------------------------------------------

本系列文章為《機器學習實戰》學習筆記，內容整理自書本，網絡以及自己的理解，如有錯誤歡迎指正。

源碼在Python3.5上測試均通過，代碼及數據 --> https://github.com/Wellat/MLaction

---------------------------------------------------------------------------------------

1、算法概述

1.1 朴素貝葉斯

朴素貝葉斯是使用概率論來分類的算法。其中朴素：各特征條件獨立；貝葉斯：根據貝葉斯定理。

根據貝葉斯定理，對一個分類問題，給定樣本特征x，樣本屬於類別y的概率是：

-------（1）

在這里，x 是一個特征向量，設 x 維度為 M。因為朴素的假設，即特征條件獨立，根據全概率公式展開，上式可以表達為：

這里，只要分別估計出，特征 Χ

1.2 算法特點

優點：在數據較少的情況下仍然有效，可以處理多類別問題。

缺點：對於輸入數據的准備方式較為敏感。

適用數據類型：標稱型數據。

2、使用Python進行文本分類

要從文本中獲取特征，需要先拆分文本。可以把詞條想象為單詞，也可以使用非單詞詞條，如URL、IP地址或者任意其他字符串。然后將每一個文本片段表示為一個詞條向量，其中值為1表示詞條出現在文檔中，0表示詞條未出現。

2.1 准備數據：從文本中構建詞向量

 1 from numpy import *
 2 
 3 def loadDataSet():
 4     '''
 5     postingList: 進行詞條切分后的文檔集合
 6     classVec:類別標簽    
 7     '''
 8     postingList=[['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
 9                  ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
10                  ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
11                  ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
12                  ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
13                  ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
14     classVec = [0,1,0,1,0,1]    #1代表侮辱性文字，0代表正常言論
15     return postingList,classVec
16 
17 def createVocabList(dataSet):
18     vocabSet = set([])#使用set創建不重復詞表庫
19     for document in dataSet:
20         vocabSet = vocabSet | set(document) #創建兩個集合的並集
21     return list(vocabSet)
22 
23 def setOfWords2Vec(vocabList, inputSet):
24     returnVec = [0]*len(vocabList)#創建一個所包含元素都為0的向量
25     #遍歷文檔中的所有單詞，如果出現了詞匯表中的單詞，則將輸出的文檔向量中的對應值設為1
26     for word in inputSet:
27         if word in vocabList:
28             returnVec[vocabList.index(word)] = 1
29         else: print("the word: %s is not in my Vocabulary!" % word)
30     return returnVec
31 '''
32 我們將每個詞的出現與否作為一個特征，這可以被描述為詞集模型(set-of-words model)。
33 如果一個詞在文檔中出現不止一次，這可能意味着包含該詞是否出現在文檔中所不能表達的某種信息,
34 這種方法被稱為詞袋模型(bag-of-words model)。
35 在詞袋中，每個單詞可以出現多次，而在詞集中，每個詞只能出現一次。
36 為適應詞袋模型，需要對函數setOfWords2Vec稍加修改，修改后的函數稱為bagOfWords2VecMN
37 '''
38 def bagOfWords2VecMN(vocabList, inputSet):
39     returnVec = [0]*len(vocabList)
40     for word in inputSet:
41         if word in vocabList:
42             returnVec[vocabList.index(word)] += 1
43     return returnVec

2.2 訓練算法：從詞向量計算概率

計算每個類別的條件概率，偽代碼：

 1 def trainNB0(trainMatrix,trainCategory):
 2     '''
 3     朴素貝葉斯分類器訓練函數(此處僅處理兩類分類問題)
 4     trainMatrix:文檔矩陣
 5     trainCategory:每篇文檔類別標簽
 6     '''
 7     numTrainDocs = len(trainMatrix)
 8     numWords = len(trainMatrix[0])
 9     pAbusive = sum(trainCategory)/float(numTrainDocs)
10     #初始化所有詞出現數為1，並將分母初始化為2，避免某一個概率值為0
11     p0Num = ones(numWords); p1Num = ones(numWords)#
12     p0Denom = 2.0; p1Denom = 2.0 #
13     for i in range(numTrainDocs):
14         if trainCategory[i] == 1:
15             p1Num += trainMatrix[i]
16             p1Denom += sum(trainMatrix[i])
17         else:
18             p0Num += trainMatrix[i]
19             p0Denom += sum(trainMatrix[i])
20     #將結果取自然對數，避免下溢出，即太多很小的數相乘造成的影響
21     p1Vect = log(p1Num/p1Denom)#change to log()
22     p0Vect = log(p0Num/p0Denom)#change to log()
23     return p0Vect,p1Vect,pAbusive

2.3 測試算法

分類函數：

 1 def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
 2     '''
 3     分類函數
 4     vec2Classify:要分類的向量
 5     p0Vec, p1Vec, pClass1:分別對應trainNB0計算得到的3個概率
 6     '''
 7     p1 = sum(vec2Classify * p1Vec) + log(pClass1)
 8     p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
 9     if p1 > p0:
10         return 1
11     else: 
12         return 0

測試：

 1 def testingNB():
 2     listOPosts,listClasses = loadDataSet()
 3     myVocabList = createVocabList(listOPosts)
 4     trainMat=[]
 5     for postinDoc in listOPosts:
 6         trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
 7     #訓練模型，注意此處使用array
 8     p0V,p1V,pAb = trainNB0(array(trainMat),array(listClasses))
 9     testEntry = ['love', 'my', 'dalmation']
10     thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
11     print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
12     testEntry = ['stupid', 'garbage']
13     thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
14     print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))

3、實例：使用朴素貝葉斯過濾垃圾郵件

一般流程：

3.1 切分文本

將長字符串切分成詞表，包括將大寫字符轉換成小寫，並過濾字符長度小於3的字符。

1 def textParse(bigString):#
2     '''
3     文本切分
4     輸入文本字符串，輸出詞表
5     '''
6     import re
7     listOfTokens = re.split(r'\W*', bigString)
8     return [tok.lower() for tok in listOfTokens if len(tok) > 2] 
9

3.2 使用朴素貝葉斯進行垃圾郵件分類

 1 def spamTest():
 2     '''
 3     垃圾郵件測試函數
 4     '''
 5     docList=[]; classList = []; fullText =[]
 6     for i in range(1,26):
 7         #讀取垃圾郵件
 8         wordList = textParse(open('email/spam/%d.txt' % i,'r',encoding= 'utf-8').read())
 9         docList.append(wordList)
10         fullText.extend(wordList)
11         #設置垃圾郵件類標簽為1
12         classList.append(1)        
13         wordList = textParse(open('email/ham/%d.txt' % i,'r',encoding= 'utf-8').read())
14         docList.append(wordList)
15         fullText.extend(wordList)
16         classList.append(0)
17     vocabList = createVocabList(docList)#生成次表庫
18     trainingSet = list(range(50))
19     testSet=[]           #
20     #隨機選10組做測試集
21     for i in range(10):
22         randIndex = int(random.uniform(0,len(trainingSet)))
23         testSet.append(trainingSet[randIndex])
24         del(trainingSet[randIndex])  
25     trainMat=[]; trainClasses = []
26     for docIndex in trainingSet:#生成訓練矩陣及標簽
27         trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
28         trainClasses.append(classList[docIndex])
29     p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
30     errorCount = 0
31     #測試並計算錯誤率
32     for docIndex in testSet:
33         wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
34         if classifyNB(array(wordVector),p0V,p1V,pSpam) != classList[docIndex]:
35             errorCount += 1
36             print("classification error",docList[docIndex])
37     print('the error rate is: ',float(errorCount)/len(testSet))
38     #return vocabList,fullText

4、實例：使用朴素貝葉斯分類器從個人廣告中獲取區域傾向

一般流程：

在這個中，我們將分別從美國的兩個城市中選取一些人，通過分析這些人發布的征婚廣告信息，來比較這兩個城市的人們在廣告用詞上是否不同。

4.1 實現代碼

 1 '''
 2 函數localWords()與程序清單中的spamTest()函數幾乎相同，區別在於這里訪問的是
 3 RSS源而不是文件。然后調用函數calcMostFreq()來獲得排序最高的30個單詞並隨后將它們移除
 4 '''
 5 def localWords(feed1,feed0):
 6     import feedparser
 7     docList=[]; classList = []; fullText =[]
 8     minLen = min(len(feed1['entries']),len(feed0['entries']))
 9     for i in range(minLen):
10         wordList = textParse(feed1['entries'][i]['summary'])
11         docList.append(wordList)
12         fullText.extend(wordList)
13         classList.append(1) #NY is class 1
14         wordList = textParse(feed0['entries'][i]['summary'])
15         docList.append(wordList)
16         fullText.extend(wordList)
17         classList.append(0)
18     vocabList = createVocabList(docList)#create vocabulary
19     top30Words = calcMostFreq(vocabList,fullText)   #remove top 30 words
20     for pairW in top30Words:
21         if pairW[0] in vocabList: vocabList.remove(pairW[0])
22     trainingSet = list(range(2*minLen)); testSet=[]           #create test set
23     for i in range(10):
24         randIndex = int(random.uniform(0,len(trainingSet)))
25         testSet.append(trainingSet[randIndex])
26         del(trainingSet[randIndex])  
27     trainMat=[]; trainClasses = []
28     for docIndex in trainingSet:#train the classifier (get probs) trainNB0
29         trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
30         trainClasses.append(classList[docIndex])
31     p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
32     errorCount = 0
33     for docIndex in testSet:        #classify the remaining items
34         wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
35         if classifyNB(array(wordVector),p0V,p1V,pSpam) != classList[docIndex]:
36             errorCount += 1
37     print('the error rate is: ',float(errorCount)/len(testSet))
38     return vocabList,p0V,p1V
39 
40 def calcMostFreq(vocabList,fullText):
41     '''
42     返回前30個高頻詞
43     '''
44     import operator
45     freqDict = {}
46     for token in vocabList:
47         freqDict[token]=fullText.count(token)
48     sortedFreq = sorted(freqDict.items(), key=operator.itemgetter(1), reverse=True) 
49     return sortedFreq[:30]
50 
51 if __name__== "__main__":  
52     #導入RSS數據源
53     import operator
54     ny=feedparser.parse('http://newyork.craigslist.org/stp/index.rss')
55     sf=feedparser.parse('http://sfbay.craigslist.org/stp/index.rss')
56     localWords(ny,sf)

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Python機器學習筆記：朴素貝葉斯算法機器學習-朴素貝葉斯機器學習算法及實戰——朴素貝葉斯代碼實現 [python機器學習及實踐(2)]Sklearn實現朴素貝葉斯【機器學習】朴素貝葉斯應用實例機器學習—朴素貝葉斯及其優化 5.機器學習之朴素貝葉斯詳解機器學習算法總結(十)——朴素貝葉斯機器學習基礎——帶你實戰朴素貝葉斯模型文本分類【機器學習筆記之八】使用朴素貝葉斯進行文本的分類