樸素貝葉斯——文本分類

1.1、貝葉斯定理

        貝葉斯定理是關於隨機事件A和B的條件概率的一則定理。

其中P(A|B)是在B發生的情況下A發生的可能性。

在貝葉斯定理中，每個名詞都有約定俗成的名稱：

• P(A|B)是已知B發生後A的條件概率，也由於得自B的取值而被稱作A的後驗概率。
• P(B|A)是已知A發生後B的條件概率，也由於得自A的取值而被稱作B的後驗概率。
• P(A)是A的先驗概率或（或邊緣概率）。之所以稱爲"先驗"是因爲它不考慮任何B方面的因素。
• P(B)是B的先驗概率或邊緣概率。

按這些術語，貝葉斯定理可表述爲：後驗概率 = (相似度*先驗概率)/標準化常量。也就是說，後驗概率與先驗概率和相似度的

乘積成正比。另外，比例P(B|A)/P(B)也有時被稱作標準相似度（standardised likelihood），貝葉斯定理可表述爲：

後驗概率 = 標準相似度*先驗概率

1.2、分類問題

分類是指識別出樣本所屬的類別。識別前是否需要進行訓練，可分爲有監督分類和無監督分類。有監督分類(supervised classification):

根據已知訓練區提供的樣本，通過計算選擇特徵參數，建立判別函數以對樣本進行的分類。無監督分類(unsupervised classification):指人們

事先對分類過程不施加任何的先驗知識，而僅憑數據，即自然聚類的特性，進行“盲目”的分類；其分類的結果只是對不同類別達到了區分，但

並不能確定類別的屬性。

1.3、樸素貝葉斯分類器

分類是把一個事物分到某個類別中。一個事物具有很多屬性，把它的衆多屬性看作一個向量，即x=(x1,x2,x3,…,xn)，用x這個向量

來代表這個事物，x的集合記爲X，稱爲屬性集。類別也有很多種，用集合C={c1,c2,…cm}表示。一般X和C的關係是不確定的，可以將

X和C看作是隨機變量，P(C|X)稱爲C的後驗概率，與之相對的，P(C)稱爲C的先驗概率。

根據貝葉斯公式，後驗概率P(C|X)=P(X|C)P(C)/P(X)，但在比較不同C值的後驗概率時，分母P(X)總是常數，忽略掉，後驗概率

P(C|X)=P(X|C)P(C)，先驗概率P(C)可以通過計算訓練集中屬於每一個類的訓練樣本所佔的比例，容易估計，對類條件概率P(X|C)的估

計，這裏我只說樸素貝葉斯分類器方法，因爲樸素貝葉斯假設事物屬性之間相互條件獨立，P(X|C)=∏P(xi|ci)。

2.1、使用樸素貝葉斯進行文檔分類

        機器學習的一個重要過程就是文檔的自動分類。在文檔分類中，整個文檔（如一封電子郵件）是實例，而電子郵件中的某些元

素構成特徵。雖然電子郵件是一種不會增加的文本，但同樣也可以對新聞報導、用戶留言等其他任意文本進行分類。觀察文檔中出

現的詞，並把每個詞的出現作爲一個特徵，這樣得到的特徵數目就會跟詞彙表中的詞一樣多。

        樸素貝葉斯的一般過程：

1. 收集數據：可以用任何方法
2. 準備數據
3. 分析數據：有大量特徵時，繪製特徵作用不大，此時用直方圖效果更好。
4. 訓練算法：計算不同的獨立特徵的條件概率。
5. 測試算法：計算錯誤率。
6. 使用算法：一個常見的樸素貝葉斯應用是文檔分類。可以在任意的分類場景中使用樸素貝葉斯分類器，不一定是文本。

        兩個假設：

        1、特徵之間相互獨立，即一個特徵或單詞的出現的可能性和它與其他單詞相鄰沒有關係。例如 am 出現在第一人稱I 和第三人

人稱單詞He之後的概率沒有關係。顯然根據正常的語法規則，am 在 I 之後的概率肯定比 He高。所以稱之爲 naive

    

            2、每個特徵同等重要。

2.2、程序分析：

2.2.1、首先，將文本轉化成單詞表，第二個函數返回一個向量，矩陣元素初始全爲0，當詞彙表vocabuList 中詞彙出現在inputSet

中時，將對應位置的向量元素改爲1.

def createVocabList(dataSet):
    vocabSet = set([])  #create empty set
    for document in dataSet:
        vocabSet = vocabSet | set(document) #union of the two sets
    return list(vocabSet)

def setOfWords2Vec(vocabList, inputSet):
    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

2.2.2、訓練算法

首先是概率的計算，p(Ci|w)=p(w|Ci)*p(Ci)/p(w)

             其中，w是一個向量，表示一個詞彙表，p(Ci)表示爲第i類文檔的概率，本文中i取值爲0、1，分別表示正常郵件和垃圾郵件,這

個概率可以由統計方法得到。即第i類文檔的數量與文檔總數的比值。如何計算p(w|Ci)呢，正如之前的假設，w的各個特徵相互獨立

也就是說，p(w|Ci)=p(w1|Ci)p(w2|Ci)...p(wN|Ci)，其中Wn是向量w的分量。如此：

def trainNB0(trainMatrix,trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    p0Num = zeros(numWords); p1Num = zeros(numWords)
    #p0Num = ones(numWords); p1Num = ones(numWords)      #change to ones() 
    p0Denom = 0.0; p1Denom = 0.0
    #p0Denom = 2.0; p1Denom = 2.0                        #change to 2.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
    '''
    p1Vect = log(p1Num/p1Denom)          #change to log()
    p0Vect = log(p0Num/p0Denom)          #change to log()
    '''

    return p0Vect,p1Vect,pAbusive

2.2.3、請看代碼註釋

#根據p1與p0概率的大小關係將文本分類

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1): 
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)    #element-wise mult
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else: 
        return 0
 

# 將分類器改爲詞袋模型，即單詞表中出現該詞，則將對應向量元素數值+1。   
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

#一個測試函數，可以修改測試詞組

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)

#切分郵件文本，使用正則表達式，去掉符合、數字，替換大寫字母爲小寫，將文本處理爲一個單詞表。

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] 

#交叉驗證，將兩個文件夾中的50條文本全部讀入並處理爲單詞表，隨機選擇10條文本，剩下40條作爲測試集    
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)#create vocabulary
    trainingSet = range(50); testSet=[]           #create test set
    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:#train the classifier (get probs) trainNB0
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
    errorCount = 0
    for docIndex in testSet:        #classify the remaining items
        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)
    #return vocabList,fullText