python 貝葉斯算法

自我理解貝葉斯算法也就是通過概率來判斷C是屬於A類還是B類，下面是具體代碼（python3.5 測試通過）

文字流程解釋一波

　　1 ）  加載訓練數據和訓練數據對應的類別

　　2）   生成詞匯集，就是所有訓練數據的並集

　　3）   生成訓練數據的向量集，也就是只包含0和1的向量集

　　4）   計算訓練數據的各個概率

　　5）   加載測試數據

　　6）   生成測試數據的向量集

　　7）   測試數據向量 * 訓練數據的概率 最后求和

　　8）   得出測試數據的所屬類別

具體代碼實現

代碼實現1

from numpy import *
#貝葉斯算法

def loadDataSet():
    trainData=[['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']]
    labels=[0, 1, 0, 1, 0, 1] #1表示侮辱性言論，0表示正常言論
    return trainData, labels

#生成詞匯表
def createVocabList(trainData):
    VocabList = set([])
    for item in trainData:
        VocabList = VocabList|set(item) #取兩個集合的並集
    return sorted(list(VocabList))    #對結果排序后返回

#對訓練數據生成只包含0和1的向量集
def createWordSet(VocabList, trainData):
    VocabList_len = len(VocabList)   #詞匯集的長度
    trainData_len = len(trainData)   #訓練數據的長度
    WordSet = zeros((trainData_len,VocabList_len))     #生成行長度為訓練數據的長度 列長度為詞匯集的長度的列表
    for index in range(0,trainData_len):
        for word in trainData[index]:
            if word in VocabList:     #其實也就是，訓練數據包含的單詞對應的位置為1其他為0
                WordSet[index][VocabList.index(word)] = 1
    return WordSet

#計算向量集每個的概率
def opreationProbability(WordSet, labels):
       WordSet_col = len(WordSet[0])
       labels_len = len(labels)
       WordSet_labels_0 = zeros(WordSet_col)
       WordSet_labels_1 = zeros(WordSet_col)
       num_labels_0 = 0
       num_labels_1 = 0
       for index in range(0,labels_len):
           if labels[index] == 0:
               WordSet_labels_0 += WordSet[index]       #向量相加
               num_labels_0 += 1                        #計數
           else:
               WordSet_labels_1 += WordSet[index]       #向量相加
               num_labels_1 += 1                        #計數
       p0 = WordSet_labels_0 * num_labels_0 / labels_len
       p1 = WordSet_labels_1 * num_labels_1 / labels_len
       return p0, p1


trainData, labels = loadDataSet()
VocabList = createVocabList(trainData)
train_WordSet = createWordSet(VocabList,trainData)
p0, p1 = opreationProbability(train_WordSet, labels)
#到此就算是訓練完成
#開始測試
testData = [['not', 'take', 'ate', 'my', 'stupid']]     #測試數據

test_WordSet = createWordSet(VocabList, testData)      #測試數據的向量集
res_test_0 = []
res_test_1 = []

for index in range(0,len(p0)):
    print(p0[index])
    if test_WordSet[0][index] == 0:
        res_test_0.append((1-p0[index]) * test_WordSet[0][index])
        res_test_1.append((1-p1[index]) * test_WordSet[0][index])
    else:
        res_test_0.append(p0[index] * test_WordSet[0][index])
        res_test_1.append(p1[index] * test_WordSet[0][index])

if sum(res_test_0) > sum(res_test_1):
    print("屬於0類別")
else:
    print("屬於1類別")

 

代碼實現2

from numpy import *
#貝葉斯算法

def loadDataSet():
    trainData=[['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']]
    labels=[0, 1, 0, 1, 0, 1] #1表示侮辱性言論，0表示正常言論
    return trainData, labels

#生成詞匯表
def createVocabList(trainData):
    VocabList = set([])
    for item in trainData:
        VocabList = VocabList|set(item) #取兩個集合的並集
    return sorted(list(VocabList))    #對結果排序后返回

#對訓練數據生成只包含0和1的向量集
def createWordSet(VocabList, trainData):
    VocabList_len = len(VocabList)   #詞匯集的長度
    trainData_len = len(trainData)   #訓練數據的長度
    WordSet = zeros((trainData_len,VocabList_len))     #生成行長度為訓練數據的長度 列長度為詞匯集的長度的列表
    for index in range(0,trainData_len):
        for word in trainData[index]:
            if word in VocabList:     #其實也就是，訓練數據包含的單詞對應的位置為1其他為0
                WordSet[index][VocabList.index(word)] = 1
    return WordSet

#計算向量集每個的概率
def opreationProbability(WordSet, labels):
       WordSet_col = len(WordSet[0])
       labels_len = len(labels)
       WordSet_labels_0 = zeros(WordSet_col)
       WordSet_labels_1 = zeros(WordSet_col)
       num_labels_0 = 0
       num_labels_1 = 0
       for index in range(0,labels_len):
           if labels[index] == 0:
               WordSet_labels_0 += WordSet[index]       #向量相加
               num_labels_0 += 1                        #計數
           else:
               WordSet_labels_1 += WordSet[index]       #向量相加
               num_labels_1 += 1                        #計數
       p0 = WordSet_labels_0 * num_labels_0 / labels_len
       p1 = WordSet_labels_1 * num_labels_1 / labels_len
       return p0, p1


trainData, labels = loadDataSet()
VocabList = createVocabList(trainData)
train_WordSet = createWordSet(VocabList,trainData)
p0, p1 = opreationProbability(train_WordSet, labels)
#到此就算是訓練完成
#開始測試
testData = [['not', 'take', 'ate', 'my', 'stupid']]     #測試數據

test_WordSet = createWordSet(VocabList, testData)      #測試數據的向量集

res_test_0 = sum(p0 * test_WordSet)
res_test_1 = sum(p1 * test_WordSet)

if res_test_0 > res_test_1:
    print("屬於0類別")
else:
    print("屬於1類別")

鄭重聲明下：

　　第二種算法是我瞎想的，我感覺這樣算也可以，可能對於當前的這種情況可以，其他情況就不一定了。兩種算法前半部分都一樣，只是最后的時候，方法1計算測試數據每個數出現的概率，方法2直接計算測試數據每個數發生的概率

　　可能我解釋的理解的也不是很到位，歡迎加Q交流 1156553820

 

部分參見大神的博文

　　鏈接　　https://blog.csdn.net/moxigandashu/article/details/71480251