《机器学习实战笔记--第一部分 分类算法：朴素贝叶斯分类1》

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

朴素贝叶斯：‘朴素’是因为整个形式我们只做最原始，最简单的假设。

优点：在数据较少的情况下仍有效；

缺点：对输入数据的准备方式敏感

适用于标称型数据

朴素贝叶斯是贝叶斯决策理论的一部分，所以先了解贝叶斯决策理论。

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

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

    朴素贝叶斯是贝叶斯分类器的一个扩展，是常用于文档分类的常用算法。

    朴素贝叶斯的一般过程：

（1）收集数据：可以使用任何方法。本章使用RSS源。

（2）准备数据：数值型或则布尔型数据

（3）分析数据：有大量特征时，绘制特征的作用不大。此时使用直方图效果更好

（4）测试算法：计算错误率

（5）使用算法：常见的是文本分类。可以在任意场景中使用，不一定非要是文本。

    由统计学得知：如果每个特征需要N个样本，那么对于10个特征需要N的10次方个样本。可以看到，所需要的样本数会随着特征数目的增大而迅速增长。

    如果特征之间是相互独立的，那么样本的个数可以从N的10次方较少到N*10个。

    朴素贝叶斯分类器中朴素含义：1.假设每个特征与其他的特征无关；2.每个特征同等重要。尽管上述假设存在一些小问题，但是朴素贝叶斯的实际效果却很好。

3.使用python进行文本分类

    要从文本中获取特征，首先要拆分文本。这里的特征时来自文本的词条。然后将每一个文本片段表示为一个词条向量，其中值为1表示词条出现在文档中，0表示词条喂出来。

    接下来给出将文本转化为数字向量的过程，然后介绍如何基于这些向量来计算条件概率，并在此基础上构建分类器，最后还要介绍一些在此过程中需要考虑的问题。

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

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

    创建bayes.py 词表到向量的转换函数

from numpy import *

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']]
    # 1骂人 0正常
    classVec = [0,1,0,1,0,1]    
    return postingList,classVec

# 创建一个包含在所有文本中出现的不重复词的列表
def createVocabList(dataSet):
    vocabSet = set([])  # 创建一个空集
    for document in dataSet:
        # 创建两个集合的并集
        vocabSet = vocabSet | set(document) 
    return list(vocabSet)

#词汇表中的词是否在文档中出现
# 输入参数为词汇表及某个文档
# 输出是文档向量，向量每一元素为1或0，分别表示词汇表中的单词在输入文档中是否出现
def setOfWords2Vec(vocabList, inputSet):
    # 创建一个长度和vocabList一样长的 全0向量
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            # 如果出现了词汇表中的单词，将输出的文档向量中对应位置的值设为1
            returnVec[vocabList.index(word)] = 1
        else: print ("the word: %s is not in my Vocabulary!" % word)
    return returnVec

     运行一下这些函数，效果如下：

    

     

    该函数使用词汇表或则想要检查的所有单词作为输入，然后为其中每一个单词构建一个特征。一旦给定一篇文档，该文档就会转换成词向量。

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

    前面介绍了如何将一组单词转换为一组数字。接下面看看如何使用这些数字计算概率。现在我们知道了一个单词是否出现在一篇文档中，也知道该文档所处的类别。 我们重写贝叶斯准则，将之前的x,y替换为w。w表示为一个向量，即它由多个数值组成。在这个例子中，数值个数与词汇表中的词个数相同。

                                                                                    

    我们使用上述公式，对每个类别进行计算值，比较两个概率值的大小。

    如何计算？

    首先可以通过类别i（骂人或正常）中文档数除以总的文档数来计算概率P( Ci )。 接下来计算P( W | Ci )，这里就要用到朴素贝叶斯假设。如果将W展开成一个个独立的特征，那么就要可以将上述概率写作p(W0, W1, W2, ... , Wn | Ci)。这里假设所有的词都互相独立，该假设也称作条件独立性假设，它意味着可以使用P( W0 | Ci)P(W1 | Ci)P(W2 | Ci)...P(Wn | Ci)计算上述概率，这就极大地简化了计算过程。

                                            

 朴素贝叶斯分类器训练函数

# 输入参数为文档矩阵trainMatrix， 以及由每篇文档类别标签构成的向量trainCategory。
def trainNB0(trainMatrix,trainCategory):
    # 文档数
    numTrainDocs = len(trainMatrix)
    # 每篇文档对应的词向量的长度
    numWords = len(trainMatrix[0])
    # 类别为1 即骂人类别的概率
    pAbusive = sum(trainCategory)/float(numTrainDocs)
   
    # 计算P(W|C1) P(W|C0),需要初始化程序中的分子变量和分母变量
    # 分母变量是一个元素个数等于词汇表大小的Numpy数组
    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]
            # 该文档的总次数也要加1
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
            
    # 最后对每个元素除以该类别中的总词数
    p1Vect = p1Num/p1Denom          
    p0Vect = p0Num/p0Denom          
    return p0Vect,p1Vect,pAbusive

    接下来我们构建词汇列表，在用for循环来填充trainMat列表。

trainMat = []
# 遍历词汇表
for postinDoc in listOposts:
    # 根据词汇表中的每个词创建相应的文档向量
    trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    
p0V, p1V, pAb = trainNB0(trainMat, listClass)
print(p0V,'\n', p1V,'\n', pAb)

    打印这些输出值，我们可以看到：

    我们可以看到骂人类别的文档的概率是0.5，该值是正确的。

    此时，我们词汇表中的第一个词是cute，该词汇在0类别中出现一次，在1类别中出现0次，所以对应的条件概率是0.041666和0.0。 可以看到该计算是正确的。 我们再找一找所有所有概率中的最大值，是0.15789497，对应于P1条件概率的第五个位置。

     我们可以查看到，第五个词是stupid。这就意味着stupid是最能表征类别1文档的单词。

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

    利用贝叶斯分类器对文档类别进行分类时，要计算多个概率乘积以获取文档属于某个类别的概率，即计算p(w0|1)p(w1|1)...p(wn|1)。如果里面有一个概率值是0，那么最后的乘积也是0。为了避免这种影响，可以将所有出现词的出现次数初始化为1，并将分母初始化为2。

     

    另外一个问题是下溢出，这是由于太多很小的数字相乘造成的。在计算p(w0|1)p(w1|1)...p(wn|1)时，由于大部分因子都很小，python在计算很多很小的数相乘的时候，最后会四舍五入变成0。一种解决方法是对乘积取自然对数，在代数中有ln(a*b)=ln(a)+ln(b)，于是可以通过计算对数的方法来解决这种错误。同时采用自然对数进行处理不会有任何的损失。下图给出函数f(x)和ln(f(x))的曲线。检查这两条曲线，就会发现他们在相同的区域里，都同时增加或减少，并且在相同的点上取极值。虽然取值不同，但是不影响最后的结果。

    修改代码：

    

    现在我们已经准备好完整的分类器了。当使用Numpy向量处理功能时，这一切都将变得十分简单。

    朴素贝叶斯分类函数：    

# 输入参数：要分类的向量vec2Classify，以及之前计算的三个概率。
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    # 元素相乘
    # 使用numpy数组来计算两个向量相乘的结果。这里相乘是指对应元素相乘
    # 即两个向量中第一个元素相乘，然后第二个元素相乘，以此类推
    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 = createVocabList(listOPosts)
    trainMat=[]
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V,p1V,pAb = trainNB0(array(trainMat),array(listClasses))
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))

    最终输出的结果：

    

    

3.4准备数据：文档词袋模型

    我们将每个词的出现与否作为一个特征，这可以被描述为 词集模型。如果一个词在文档中出现不止一次，这就可能意味着包含该词是否出现在文档中所不能表达的某种信息，这种方法称为 词袋模型。在词袋中，每个单词可以出现多次，而在词集中，每个词只能出现一次。为了适应词袋模型，需要对setOfWords2Vec()稍加修改，而修改后的函数称为bagOfWords2Vec()。

    下面给出词袋模型的朴素贝叶斯代码。它与函数setOfWords2Vec()几乎相同。唯一不同的地方就是每遇到一个单词时，他会增加词向量中的对应值，而不仅仅是将数值设为1。