朴素贝叶斯之文本分类

import numpy
from numpy import *
def getDataSet():
    """
    加载训练数据, postingList是所有的训练集, 每一个列表代表一条言论, 一共有8条言论 classVec代表每一条言论的类别,
     0是正常, 1是有侮辱性 返回 所有言论和类别
    :return:
    """
    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']]
    labels = [0,1,0,1,0,1]
    return postingList,labels
#
# def createVocabList(dataSet):
#     """
#     创建词汇表, 就是把这个文档中所有的单词不重复的放在一个列表里面
#     :param dataSet:  为文档言论
#     :return:     返回词汇表
#     """
#     vocabSet = set([])
#     for data in dataSet:
#         vocabSet = vocabSet | set(data)    #取两个集合的并集
#     return list(vocabSet)
#
# def vectorize(vacablist,dataSet):
#     """
#     制作词向量矩阵  #根据词条列表中的词条是否在文档中出现(出现1，未出现0)，将文档转化为词条向量
#     将每一个文档转换为词向量, 然后放入矩阵中
#     :param vocablist:  文档词汇表
#     :param dataSet:    文档数据
#     :return:
#     """
#     vectors=[]
#     print('打印词汇表',vacablist)
#     for data in dataSet:
#         vector = [0] * len(vacablist)
#         for word in data:
#             if word in vacablist:
#                 vector[vacablist.index(word)] = 1
#             else:
#                print('没有 {} 这个词'.format(word))
#         vectors.append(vector)
#     return vectors

#调用getDataSet()从数据集获取文档矩阵和文档分类标签
X,y =getDataSet()
class NaiveBayes(object):
    # x为文档词向量,y为文档分类标签
    def fit(self, x, y):
        self.x = x  # wordvecors
        self.y = y  # labels

    def createVocabList(self,text):
        """
        创建词汇表, 就是把这个文档中所有的单词不重复的放在一个列表里面
        :param dataSet:  为文档言论
        :return:     返回词汇表
        """
        vocabSet = set([])
        for data in text:
            vocabSet = vocabSet | set(data)  # 取两个集合的并集
        return list(vocabSet)

    def vectorize(self,text, wordlist):
        """
                制作词向量矩阵  #根据词条列表中的词条是否在文档中出现(出现1，未出现0)，将文档转化为词条向量
                将每一个文档转换为词向量, 然后放入矩阵中
                :param vocablist:  文档词汇表
                :param dataSet:    文档数据
                :return:
                """
        vectors = []
        print('打印词汇表', wordlist)
        for data in text:
            vector = [0] * len(wordlist)
            for word in data:
                if word in wordlist:
                    vector[wordlist.index(word)] = 1
                else:
                    print('没有 {} 这个词'.format(word))
            vectors.append(vector)
        return vectors
     #训练算法，从词向量计算概率p(w0|ci)...及p(ci)
     #@trainMatrix：由每篇文档的词条向量组成的文档矩阵
     #@trainCategory:每篇文档的类标签组成的向量
    def trainNB0(self):
        #所有文档中属于类1所占的比例p(c=1)
        pAbusive=sum(self.y)/float(len(self.x))
        #创建一个长度为词条向量等长的列表
        p0Num=zeros(len(self.x[0]));p1Num=zeros(len(self.x[0]))
        p0Denom=0.0;p1Denom=0.0
        #遍历每一篇文档的词条向量
        for i in range(len(self.x)):
            #如果该词条向量对应的标签为1
            if self.y[i]==1:
                #统计所有类别为1的词条向量中各个词条出现的次数
                p1Num+=self.x[i]
                #统计类别为1的词条向量中出现的所有词条的总数
                #即统计类1所有文档中出现单词的数目
                p1Denom+=sum(self.x[i])
            else:
                #统计所有类别为0的词条向量中各个词条出现的次数
                p0Num+=self.x[i]
                #统计类别为0的词条向量中出现的所有词条的总数
                #即统计类0所有文档中出现单词的数目
                p0Denom+=sum(self.x[i])
        #利用NumPy数组计算p(wi|c1)
        #p1Num为词向量中每个词出现的次数数组,p1Denom为1类文档总的单词数目
        p=[]
        p1Vect=(p1Num/p1Denom)  #为避免下溢出问题，后面会改为log()
        #利用NumPy数组计算p(wi|c0)
        p0Vect=(p0Num/p0Denom)  #为避免下溢出问题，后面会改为log()
        #训练返回,0类每个词的概率,1类每个词的概率,文档属于1类的概率
        p.append(p0Vect)
        p.append(p1Vect)
        p.append(pAbusive)
        return p
        # return p0Vect,p1Vect,pAbusive
    #朴素贝叶斯分类函数
    #@ waitclassify  待分类词向量
    #@ p0word  类别0中所有文档每个词出现频率p(wi|c0)
    #@ p1word 类别1中所有文档每个词出现频率p(wi|c1)
    #@ pc1     文档类型为1的概率,1类文档占总文档比例  p(c1)  pAbusive
    def predict(self,test):
        #把输入test转化为词向量
        # text=self.vectorize(test)
        p0word=self.trainNB0()[0]
        p1word=self.trainNB0()[1]
        pc1=self.trainNB0()[2]
        #根据朴素贝叶斯 分别计算待分类文档属于类1和类0的概率,并比较大小
        #属于p1的概率即p(c1|wi)=p(wi|c1)*p(c1)/p(wi)
        p1 = sum(p1word*test)+log(pc1)
        p0 = sum(p0word*test)+log(1-pc1)
        print('分类文档属于类1的概率',p1)
        print('分类文档属于类0的概率',p0)
        if p1 > p0:
            return 1
        else:
            return 0
a=NaiveBayes()
#文档中没有重复的词汇表
wordlist = a.createVocabList(X)
x=a.vectorize(X,wordlist)
a.fit(x,y)

testdoc = [['love', 'my', 'dalmation']]
testdoc1 = [['stupid', 'garbage']]
testx=a.vectorize(testdoc,wordlist)
testx1=a.vectorize(testdoc1,wordlist)

#打印分类结果
print( testdoc,'classified as 类别为:',a.predict(testx))
#打印分类结果
print( testdoc1,'classified as 类别为:',a.predict(testx1))