郑捷《机器学习算法原理与编程实践》学习笔记（第二章中文文本分类—朴素贝叶斯算法）

def loadDataSet():
    postingList =[[‘my‘,‘dog‘,‘has‘,‘flea‘,‘problem‘,‘help‘,‘please‘],
                  [‘maybe‘,‘not‘,‘take‘,‘him‘,‘to‘,‘dog‘,‘park‘,‘stupid‘],
                  [‘my‘,‘dalmation‘,‘is‘,‘so‘,‘cute‘,‘I‘,‘love‘,‘him‘,‘my‘],
                  [‘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] #1 is abusive,0 not
    return postingList,classVec

class NBayes(object)：
    def __init__(self):
        self.vocabulary = []        #词典
        self.idf        = 0         #词典的IDF权值向量
        self.tf         = 0         #训练值的权值矩阵
        self.tdm        = 0         #P(x|yi)
        self.Pcates     = {}        #P(yi)是一个类别字典
        self.labels     = []        #对应每个文本的分类，是一个外部导入的列表
        self.doclength  = 0         #训练集文本数
        self.vocablen   = 0         #词典词长
        self.testset    = 0         #测试集

def train_set(self,trainset,classVec):
    self.cate_prob(classVec)       #计算每个分类在数据集中的概率P(yi)
    self.doclength       = len(trainset)
    tempset              = set()
    [tempset.add(word) for doc in trainset for word in doc]  #生成词典
    self.vocabulary      = list(tempset)
    self.vocablen        = len(self.vocabulary)
　　 self.calc_wordfreq(trainset)

　　 self.build_tdm() #按分类累计向量空间的每维值P(x|yi)

def cate_prob(self,classVec):
    self.labels          = classVec
    labeltemps           = set(self.labels)                   #获取全部分类
    for labeltemp in labeltemps:
        #统计列表中重复的分类：  self.labels.count(labeltemp)
        self.Pcates[labeltemp] = float(self.labels.count(labeltemp))/float(len(self.labels))

def calc_wordfreq(self,trainset):
    self.idf             = np.zeros([1,self.vocablen])        #1*词典数
    self.tf              = np.zeros([self.doclength,self.vocablen]) #训练集文件数*词典数
    for indx in xrange(self.doclength):                      #遍历所有的文本
        for word in trainset[indx]:                          #遍历文本中的每个词
            #找到文本的词在字典中的位置+1
            self.tf[indx,self.vocabulary.index(word)] += 1
        for signleword in set(trainset[indx]):               #idf词数
            self.idf[0,self.vocabulary.index(signleword)] += 1

    def build_tdm(self):
        self.tdm = np.zeros([len(self.Pcates),self.vocablen])     #类别行*词典列
        sumlist  = np.zeros([len(self.Pcates),1])                #统计每个分类的总值
        for indx in xrange(self.doclength):
            #将同一类别的词向量空间值加总
            self.tdm[self.labels[indx]] += self.tf[indx]
            #统计每个分类的总值--是一个标量
            sumlist[self.labels[indx]]    = np.sum(self.tdm[self.labels[indx]])
        self.tdm = self.tdm/sumlist                              #生成P(x|yi)

   # （6）map2vocab函数：将测试集映射到当前词典
    def map2vocab(self,testdata):
        self.testset = np.zeros([1,self.vocablen])
        for word in testdata:
            self.testset[0,self.vocabulary.index(word)] += 1

 def predict(self,testset):
        if np.shape(testset)[1] != self.vocablen: #如果测试集长度与词典不相等，则退出程序
            print "输入错误"
            exit(0)
        predvalue = 0                             #初始化类别概率
        predclass = ""                            #初始化类别名称
        for tdm_vect,keyclass in zip(self.tdm,self.Pcates):
            #P(x|yi)*P(yi)
            #变量tdm，计算最大分类值
            temp = np.sum(testset*tdm_vect*self.Pcates[keyclass])
            if temp > predvalue:
                predvalue = temp
                predclass = keyclass
        return predclass

#生成tf-idf
def calc_tfidf(self,trainset):
    self.idf = no.zeros([1,self.vocablen])
    self.tf  = np.zeros([self.doclength,self.vocablen])
    for indx in xrange(self.doclength):
        for word in trainset[indx]:
            self.tf[indx,self.vocabulary.index(word)] += 1
        #消除不同句长导致的偏差
        self.tf[indx] = self.tf[indx]/float(len(trainset[indx]))
        for signleword in set(trainset[indx]):
            self.idf[0,self.vocabulary.index(signleword)] += 1
    self.idf = np.log(float(self.doclength)/self.idf)
    self.tf  = np.multiply(self.tf,self.idf)    #矩阵与向量的点乘 TF*IDF

#coding:utf-8
import sys
import os
from numpy import *
import numpy as np
from Nbayes_lib import *
#评估分类结果

dataSet,listClasses = loadDataSet() #导入外部数据集
#dataSet:句子的词向量
#listClass是句子所属的类别[0,1,0,1,0,1]
nb                  = NBayes()      #实例化
nb.train_set(dataSet,listClasses)   #训练数据集
nb.map2vocab(dataSet[0])            #随机选择一个测试语句
print nb.predict(nb.testset)