python 贝叶斯算法

时间：2022-06-14 17:27:51

自我理解贝叶斯算法也就是通过概率来判断C是属于A类还是B类，下面是具体代码（python3.5 测试通过）

文字流程解释一波

　　1 ）  加载训练数据和训练数据对应的类别

　　2）   生成词汇集，就是所有训练数据的并集

　　3）   生成训练数据的向量集，也就是只包含0和1的向量集

　　4）   计算训练数据的各个概率

　　5）   加载测试数据

　　6）   生成测试数据的向量集

　　7）   测试数据向量 * 训练数据的概率 最后求和

　　8）   得出测试数据的所属类别

python 贝叶斯算法

具体代码实现

代码实现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类别")

python 贝叶斯算法

郑重声明下：

　　第二种算法是我瞎想的，我感觉这样算也可以，可能对于当前的这种情况可以，其他情况就不一定了。两种算法前半部分都一样，只是最后的时候，方法1计算测试数据每个数出现的概率，方法2直接计算测试数据每个数发生的概率

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

部分参见大神的博文

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

相关文章