參考網址如下，講解更詳細：

http://www.jianshu.com/p/5fd446efefe9

http://blog.csdn.net/v_victor/article/details/51319873

 樸素navie：條件獨立性

【問題的引入】

經典的貝葉斯公式

       實際問題中，能獲得的數據可能只有有限數目的樣本數據，而先驗概率P(wi)和類條件概率(各類的總體分布)P(x|wi) 都是未知的。解決：需要先對先驗概率和類條件概率進行估計，然后再套用貝葉斯分類器。

       先驗概率的估計較簡單：1、每個樣本所屬的自然狀態都是已知的（有監督學習）；2、依靠經驗；3、用訓練樣本中各類出現的頻率估計。

    類條件概率的估計（非常難），原因包括：概率密度函數包含了一個隨機變量的全部信息；樣本數據可能不多；特征向量x的維度可能很大等。要直接估計類條件概率的密度函數很難。解決的辦法：把估計完全未知的概率密度轉化為估計參數（即轉換成參數估計問題），極大似然估計就是一種參數估計方法。

       關于極大似然估計的引入和解釋可參考以下網站：

       http://blog.csdn.net/zengxiantao1994/article/details/72787849

       http://www.cnblogs.com/hbwxcw/p/6824400.html

【算法】

       給定的訓練集是標定了 侮辱性/非侮辱性 的句子（因為是英語句子，所以基本視分詞為已經解決的問題，如果是漢語，則要先進行分詞），我們認為特征就是句子中的單個詞語。單個詞語有極性表征，整個句子所包含的單詞的極性表征就是句子的極性。

由以上基礎，應用樸素貝葉斯分類。

• 初始化：構建可以表征句子的特征向量（詞匯表）。并根據這個特征向量，把訓練集表征出來。從訓練集中分離部分數據作為測試集。
• 學習：計算類的先驗概率和特征向量對應每一類的條件概率向量。
• 分類：計算測試集中待分類句子在每一類的分類后驗概率，取最大值作為其分類，并與給定標簽比較，得到誤分類率。

【代碼】# 屏蔽社區留言板的侮辱性言論

1.初始化-社區留言板文本如下：

       其中，我們對其進行負面和正面分類：0代表正類，1代表負類。

def loadDataSet():
    """
    單詞列表postingList, 所屬類別classVec 
    """
    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

2. 初始化-根據上述文本建立一個詞匯表，即把重復的詞匯剔除。

def createVocabList(dataSet):
    """
    dataSet: 數據集，return: vocabList不含重復元素的單詞列表
    """
    vocabSet = set()
    for data in dataSet:
        vocabSet |= set(data)
    return list(vocabSet)

3. 初始化-首先把留言轉化為向量，如下所示：

詞匯表: ['help', 'to', 'stupid','problem', 'garbage', 'love', 'licks', 'dog', 'stop', 'so', 'ny', 'take', 'is','food', 'worthless', 'park', 'flea', 'steak', 'has', 'dalmation', 'how','posting', 'please', 'my', 'maybe', 'buying', 'quit', 'ate', 'cute', 'mr','not', 'I', 'him']
對于文本：['my', 'dog', 'has', 'flea', 'problem', 'help','please']
轉化為向量：[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0]

def wordsToVector (vocabList, inputSet):
    """
    vocabList詞匯，inputSet: 為要轉化為向量的輸入文本 
    return: returnVec
    """
    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 the vocabList!'%word)
    return returnVec

4.先驗概率和條件概率的求解

負類的先驗概率 = 負類的數量/留言的總數量

條件概率：計算每個單詞分別在負類和正類條件下的概率

代碼中各變量含義如下：

 

輸入	trainset	已轉換為向量的輸入，內容[[0,0,1,...],[1,0]...]
	trainCategory	輸入文本所對應的類別
	num_train	訓練集數目
	num_vocab	整個vocabList的長度
構造單詞出現次數列表	避免單詞列表中的任何一個單詞為0，而導致最后的乘積為0，所以將每個單詞的出現次數初始化為 1
	pnorm_vector	正常的統計
	pabu_vector	侮辱的統計
整個數據集單詞出現總數：2	根據樣本/實際結果調整分母的值（2是避免分母為0，值可以調整）
	pnorm_denom	正常的統計
	pabu_denom	侮辱的統計
輸出	pAbusive	負類的概率 = 負類的數量/訓練集的數目
	pabu_vector	類別1下單詞出現的條件概率，即侮辱性文檔的[log(P(F1|C1)),log(P(F2|C1)) ....]列表
	pnorm_vector	類別0下單詞出現的條件概率，即正常文檔的[log(P(F1|C0)),log(P(F2|C0)) ....]列表

 

def train_bayes(trainset, trainCategory):
    """
    先驗概率和條件概率的求解
    return:
        pAbusive:負類的概率 = 負類的數量/訓練集的數目
        pabu_vector:類別1，即侮辱性文檔的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表   
        pnorm_vector:類別0，即正常文檔的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
    """
    num_train = len(trainset)
    num_vocab = len(trainset[0])
    
    pAbusive = sum(trainCategory) / num_train
    
    #求條件概率：構造單詞出現次數列表
    pnorm_vector = np.ones(num_vocab)
    pabu_vector = np.ones(num_vocab)
    #初始化整個數據集單詞出現總數2
    pnorm_denom = 2
    pabu_denom = 2
    
    for i in range(num_train):
        if trainCategory[i] == 1:
            pabu_vector += trainset[i]
            pabu_denom += sum(trainset[i])
        else:
            pnorm_vector += trainset[i]
            pnorm_denom += sum(trainset[i])
    
    pabu_vector = np.log(pabu_vector / pabu_denom)
    pnorm_vector = np.log(pnorm_vector / pnorm_denom)
    
    return pAbusive,pabu_vector,pnorm_vector

5. 分類

使用算法	# 將乘法轉換為加法	乘法：P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
		加法：P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
輸入	testVector	待測數據[0,1,1,1,1...]，即要分類的向量
	pnorm_vector	類別0下單詞出現的條件概率，即正常文檔的[log(P(F1|C0)),log(P(F2|C0)) ....]列表
	pabu_vector	類別1下單詞出現的條件概率，即侮辱性文檔的[log(P(F1|C1)),log(P(F2|C1)) ....]列表
	pabusive	類別1，侮辱性文件的出現概率
計算公式		log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
輸出	類別1/0	pabu = sum(testVector*pabu_vector) + np.log(pabusive)

 

def classify(testVector, pnorm_vector, pabu_vector, pabusive):
    """
    testVector:待測數據[0,1,1,1,1...],即要分類的向量 
    pnorm_vector:類別0,pabu_vector:類別1,pabusive:類別1，侮辱性文件的出現概率 
    return:類別1 or 0
    # 計算公式 log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
    testVector*pnorm_vector:單詞在詞匯表中的條件下，文件是good 類別的概率        
    """
    pabu = sum(testVector * pabu_vector) + np.log(pabusive)
    pnorm = sum(testVector * pnorm_vector) + np.log(1-pabusive)
    if pabu > pnorm:
        return 1
    else:
        return 0

6.測試代碼：

if __name__ == '__main__':
        # 1. 加載數據集  
    posts_List, classes_list = loadDataSet()  
        # 2. 創建單詞集合  
    vocab_List = createVocabList(posts_List)  
        # 3. 計算單詞是否出現并創建數據矩陣  
    trainset = []  
    for post in posts_List:  
            # 返回m*len(myVocabList)的矩陣， 記錄的都是0，1信息  
        trainset.append(wordsToVector(vocab_List, post))  
     	# 4. 訓練數據  
    pAbusive,pabu_vector,pnorm_vector = train_bayes(trainset,classes_list)  
        # 5. 測試數據  
    testEntry1 = ['love', 'my', 'dalmation']  
    testVector1 = wordsToVector(vocab_List, testEntry1)
    print (testEntry1, 'classified as: ', classify(testVector1, pnorm_vector, pabu_vector, pAbusive))  
    
    testEntry2 = ['stupid', 'garbage']  
    testVector2 = wordsToVector(vocab_List, testEntry2)
    print (testEntry2, 'classified as: ', classify(testVector2, pnorm_vector, pabu_vector, pAbusive)