《机器学习实战》学习笔记（三）

第四章 基于概率论的分类方法:朴素贝叶斯

引言

朴素贝叶斯优缺点

优 点 ：在数据较少的情况下仍然有效，可以处理多类别问题。

缺 点 ：对于输入数据的准备方式较为敏感。

适用数据类型：标称型数据

朴素贝叶斯的一般过程

1. 收集数据 ：可以使用任何方法。
2. 准备数据：需要数值型或者布尔型数据。
3. 分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好。
4. 训练算法：计算不同的独立特征的条件概率。
5. 测试算法：计算错误率。
6. 使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。

之前的决策树也是这个流程。这个流程机器学习是否是通用的？

4 . 1 基于贝叶斯决策理论的分类方法

现在用$p1(x,y)$ 表示数据点(x,y)属于类别1（用图中用圆点表示的类别）的概率，用$p2(x,y)$表示数据点(x,y)属于类别2 ( 图中用三角形表示的类别）的概率，那么对于一个新数据点(x,y)，可以用下面的规则来判断它的类别：

1. 如果p1(x,y)> p2 (x,y), 那么类别为1。
2. 如 果 於 p2(x,y)> p1(x,y), 那么类别为2

也就是说，我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。

4.2条件概率

直接看概率论吧!
回忆一下贝叶斯公式。

贝叶斯公式

$$p(c|x)=\frac{p(c|x)p(c)}{p(x)}$$

4.3 使用条件概率来分类

应用贝叶斯准则得到贝叶斯分类准则为：

1. 如果$p(c_1|x,y)>p(c_2|x,y)$,那么属于类别$c_1$。
2. 如果$p(c_1|x,y)<p(c_2|x,y)$,那么属于类别$c_2$。
   $$p(c_i|x,y)=\frac{p(x,y|c_i)p(c_i)}{p(x,y)}$$

使用贝叶斯准则，可以通过巳知的三个概率值来计算未知的概率值。

4.4 使用朴素贝叶斯进行文档分类

观察文档中出现的词，并把每个词的出现或者不出现作为一个特征，这样得到的特征数目就会跟词汇表中的词目一样多。

要得到好的概率分布，就需要足够的数据样本，假定样本数为N。由统计学知，如果每个特征需要N个样本，那么对于10个特征将需要$N^{1}0$个样本，对于包含1000个特征的词汇表将需要$N^{1}000$个样本,所需要的样本数会随着特征数目增大而迅速增长。

朴素贝叶斯分类器的两个假设

假设特征之间相互独立，那么样本数就可以从$N^{1}000$减少到1000 x N。

所谓独立（independence）指的是统计意义上的独立，即一个特征或者单词出现的可能性与它和其他单词相邻没有关系。(这种假设并不正确)词语之间的组合是有一定的规律的，像形容词一般是修饰名词，不太可能修饰形容词。
这个假设正是朴素贝叶斯分类器中朴素（naive) 一词的含义。

朴素贝叶斯分类器中的另一个假设是，每个特征同等重要。这个假设也有问题。 判断留言板的留言是否得当，只需要看10~20个特征就足以做出判断了，不需要全部看完。

4.5使 用 Python进行文本分类

要从文本中获取特征，需要先拆分文本。
这里的特征是来自文本的词条(token), 一个词条是字符的任意组合。可以把词条想象为单词，也可以使用非单词词条，如URL、IP址或者任意其他字符串。然后将每一个文本片段表示为一个词条向量，其中值为1表示词条出现在文档中，0表示词条未出现。

准备数据：从文本中构建词向量

把文本看成单词向量或者词条向量，也就是说将句子转换为向量。考虑出现在所有文档中的所有单词，再决定将哪些词纳人词汇表或者说所要的词汇集合，然后必须要将每一篇文档转换为词汇表上的向量。

词表到向暈的转换函数

代码是参考书里的代码

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]    #1 is abusive, 0 not
    return postingList,classVec

def createVocabList(dataSet):
    vocabSet = set([])  #create empty set
    for document in dataSet:
        vocabSet = vocabSet | set(document) #union of the two sets
    return list(vocabSet)
 
def setOfWords2Vec(vocabList, inputSet):
    #创建列表值全为零
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            #index()在列表中查找某个元素并输出对应的索引值(位置)，
            #这里是在现有列表中找到了，则对应位置值置去
            returnVec[vocabList.index(word)] = 1
        else: print( "the word: %s is not in my Vocabulary!" %word)
    return returnVec

listOPosts,listClasses = loadDataSet()
myVocabList = createVocabList(listOPosts)
print(myVocabList)
#第一句
print(setOfWords2Vec(myVocabList,listOPosts[0] ))

输出结果如下：

['cute', 'stupid', 'is', 'garbage', 'steak', 'dalmation', 'to', 'dog', 'please', 'mr', 'ate', 'has', 'how', 'take', 'so', 'him', 'licks', 'posting', 'maybe', 'worthless', 'buying', 'flea', 'my', 'not', 'problems', 'I', 'quit', 'food', 'park', 'love', 'stop', 'help']
[0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]

创建一个字典，然后我们的句子中用到的字，将字典对应位置标记为1 ，没用到的位置标记为0.

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

函数的伪代码如下：

计算每个类别中的文档数目
对每篇训练文档：
	对每个类别：
		如果词条出现文档中―增加该词条的计数值
		增加所有词条的计数值
	对每个类别：
		对每个词条：
			将该词条的数目除以总词条数目得到条件概率
	返回回每个类别的条件概率

代码实现如下：

def trainNB0(trainMatrix,trainCategory):
    #计算训练的文档数目
    numTrainDocs = len(trainMatrix)
    #计算每篇文档的词条数
    numWords = len(trainMatrix[0])
    #文档属于侮辱类的概率，算的是侮辱类样本占总样本的个数
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    
    #ones()以创建任意维度和元素个数的数组，其元素值均为1
    #这里是进行了优化，避免原代码设置为零时，计算出现某一个条件概率为零时，计算结果为零。
    #这个改进被称为拉普拉斯平滑
    #另外一个改进是取了对数，防止计算时出现下溢出。
    #p0Num为非侮辱类情况下的条件概率，（所有的）
    p0Num = ones(numWords); p1Num = ones(numWords)      #change to ones() 
    p0Denom = 2.0; p1Denom = 2.0                        #change to 2.0
    
    for i in range(numTrainDocs):
        #如果是侮辱类
        if trainCategory[i] == 1:
            #p1Num是向量，所有成员一起算
            p1Num += trainMatrix[i]
            #sum(iterable[, start])，sum()最后求得的值 = 可迭代对象里面的数加起来的总和(字典:key值相加)+ start的值
            #统计侮辱类样本单词的个数
            p1Denom += sum(trainMatrix[i])
        #非侮辱类
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    #计算每个单词分别在侮辱类中出现的概率以及非侮辱类中出现的概率
    p1Vect = log(p1Num/p1Denom)          #change to log()
    p0Vect = log(p0Num/p0Denom)          #change to log()
    return p0Vect,p1Vect,pAbusive
    #生成数据列表
postingList,classVec = loadDataSet()
#生成词汇表
myVocabList = createVocabList(postingList)
#存储样本产生的词向量
trainMat = []
#将样本转为词向量，并存储到tarinMat中
for postinDoc in postingList:
    #append(object) 是将一个对象作为一个整体添加到列表中，添加后的列表比原列表多一个元素，
    # 该函数的参数可以是任何类型的对象
    trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
p0V,p1V,pAb = trainNB0(trainMat, classVec) 

print("p0V"+ str(p0V),end='\n')
print("p1V"+ str(p1V),end='\n')
print("pAb"+ str(pAb),end='\n')

输出结果如下：

测试算法：根据现实情况修改分类器

主要为两点改进，已经在之前的代码中标明了。

1. 要计算多个概率的乘积以获得文档属于某个类别的概率 。如果其中一个概率值为0,那么最后的乘积也为0。为降低这种影响，可以将所有词的出现数初始化为1，并将分母初始化为2。
2. 另一个遇到的问题是下溢出，太多很小的数相乘，会超出计算机飙到精度，所以将小数乘积取对数。（Python数据计算log时怎么计算的，转换为log后计算?不然相除后不一样溢出了？还是运算时精度与表达时是不一样的？）

朴素贝叶斯分类函数

#要分类的向量vec2Classify以及使用函数trainNB0计算的到的三个概率
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):

    #贝叶斯公式的分母
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)    #element-wise mult
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else: 
        return 0


#生成数据列表
postingList,classVec = loadDataSet()
#生成词汇表
myVocabList = createVocabList(postingList)
#存储样本产生的词向量
trainMat = []
#将样本转为词向量，并存储到tarinMat中
for postinDoc in postingList:
    #append(object) 是将一个对象作为一个整体添加到列表中，添加后的列表比原列表多一个元素，
    # 该函数的参数可以是任何类型的对象
    trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
p0V,p1V,pAb = trainNB0(trainMat, classVec) 

# print("p0V\n"+ str(p0V),end='\n')
# print("p1V\n"+ str(p1V),end='\n')
# print("pAb\n"+ str(pAb),end='\n')

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

#测试样本2
testEntry = ['stupid', 'garbage']							
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))	
if classifyNB(thisDoc,p0V,p1V,pAb):
    print(testEntry,'属于侮辱类')							
else:
    print(testEntry,'属于非侮辱类')							

输出结果如下：

['love', 'my', 'dalmation'] 属于非侮辱类
['stupid', 'garbage'] 属于侮辱类

贝叶斯分类过程大致概括为：

将待分类的样本通过词典转换为转换为词向量。 词向量表示样本是以有这个单词标记为1，没有标记为零，使用词向量与通过训练样本得到的各单词在侮辱类与非侮辱类中出现的概率的向量相乘并求和得到贝叶斯公式分母中的$p(x,y|c_i）$。

因为通过训练样本得到的概率为log值，所以加上侮辱类的概率的对数值即可得到完整的分母。

通过比较侮辱类与非侮辱类的概率即可得到分类结果。

4.6示例：使用朴素贝叶斯过滤垃圾邮件

准备数据：文档词袋模型

前面每个词的出现与否作为一个特征，这可以被描述为词集模型（set - of - words - model）如果一个词在文档中出现不止一次，这可能意味着包含该词是否出现在文档中所不能表达的某种信息，这种方法被称为词袋模型（set - of - words - model）。

在词袋中，每个单词可以出现多次，而在词集中，每个词只能出现一次。

实现程序如下：

#词袋向量生成
def bagOfWords2VecMN(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

对比词集向量生成，差别只在于

returnVec[vocabList.index(word)] += 1

这里将统计词语出现的次数。

准备数据：切分文本

def textParse(bigString):    #input is big string, #output is word list

    #将特殊符号作为切分标志进行字符串切分，即非字母、非数字
    listOfTokens = re.split(r'\W+', bigString)
    #除了单个字母，例如大写的I，其它单词变成小写
    return [tok.lower() for tok in listOfTokens if len(tok) > 2] 


docList = []; classList = []
#遍历26个txt文件
for i in range(1, 26):                
    #读取每个垃圾邮件，并字符串转换成字符串列表                                  
    wordList = textParse(open(r'Ch04/email/spam/%d.txt' % i, 'r').read())     
    docList.append(wordList)
    #标记垃圾邮件，1表示垃圾文件
    classList.append(1)         
    #读取每个非垃圾邮件，并字符串转换成字符串列表                                        
    wordList = textParse(open(r'Ch04/email/ham/%d.txt' % i, 'r').read())     
    docList.append(wordList)
    #标记非垃圾邮件，1表示垃圾文件 
    classList.append(0)         
#创建词汇表，不重复                                          
vocabList = createVocabList(docList)     
print(vocabList)                              

输出结果如下：

已经将不重复的单词选择出。

在使用书中提供的代码时，要注意修改一下

listOfTokens = re.split(r'\W+', bigString）

将书中给出的$“\ast ”$修改为$“+”$号

测试算法：使用朴素贝叶斯进行交叉验证

                                   
def spamTest():
    docList = []; classList = []; fullText = []
    for i in range(1, 26):                                        
        #读取每个垃圾邮件，并字符串转换成字符串列表         
        wordList = textParse(open('Ch04/email/spam/%d.txt' % i, 'r').read())   
        #将单词加到文件列表向量中 
        docList.append(wordList)

        fullText.append(wordList)
        #标记垃圾邮件，1表示垃圾文件
        classList.append(1)                                                
        #读取每个非垃圾邮件，并字符串转换成字符串列表
        wordList = textParse(open('Ch04/email/ham/%d.txt' % i, 'r').read())      
        docList.append(wordList)
        fullText.append(wordList)
        #标记非垃圾邮件，1表示垃圾文件  
        classList.append(0)                         
    #创建词汇表，不重复                         
    vocabList = createVocabList(docList)                                    
    #创建存储训练集的索引值的列表和测试集的索引值的列表
    trainingSet = list(range(50)); testSet = []                     
    #从50个邮件中，随机挑选出40个作为训练集,10个做测试集                              
    for i in range(10):  
        #随机选取索索引值                                                   
        randIndex = int(random.uniform(0, len(trainingSet)))    
        #添加测试集的索引值            
        testSet.append(trainingSet[randIndex])                             
         #在训练集列表中删除添加到测试集的索引值
        del(trainingSet[randIndex])                                        
        #创建训练集矩阵和训练集类别标签系向量  
    trainMat = []; trainClasses = []                    
     #遍历训练集                               
    for docIndex in trainingSet:               
        #将生成的词集模型添加到训练矩阵中                            
        trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))       
        #将类别添加到训练集类别标签系向量中
        trainClasses.append(classList[docIndex])                            
        #训练朴素贝叶斯模型
    p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))  
    #错误分类计数
    errorCount = 0
    #遍历测试集                                                          
    for docIndex in testSet:                
         #测试集的词集模型                                
        wordVector = setOfWords2Vec(vocabList, docList[docIndex])          
        #如果分类错误
        if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
             #错误计数加1    
            errorCount += 1                                                
            print("分类错误的测试集：",docList[docIndex])
    print('错误率：%.2f%%' % (float(errorCount) / len(testSet) * 100))

spamTest()

输出如下：

分类错误的测试集： ['home', 'based', 'business', 'opportunity', 'knocking', 'your', 'door', 'don抰', 'rude', 'and', 'let', 'this', 'chance', 'you', 'can', 'earn', 'great', 'income', 'and', 'find', 'your', 'financial', 'life', 'transformed', 'learn', 'more', 'here', 'your', 'success', 'work', 'from', 'home', 'finder', 'experts']
错误率：10.00%

程序主要内容还是借用之前的贝叶斯分类进行判断。新增的是由于要处理从文档载入的数据，而进行的一些数据操作。

4.7 示例：使用朴素贝叶斯分类器从个人广告中获取区域倾向

收集数据

没有使用书里提供的方式，我参考的是这个博客《《机器学习实战》学习笔记（五）》
参考博客先安装个中文语句切分工具。
下载他的数据集时，要转到GitHub里面去，我一直连接不上。
这有几种解决方式：无法访问 GitHub 几种解决方式
我没用到上面的，我用的是这个——>修改hosts-使用SwitchHosts软件

还有一个要说的是下载的时候要点到仓库首页，点那个code,直接点那个博客链接进去是没有那个code选项的。（第一次使用好坑，折腾半天）

实现代码如下：

def TextProcessing(folder_path):
    #查看folder_path下的文件
    folder_list = os.listdir(folder_path)       
    #训练集                
    data_list = []                                                
    class_list = []

    #遍历每个子文件夹
    for folder in folder_list:
        #根据子文件夹，生成新的路径,join将两个路径合并起来
        new_folder_path = os.path.join(folder_path, folder)       
        #存放子文件夹下的txt文件的列表
        files = os.listdir(new_folder_path)                        

        j = 1
        #遍历每个txt文件
        for file in files:
            #每类txt样本数最多100个
            if j > 100:                                            
                break
            #打开txt文件
            with open(os.path.join(new_folder_path, file), 'r', encoding = 'utf-8') as f:    
                raw = f.read()
            
            #精简模式，返回一个可迭代的generator
            word_cut = jieba.cut(raw, cut_all = False)      
            #generator转换为list      
            word_list = list(word_cut)                            
            #将数据存到data_list中
            data_list.append(word_list)
            #将类别存到数据之后
            class_list.append(folder)
            j += 1
        print(data_list)
        print(class_list)
        #训练集存放地址
folder_path = './Ch04/SogouC/Sample'
TextProcessing(folder_path)

输出切割效果如下：

看到输出已经将词语切割出来了。

数据集网上也找了一些，由于我想借用博客的代码，所以找了半天代码使用的数据集。如果不使用博客代码关于数据集的分割部分，则可以根据我们手里的数据设计合适的数据转换的都拿。

髙频词与常见结束语去除函数

根据去掉结束语包含的常见词，去掉出现频率最高的100个词，得到特征词表。
实现代码：

#读取文件里的内容，并去重
def MakeWordsSet(words_file):
    words_set = set()   
    #打开文件                                         
    with open(words_file, 'r', encoding = 'utf-8') as f: 
        #一行一行读取      
        for line in f.readlines():      
            #去回车                         
            word = line.strip()      
            #有文本，则添加到words_set中                              
            if len(word) > 0:                                   
                words_set.add(word)                               
    return words_set                                             #返回处理结果

#
def words_dict(all_words_list, deleteN, stopwords_set = set()):
    feature_words = []                            #特征列表
    n = 1
    for t in range(deleteN, len(all_words_list), 1):
        if n > 1000:                            #feature_words的维度为1000
            break                               
        #如果这个词不是数字，并且不是指定的结束语，并且单词长度大于1小于5，那么这个词就可以作为特征词
        if not all_words_list[t].isdigit() and all_words_list[t] not in stopwords_set and 1 < len(all_words_list[t]) < 
            feature_words.append(all_words_list[t])
        n += 1
    return feature_words
#文本预处理
#训练集存放地址
folder_path = './Ch04/SogouC/Sample'               
all_words_list, train_data_list, test_data_list, train_class_list, test_class_list = TextProcessing(folder_path, test_size=0.2)
# print(all_words_list)

#生成stopwords_set
stopwords_file = './Ch04/stopwords_cn.txt'
stopwords_set = MakeWordsSet(stopwords_file)

#根据去掉结束语包含的常见词，去掉出现频率最高的100个词，得到特征词表
feature_words = words_dict(all_words_list, 100, stopwords_set)
print(feature_words)

输出结果：

输出的是作为文本的特征词表，即朴素贝叶斯生成向量时需要的词向量。
后面对测试样本和训练分类时也需要使用词向量，所以进行转化代码如下：

#创建存储训练集的索引值的列表和测试集的索引值的列表
trainingSet = range(len(train_data_list))
testSet = range(len(test_data_list))

#创建训练集矩阵和测试集向量  
trainMat = []; testMat = []                    
#遍历训练集                               
for docIndex in trainingSet:               
    #将生成的词集模型添加到训练矩阵中                            
    trainMat.append(setOfWords2Vec(feature_words, train_data_list[docIndex]))       
    #将类别添加到训练集类别标签系向量中
    # trainClasses.append(train_class_list[docIndex])                            

for docIndex in testSet:               
    #将生成的词集模型添加到训练矩阵中                            
    testMat.append(setOfWords2Vec(feature_words, test_data_list[docIndex]))   
    #将类别添加到训练集类别标签系向量中
    # trainClasses.append(train_class_list[docIndex])                           

输出结果如下：

看到测试样本与训练样本已经被转为了向量。
这里转换时我没有将训练样本中的非特征值删掉，所以出现了如下输出：

这是在将样本转向量时，我们只去取了特征词所以这些非特征词就被输出了。

使用Sklearn构建朴素贝叶斯分类器

之前分辨侮辱类与非侮辱类的函数这里使用不了，侮辱类与非侮辱类只有两类，这里好多类不能直接使用,要进行修改。
所以我就使用已经有的素贝叶斯分类器。

函数需要的参数我们已经处理好了，这里传递后可以直接使用，最后将测试精度输出

#新闻分类器
def TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list):
    classifier = MultinomialNB().fit(train_feature_list, train_class_list)
    test_accuracy = classifier.score(test_feature_list, test_class_list)
    return test_accuracy

from sklearn.naive_bayes import MultinomialNB
test_accuracy = TextClassifier(trainMat, testMat, train_class_list, test_class_list)

print(test_accuracy)

输出结果如下：

0.5263157894736842

输出数据分类结果

利用朴素贝叶斯分类器MultinomialNB自带的predict（）方法，可以将分类结果输出。
实现代码如下：

classifier = MultinomialNB().fit(train_feature_list, train_class_list)
predict_result=classifier.predict(test_feature_list)
   
index = 0
for test_class in test_class_list:
    print('test class is%s\n' %test_class +'predict result is:%s\n' %str(predict_result[index]))
    index +=1

输出结果如下：

test class为测试样本的类别，predict result为输出的预测结果。

4.8本章小结

本章最主要是引进了贝叶斯概率分类的思想，与实现。主要内容也都是围绕着这一主题展开的，以侮辱类文字识别为实例，实现了对侮辱类文字使用贝叶斯分类的要求。

我认为贝叶斯分类的核心思想是：概率最高的即为对应类别。本章的主要内容是围绕如何去获取各个数据概率实现来展开的。首先是理论推导，推导给出的两个假设，一个是特征之间相互独立，一个是特征之间同样重要，使得贝叶斯分类有了实现的可能。之后便是将实际的文本转换为可以计算的数据的方法。之后便是对数据进行计算得到概率大小。