本文主要介紹一下內容：1貝葉斯，2 樸素貝葉斯的推導，3 最大似然估計的推到過程，4樸素貝葉斯的計算步驟 ，5 貝葉斯估計

1 貝葉斯

 假設有兩類資料p1(x,y)表示（x,y）屬於類別1，用p2(x,y)表示（x,y）屬於類別2，那麼對於一個新的資料集（x,y），可以根據一下規則來判斷他的類別

1.如果p1(x,y)>p2(x,y)，則（x,y）屬於類別1

2.如果p2(x,y)>p1(x,y)，則（x,y）屬於類別2

也就是說，我們會選擇具有最高概率的決策，這就是貝葉斯決策理論的核心思想通常，事件A在事件B(發生)的條件下的概率，與事件B在事件A的條件下的概率是不一樣的；然而，這兩者是有確定的關係,貝葉斯法則就是這種關係的陳述。作為一個規範的原理，貝葉斯法則對於所有概率的解釋是有效的；然而，頻率主義者和貝葉斯主義者對於在應用中概率如何被賦值有著不同的看法：頻率主義者根據隨機事件發生的頻率，或者總體樣本里面的個數來賦值概率；貝葉斯主義者要根據未知的命題來賦值概率。一個結果就是，貝葉斯主義者有更多的機會使用貝葉斯法則。

2樸素貝葉斯

樸素貝葉斯是基於貝葉斯定理與特徵條件獨立假設的分類

3 最大似然估計推到

4 樸素貝葉斯演算法計算步驟

5 貝葉斯估計

用極大似然估計可能會出現所要估計的概率值為0的情況，這時會影響到後驗概率的影響結果，使分類產生誤差解決這一問題的方法是採用貝葉斯估計

等價於在隨機變數各個取值的頻數上賦予一個正數，值為0時為極大似然估計，值為1是為拉普拉斯平滑至此樸素貝葉斯的基本原理均介紹完成，後續會增加樸素貝葉斯的python實現

6 python實現

以下程式碼參照機器學習實戰第四章，

from numpy import *

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']]
    classVec = [0,1,0,1,0,1]    #1 is abusive, 0 not
    return postingList,classVec
       
 #建立一個包含在所有文件中出現的不重複的列表 |用於求兩個集合並集，詞集
def createVocabList(dataSet):
    vocabSet = set([])  #create empty set
    for document in dataSet:
        vocabSet = vocabSet | set(document) #union of the two sets
    return list(vocabSet)#生成一個包含所有單詞的列表
    
#數輸引數是文件，輸出引數是變數，vocabSet包含所有不重複的詞,把句子轉成詞向量，，詞集模型
def setOfWords2Vec(vocabList, inputSet):
    returnVec = [0]*len(vocabList)#生成一個列表長度為單詞長度，每個元素均為0
    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  #生成詞集向量

#原始的計算需要多項相乘，這樣如果其中一項為0 ，則影響整體，因此初始化資料分子為1分母為2
#令一種情況為下溢位問題，即一些很小的資料相乘四捨五入會得到0結果，因此一種處理方法為取對數
#def trainNB0(postingList,trainCategory):
#    trainMatrix=[]
#    for p in postingList:
#        trainMatrix.append(setOfWords2Vec(myVocablist, p))
#    print trainMatrix[2]
#    numTrainDocs = len(trainMatrix)#取行6
#    numWords = len(trainMatrix[0])#取列32
#    pAbusive = sum(trainCategory)/float(numTrainDocs)#出現侮辱性文件的概率，包含侮辱性句子/所有句子
#    p0Num = zeros(numWords)#生成一個包含單詞個數的列表，值均為0
#    p1Num = zeros(numWords)  #生成一個包含單詞個數的列表，值均為0    #change to ones() 
#    p0Denom = 0.0
#    p1Denom = 0.0                      #change to 2.0
#    for i in range(numTrainDocs):
#        if trainCategory[i] == 1:#類別為1
#            p1Num += trainMatrix[i]#各變數均增加1
#            p1Denom += sum(trainMatrix[i])#每次變數中發生的次數
#        else:
#            p0Num += trainMatrix[i]
#            p0Denom += sum(trainMatrix[i])
#    p1Vect = p1Num/p1Denom        #change to log()
#    p0Vect = p0Num/p0Denom         #change to log()
#    return p0Vect,p1Vect,pAbusive
#    


#詞袋模型，每個詞可以多次出現   
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

#改進演算法
def trainNB0(trainMatrix,trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory)/float(numTrainDocs) #計算先驗概率
    p0Num = ones(numWords); p1Num = ones(numWords)      #change to ones() 
    p0Denom = 2.0; p1Denom = 2.0  #避免其中一項為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 = log(p1Num/p1Denom)     #避免下溢位問題     #change to log()
    p0Vect = log(p0Num/p0Denom)          #change to log()
    return p0Vect,p1Vect,pAbusive
    
#計算屬於類別1和類別0的概率，把資料進行分類
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)  #測試結果

#文字解析，把大寫轉小寫，且去掉長度小於2的字元
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:#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
    
if  __name__=='__main__':
      spamTest()