机器学习实战-朴素贝叶斯

使用python进行文本分类

# -*- coding: utf-8 -*-
"""
Created on Mon Aug 21 17:17:19 2017

@author: rocky
"""

#机器学习实战第四章
#朴素bayes
#使用python进行文本分类

#从文本中构建词向量
from numpy import *
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'],
                 ['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代表侮辱性文字，0代表正常言论
    return postingList,classVec

def createVocalList(dataSet):
    vocabSet=set([])#set返回一个不含重复词的列表
    for document in dataSet:
        vocabSet=vocabSet|set(document)#创建两个集合的并集
    return list(vocabSet)

def setOfWord2Vec(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 my Vocabulary!" % word)
    return returnVec
#以上的三个程序的作用：
#程序1返回几篇文档和文本类别，程序2对程序1进行非重复处理并拼接，返回一篇文档
#程序3的输入分别对应程序2的结果和程序1中的第i篇文档，返回的结果是2的结果的每一个词
#是否出现在第i篇文章中。出现则是1，没出现则是0.
#这样我们就把一篇文章（在第i篇文档环境下）转换成了一组数字

我们可以做这样的实验，在命令窗口输入以下：

listOPosts,listClasses=loadDataSet()
data=[['my','dog'],['is','rain']]

lis=createVocalList(data)
lis
Out[22]: ['rain', 'my', 'is', 'dog']
setOfWord2Vec(lis,listOPosts[5])
the word: quit is not in my Vocabulary!
the word: buying is not in my Vocabulary!
the word: worthless is not in my Vocabulary!
the word: food is not in my Vocabulary!
the word: stupid is not in my Vocabulary!
Out[23]: [0, 0, 0, 1]

我们可以判断第六行的每个词是否出现在data中，从而得到data的数字表示，为后面对data进行概率计算(好坏属性判断)准备。

训练算法：从词向量计算概率

#训练算法：从词向量计算概率（假设二类分布，即只有两个属性）
def trainNB0(trainMatrix,trainCategory):
    numTrainDocs=len(trainMatrix)#统计矩阵行数，即文档数
    numWords=len(trainMatrix[0])#统计列数，即每个文档的字数
    pAbusive=sum(trainCategory)/float(numTrainDocs)#计算文档属性的概率（P1，另一个就是P0）
    p0Num=zeros(numWords)#建立零向量，长度为文档字数
    p1Num=zeros(numWords)
    p0Denom=0.0
    p1Denom=0.0#以上是对概率的初始化
    for i in range(numTrainDocs):#循环每个文档
        if trainCategory[i]==1:#如果这个文档的属性是1
            p1Num+=trainMatrix[i]#把第i行数据（或者第i个文档）赋给p1Num
            p1Denom+=sum(trainMatrix[i])#求该文档中1的和，赋给。。。
        else:
            p0Num+=trainMatrix[i]
            p0Denom+=sum(trainMatrix[i])
    p1Vect=p1Num/p1Denom
    p0Vect=p0Num/p0Denom
    return p0Vect,p1Vect,pAbusive

在命令行输入以下命令检验：

#建立自己的数据集和类别，不使用上面的。
data=[['to','my','worthless'],['dog','take','ate'],['stop','to','him']]

listclass=[1,1,0]

mylist=createVocalList(data)
#mylist就是待检验的文档
mylist
Out[17]: ['to', 'worthless', 'take', 'ate', 'my', 'him', 'dog', 'stop']

trainmat=[]
#生成一个文本矩阵，代表着这个待检验文本在每个样本下的存在与否
for postindoc in data:
    trainmat.append(setOfWord2Vec(mylist,postindoc))
  
trainmat
Out[21]: [[1, 1, 0, 0, 1, 0, 0, 0], [0, 0, 1, 1, 0, 0, 1, 0], [1, 0, 0, 0, 0, 1, 0, 1]]
#计算各个概率
p0V,p1V,pAb=trainNB0(trainmat,listclass)

pAb
Out[23]: 0.66666666666666663

p0V
Out[24]: 
array([ 0.33333333,  0.        ,  0.        ,  0.        ,  0.        ,
        0.33333333,  0.        ,  0.33333333])

p1V
Out[25]: 
array([ 0.16666667,  0.16666667,  0.16666667,  0.16666667,  0.16666667,
        0.        ,  0.16666667,  0.        ])
   

在trainNB0的循环中，循环参数是行数，也就是类别数，也就是3，而不是列数（8），这一点要注意。在上面自己的数据中，前两行类别都是1，那么经过i=0和i=1后，p1Num=(11111010)（两个向量相加），p1Denom=6(即3+3)，经i=2后，p0Num=(10000101)（第三个向量），p0Denom=3。这样就可以计算概率了。
以上计算的是文本中每个词在各个类别下出现的概率。

测试算法，修改分类器

上面计算了各个词在每个类别下的概率，下面就要计算多个概率的乘积来获得文档属于某个类别的概率。那么如果一个词的概率为0，总结果就是0，这显然不行。所以进行简单处理，所有词的初始出现数为1，分母初始化2，修改上述程序。修改p0Num\p0Denom\p1Num\p1Denom的初值，以及最后的概率计算，改为对数运算。

def trainNB0(trainMatrix,trainCategory):
    numTrainDocs=len(trainMatrix)#统计矩阵行数，即文档数
    numWords=len(trainMatrix[0])#统计列数，即每个文档的字数
    pAbusive=sum(trainCategory)/float(numTrainDocs)#计算文档属性的概率（P1，另一个就是P0）
    p0Num=ones(numWords)#建立o向量，长度为文档字数
    p1Num=ones(numWords)
    p0Denom=2.0
    p1Denom=2.0#以上是对概率的初始化
    for i in range(numTrainDocs):#循环每个文档
        if trainCategory[i]==1:#如果这个文档的属性是1
            p1Num+=trainMatrix[i]#把第i行数据（或者第i个文档）赋给p1Num
            p1Denom+=sum(trainMatrix[i])#求该文档中1的和，赋给。。。
        else:
            p0Num+=trainMatrix[i]
            p0Denom+=sum(trainMatrix[i])
    p1Vect=log(p1Num/p1Denom)
    p0Vect=log(p0Num/p0Denom)
    return p0Vect,p1Vect,pAbusive
    

下面构建完整的分类器。

#创建朴素贝叶斯分类函数
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    p1=sum(vec2Classify*p1Vec)+log(pClass1)
    p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)
    if p1>p0:
        return 1
    else:
        return 0

#以下的命令其实是将一些命令窗口中的操作封装为一个函数，叫便利函数。节省输入时间。    
def testingNB():
    listOPosts,listClasses=loadDataSet()
    myVocabList=createVocalList(listOPosts)
    trainMat=[]
    for postinDoc in listOPosts:
        trainMat.append(setOfWord2Vec(myVocabList,postinDoc))
    p0V,p1V,pAb=trainNB0(array(trainMat),array(listClasses))
    testEntry=['love','my','dalmation']
    thisDoc1=array(setOfWord2Vec(myVocabList,testEntry))
    #上面这一句的意思是检查myVocabList中的文字是否出现在testEntry中
    print(testEntry,'classified as: ',classifyNB(thisDoc1,p0V,p1V,pAb))
    
    testEntry=['stupid','garbage']
    thisDoc2=array(setOfWord2Vec(myVocabList,testEntry))
    print(testEntry,'classified as: ',classifyNB(thisDoc2,p0V,p1V,pAb))
    return thisDoc1,thisDoc2

    

最后的return thisDoc1,thisDoc2是自己加的，检查结果。后一个函数是封装了一些操作。命令窗口输入以下：

testingNB()
['love', 'my', 'dalmation'] classified as:  0
['stupid', 'garbage'] classified as:  1
Out[31]: (array([0, 0, 0, ..., 1, 0, 0]), array([0, 0, 0, ..., 0, 1, 0]))

我们可以看到，thisDoc1结果是([0, 0, 0, ..., 1, 0, 0]),中间有一些省略号，看不到中间是什么数据，这时我们可以在开头定义numpy的下面，输入一行'np.set_printoptions(threshold=np.inf)',可以保证数据全部显示,另外我也将myVocabList输出（return稍作修改即可）：

testingNB()
['love', 'my', 'dalmation'] classified as:  0
['stupid', 'garbage'] classified as:  1
Out[42]: 
(array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
        0, 0, 0, 0, 0, 0, 1, 0, 0]),
 array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 1, 0, 0, 0, 0, 1, 0]),
['to',
  'worthless',
  'ate',
  'quit',
  'stop',
  'steak',
  'take',
  'has',
  'I',
  'problem',
  'park',
  'dog',
  'so',
  'love',
  'is',
  'posting',
  'flea',
  'not',
  'help',
  'maybe',
  'my',
  'licks',
  'food',
  'cute',
  'buying',
  'stupid',
  'how',
  'please',
  'him',
  'dalmation',
  'garbage',
  'mr'])

以上我们可以看到['love', 'my', 'dalmation']的出现，用1表示，而之前我们得到了一个概率分布，这样thisDoc1（thisDoc2）表示待测文本在当前环境下的表示(仍保持thisDoc1的意义)，这样再利用函数classifyNB就可以计算thisDoc1是否属于侮辱性文档的概率。

注：处理垃圾邮件尚未学习，等回顾上述思路待后续。