第四章 朴素贝叶斯 （一）

过滤侮辱性词汇

import numpy as np
from functools import reduce

'''
(1)函数说明：创建实验样本
   返回值：postingList：实验样本切分的词条
          classVec：类别标签向量。存每个词条的类别
'''
def loadDataSet():
    #切分的词条（共6个词条）
    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']]
    #对postingList中的6个词条进行分类（1：侮辱性的词条、0：非侮辱性词条）
    classVec = [0,1,0,1,0,1]
    #返回词条、对词条的分类
    return postingList,classVec
# if __name__ == '__main__':
#     postingList,classVec = loadDataSet()
#     for each in postingList:
#         print(each)
#     print(classVec)

'''
(2)函数说明：将样本(即（1）中创建的postingList)中的词条整理成不重复的词条列表（即重复的单词只保留一个），也就是词汇表
   参数：dataSet:词条样本集
   返回值：返回不重复的词条列表，即词汇表
'''
def createVocabList(dataSet):
    # 创建一个空的不重复列表
    vocabSet =set([])
    #遍历所有的词条，将每一个词条中的单词存入vocabSet中
    for document in dataSet:
        #set(document),取词条document中的单词（重复的单词只取一个）
        vocabSet = vocabSet | set(document)
    #返回词汇表
    return list(vocabSet)


'''
（3）函数说明：根据vocabList词汇表，将词条inputSet（一个词条）向量化。向量的每个元素为1或0。
                向量的初始值都为0，若词条中的单词出现在词汇表中，将其元素设置为1
     参数说明：vocabList 词汇表
              inputSet 一个词条
     返回值：文档向量。（向量化后的词条列表）
'''
def setOfWords2Vec(vocabList,inputSet):
    #创建一个所含元素都为0的向量(和词汇表等长)，用来存放向量化后的词条列表
    returnVec = [0]*len(vocabList)
    #遍历词条inputSet，将该词条向量化
    for word in inputSet:
        if word in vocabList:
            #若单词word在词汇表vocabList中，将其设置为1
            returnVec[vocabList.index(word)]=1
        else:
            print("%s不存在单词表中" % word)
    #返回文档向量
    return returnVec
# if __name__ == '__main__':
#     #获取所有词条样本 及其 分类
#     postingList, classVec = loadDataSet()
#     print("postingList:\n",postingList)
#     #获取词汇表（词条postingList中的单词）
#     vocabList = createVocabList(postingList)
#     print("vocabList:\n",vocabList)
#     #将postingList向量化,结果存放在trainMat
#     trainMat = []
#     #依次遍历词条样本中的每一个词条
#     for postinDoc in postingList:
#         #将一个词条postinDoc向量化（该向量大小与词汇表一致）
#         trainMat.append(setOfWords2Vec(vocabList,postinDoc))
#     print("trainMat:\n",trainMat)

'''
（4）函数说明：使用朴素贝叶斯分类器训练函数
     参数：trainMatix 训练的文档矩阵 即setOfWords2Vec中返回的向量矩阵（词条列表向量化）(6个向量)
           trainCategory 训练类别标签向量 即loadDataSet返回的classVec （对6个向量的分类）
     返回值：p0Vect 词汇表中每个单词是非侮辱类的条件概率（数组）。即 P（某单词|非侮辱类）
             p1Vect 侮辱类的条件概率（数组）
             pAbusive 文档属于侮辱类的概率
'''
def trainNB0(trainMatiix,trainCategory):
    #获取词条集中词条的个数(6条)
    numTrainDocs = len(trainMatiix)
    #获取词条向量中，一个向量的大小（和词汇表的大小一致）
    numWords = len(trainMatiix[0])
    #计算整个词条集属于侮辱类的概率（6个词条中，侮辱类词条所占的概率）
      #trainCategory（对词条的分类），若是侮辱性词条，值为1；若是非侮辱性，值为0。
      #所以sum(trainCategory)：将分类结果相加，其结果即为侮辱性词条的个数
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    #存放词汇表中非侮辱类单词的数目(数组大小为numWords，初始值为1)
    p0Num = np.ones(numWords)
    #存放词汇表中侮辱类单词的数目(数组大小为numWords，初始值为1)
    p1Num = np.ones(numWords)
    #存放总的非侮辱性、侮辱性词汇数目（初始值为2.0）
    p0Denom = 2.0
    p1Denom = 2.0
    #遍历词条向量集，统计p0Num、p1Num、p0Denom、p1Denom(numTrainDocs:词条数)
    for i in range(numTrainDocs):
        #若该词条是侮辱性的
        if trainCategory[i] == 1:#为侮辱性词条
            #将侮辱性词条中每个单词出现的数目进行累加（p1Num：数组，每个单词单独计数）
            p1Num = p1Num+trainMatiix[i]
            #将侮辱性词条中所有的单词数目相加（p1Denom：数,所有单词共同计数）
            p1Denom = p1Denom+sum(trainMatiix[i])
        else: #为非侮辱性词条
            #将非侮辱性词条向量中每个单词出现的数目进行累加（p0Num：数组，每个单词单独计数）
            p0Num = p0Num+trainMatiix[i]
            #将非侮辱性词条中所有单词数目相加（p0Denom：数,所有单词共同计数）
            p0Denom = p0Denom+sum(trainMatiix[i])
    #计算各个单词是侮辱性词汇的概率(该单词出现的次数/侮辱性词条中单词的总个数:p1Num /p1Denom)
    p1Vect = np.log(p1Num /p1Denom)#取对数，防止下溢出（0.0000000000012）
    #计算各个单词是非侮辱性词汇的概率(该单词出现的次数/非侮辱性词条中单词的总个数:p0Num / p0Denom)
    p0Vect = np.log(p0Num / p0Denom)
    #返回单词属于非侮辱类的条件概率、属于侮辱类的条件概率、整个词条集属于侮辱类的概率
    return p0Vect,p1Vect,pAbusive
# if __name__ == '__main__':
#     #获取所有词条样本 及其 分类
#     postingList, classVec = loadDataSet()
#     print("postingList:\n",postingList)
#     #获取词汇表（词条postingList中的单词）
#     vocabList = createVocabList(postingList)
#     print("vocabList:\n",vocabList)
#     #将postingList向量化,结果存放在trainMat
#     trainMat = []
#     #依次遍历词条样本中的每一个词条
#     for postinDoc in postingList:
#         #将一个词条postinDoc向量化（该向量大小与词汇表一致）
#         trainMat.append(setOfWords2Vec(vocabList,postinDoc))
#     print("trainMat:\n",trainMat)
#     p0V,p1V,pAb = trainNB0(trainMat,classVec)
#     print('p0V:\n', p0V)
#     print('p1V:\n', p1V)
#     print('pAb\n', pAb)

'''
(5)函数说明：朴素贝叶斯分类器分类函数
   参数：vec2Classify 待分类的词条数组（向量）
         p0Vec 非侮辱性条件概率数组
         p1Vec1 侮辱性条件概率数组
         pClass 文档属于侮辱类文档的概率
    返回值： 0 词条是非侮辱类
             1 词条是侮辱类
'''
def classfiyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    #p（（非）侮辱类文档|词条）= p（词条& （非）侮辱类文档） / p（词条）
    #p（词条 & 侮辱类文档）= p（词条|侮辱类文档）*p（侮辱类文档）=sum（vec2Classify*p1Vec）*pClass1
    #其中sum（vec2Classify*p1Vec）:vec2Classify*p1Vec指待分类词条向量集vec2Classify中每个词条是侮辱性的概率。将所有词条是侮辱性的概率相乘
    #因分母一样，故只需计算sum（vec2Classify*p1Vec）*pClass1。（p1Vec 是log形式的。log（a*b）= loga+logb ）
    p1 = sum(vec2Classify*p1Vec)+np.log(pClass1) #计算该词条是侮辱类的概率
    p0 = sum(vec2Classify*p0Vec)+np.log(1.0-pClass1) #计算该词条是非侮辱类的概率
    if p1>p0:
        return 1
    else:
        return 0

'''
(6)函数说明：测试朴素贝叶斯分类器
'''
def testingNB():
    #创建实验样本
    listPosts,listClasses = loadDataSet()
    #创建词汇表
    vocabList = createVocabList(listPosts)
    #将词条集向量化
    trainMat = []
    for each in listPosts:
        trainMat.append(setOfWords2Vec(vocabList,each))
    #训练朴素贝叶斯分类器。获取p0V,p1V,pAb
    p0V,p1V,pAb = trainNB0(np.array(trainMat),np.array(listClasses))

    #测试样本1
    testEntry1 = ['love','my','dalmation']
    #将测试样本向量化
    thisDoc=np.array(setOfWords2Vec(vocabList,testEntry1))
    #执行分类，并打印分类结果
    if classfiyNB(thisDoc,p0V,p1V,pAb) == 1:
        print(testEntry1,'属于侮辱类')
    else:
        print(testEntry1,'属于非侮辱类')

    #测试样本2
    testEntry2 = ['stupid','garbage']
    #测试样本向量化
    thisDoc2 = np.array(setOfWords2Vec(vocabList,testEntry2))
    #执行分类，并打印结果
    if classfiyNB(thisDoc2,p0V,p1V,pAb) == 1:
        print(testEntry2,'属于侮辱类')
    else:
        print(testEntry2,'属于非侮辱类')

if __name__ == '__main__':
    testingNB()