机器学习实战——朴素贝叶斯练习

参考：https://www.cnblogs.com/zy230530/p/6847243.html
代码段需完善

假设这里要被分类的类别有两类，类c1和类c2，那么我们需要计算概率p(c1|x,y)和p(c2|x,y)的大小并进行比较：

如果：p(c1|x,y)>p(c2|x,y),则(x,y)属于类c1

     p(c1|x,y)<p(c2|x,y),则(x,y)属于类c2

我们知道p(x,y|c)的条件概率所表示的含义为：已知类别c1条件下，取到点(x，y)的概率；那么p(c1|x,y)所要表达的含义呢？显然，我们同样可以按照条件概率的方法来对概率含义进行描述，即在给定点(x,y)的条件下，求该点属于类c1的概率值。那么这样的概率该如何计算呢？显然，我们可以利用贝叶斯准则来进行变换计算：
　　p(ci|x,y)=p(x,y|ci)*p(ci)/p(x,y)

利用上面的公式，我们可以计算出在给定实例点的情况下，分类计算其属于各个类别的概率，然后比较概率值，选择具有最大概率的那么类作为点(x,y)的预测分类结果。

以上我们知道了通过贝叶斯准则来计算属于各个分类的概率值，那么具体而言，就是计算贝叶斯公式中的三个概率，只要得到了这三个概率值，显然我们就能通过贝叶斯算法预测分类的结果了。因此，到了这里，我们就知道了朴树贝叶斯算法的核心所在了。

#-*- coding: UTF-8 -*-
from math import log
import operator
from numpy import *
'''
函数说明：创建实验样本

return:
    postingList--实验样本切分的词条
    classVec--类标签向量

date:
    2018-8-25

'''

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]                                                                   #类标签向量

        return postingList,classVec



'''
将实验样本词条整理成不重复的词条列表，即词汇表
dataSet--实验样本
vocabSet--返回不重复的词条列表
'''

def creatVocabList(dataSet):
    vocabSet = set([])                                                      #创建一个空的集合
    for document in dataSet:
        vocabSet = vocabSet | set(document)                                 #将dataSet中产生的新词集合到vocabSet中
    return list(vocabSet)


'''
根据vocabList词汇表，将inputSet向量化，向量的元素为1或0
vocabList--creatVocabList返回的列表
inputSet--输入文档
0/1表示vocabList中是否出现inpoutSet的文档

'''
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 !" % word)
    return returnVec


'''
Bayes分类器训练函数
trainMatrix--训练文档矩阵，即setOfWord2Vec函数返回的矩阵
trainCategory--训练类别标签向量，即loadDataSet返回的classVec
'''

def trainNB0(trainMatrix,trainCategory):
    numTrainDocs = len(trainMatrix)                                         #获取训练矩阵中文档的数目
    numWords = len(trainMatrix[0])                                          #j计算每篇文档的词条数
    pAbusive = sum(trainCategory)/float(numTrainDocs)                       #计算文档中属于1类的概率
    p0Num = ones(numWords);p1Num=ones(numWords)                           #每篇文档词条出现次数初始化为1(避免朴素贝叶斯中出现某项为0的情况)
    p0Denom = 2.0; p1Denom = 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)
        p0Vect = log(p0Num / p0Denom)
        return p0Vect,p1Vect,pAbusive


'''
朴素贝叶斯分类函数
    vec2Classify--待分类的词条向量
    p0Vect
    p1Vect
    pAbusive

'''
def classfyNB(vec2Classify,p0Vect,p1Vect,pAbusive):
    p1 = sum(vec2Classify * p1Vect) + log(pAbusive)
    p0 = sum(vec2Classify * p0Vect) + log(1-pAbusive)
    if p1 > p0:
        return 1
    else:
        return 0

'''
测试函数
'''
def testingNB():
    postingList, classVec = loadDataSet()                                                   #创建样本
    vocabList = creatVocabList(postingList)                                                 #创建词汇表
    trainMatrix = []
    for postinDoc in postingList:
        trainMatrix.append(setOfWords2Vec(vocabList,postinDoc))                             #向量化实验样本

    p0Vect, p1Vect, pAbusive = trainNB0(np.array(trainMatrix),np.array(classVec))           #训练样本分类器

    vec2Classify = ['love']                                                                #测试样本
    thisDoc = np.array(setOfWords2Vec(vocabList,vec2Classify))                              #测试样本转化为向量形式
    if classfyNB(thisDoc,p0Vect,p1Vect,pAbusive):                                           #利用分类器分类
        print(vec2Classify,"属于侮辱类")

    else:
        print(vec2Classify,"不属于侮辱类")



import numpy as np

if __name__ == '__main__':
    # postingList,classVec = loadDataSet()                                #注释部分多为代码编写过程中测试输出部分  
    # # for each in postingList:
    # #     print(each)
    # # print(classVec)
    #
    # vocabList = creatVocabList(postingList)
    # # print(vocabList)
    # # print(postingList[0])
    # # print(vocabList)
    # # returnvec = setOfWords2Vec(vocabList,postingList[0])
    # # print(returnvec)
    # trainMatrix = []
    # for postinDoc in postingList:
    #     trainMatrix.append(setOfWords2Vec(vocabList,postinDoc))
    # p0Vect,p1Vect,pAbusive=trainNB0(trainMatrix,classVec)
    # print('p0Vect:\n', p0Vect)
    # print('p1Vect:\n', p1Vect)
    # print('classVec:\n', classVec)
    # print('pAbusive:\n', pAbusive)
    #
    # # print(trainMatrix[0])
    # # print(sum(trainMatrix[0]))
    # # print(vocabList)
    # # print(len(vocabList))
    # # print(trainMatrix)
    # # print(len(trainMatrix[0]))
    #
    # # print('postinDoc:\n',postinDoc)
    # # print('postingList:\n',postingList)
    # # print('vocabList:\n',vocabList)
    # # print('trainMat:\n',trainMatrix)

    testingNB()