机器学习实战之朴素贝叶斯--python/scikit-learn实现

最新推荐文章于 2024-08-22 17:08:36 发布

金融科技自习生

最新推荐文章于 2024-08-22 17:08:36 发布

阅读量1.7k

点赞数 2

分类专栏：机器学习 scikit-learn Python 文章标签：贝叶斯贝叶斯推导 scikit-learn

本文链接：https://blog.csdn.net/weixin_42147780/article/details/102776276

版权

机器学习同时被 3 个专栏收录

21 篇文章 0 订阅

订阅专栏

Python

15 篇文章 0 订阅

订阅专栏

scikit-learn

6 篇文章 0 订阅

订阅专栏

理论基础知识

贝叶斯与大多数机器学习算法不同，如：决策树，逻辑回归，支持向量机等都是判别方法，也就是直接学习出特征输出Y和特征X之间的关系，通过一个决策函数Y=f(X)或者条件分布P(Y|X)。今天的主角贝叶斯是生成方法，找出特征输出Y和特征X的联合分布P(X,Y),然后用P(Y|X)=P(X,Y)/P(X)得出。

基本思想

朴素贝叶斯假设：自变量特征之间条件独立

贝叶斯学派的思想可以概括为 先验概率+数据=后验概率（言外之意：我们在实际问题中想要得到的后验概率，可以通过先验概率和数据一起综合得到）

条件独立:如果X,Y互相独立，则有

P(X,Y)= P(X)*P(Y)

条件概率：

$P(Y|X) = \frac{P(X,Y)}{P(X)}$

$P(X|Y) = \frac{P(X,Y)}{P(Y)}$

P(Y|X)P(X)=P(X|Y)P(Y)

最后得到贝叶斯公式：

$P(Y|X)=\frac{P(X|Y)P(Y)}{P(X)}$

贝叶斯模型

现在我们来看一下怎么操作。假设我有m个样本数据：

$\left(x_{1}^{(1)}, x_{2}^{(1)}, \ldots x_{n}^{(1)}, y_{1}\right),\left(x_{1}^{(2)}, x_{2}^{(2)}, \ldots x_{n}^{(2)}, y_{2}\right), \ldots\left(x_{1}^{(m)}, x_{2}^{(m)}, \ldots x_{n}^{(m)}, y_{n}\right)$

每一个样本特征X有n个体征，标签Y有K个类别，定义为为： C_1,C_2,,,C_k

从已有的样本，我们很容易得到先验概率分布 P(Y=C_k) (k=1,,,,K)

再来看条件概率分布：

$P\left(X=x | Y=C_{k}\right)=P\left(X_{1}=x_{1}, X_{2}=x_{2}, \ldots X_{n}=x_{n} | Y=C_{k}\right)$

然后我们就可以用贝叶斯公式得到X,Y的联合分布P(X,Y)了，联合分布P(X,Y)定义为：

$P\left(X, Y=C_{k}\right)=P\left(Y=C_{k}\right) P\left(X=x | Y=C_{k}\right)=P\left(Y=C_{k}\right) P\left(X_{1}=x_{1}, X_{2}=x_{2}, \ldots X_{n}=x_{n} | Y=C_{k}\right)$

从上面可以看出我们的 P(Y=C_k) 很容易得到，统计一下各类被占的比例（频数）就能求得。

但是 $P\left(X_{1}=x_{1}, X_{2}=x_{2}, \ldots X_{n}=x_{n} | Y=C_{k}\right)$ 很难求出，因为这是一个很复杂的有n个维度的条件分布，因此朴素贝叶斯在这里做了一个大胆的假设：X的n个维度之间相互独立（也就是，特征之间条件独立），这样就可以得到：

$P\left(X_{1}=x_{1}, X_{2}=x_{2}, \ldots X_{n}=x_{n} | Y=C_{k}\right)=P\left(X_{1}=x_{1} | Y=C_{k}\right) P\left(X_{2}=x_{2} | Y=C_{k}\right) \ldots P\left(X_{n}=x_{n} | Y=C_{k}\right)$

这大大的简化了n维条件概率分布的难度，虽然很粗暴，但是很给力。

手动计算实例一：

实战项目--屏蔽社区留言板的侮辱性言论

Python版本

def loadDataSet():
    """
    创建数据集
    :return: 单词列表postingList, 所属类别classVec
    """
    postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'], #[0,0,1,1,1......]
                   ['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):
    """
    获取所有单词的集合
    :param dataSet: 数据集
    :return: 所有单词的集合(即不含重复元素的单词列表)
    """
    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):
    """
    遍历查看该单词是否出现，出现该单词则将该单词置1
    :param vocabList: 所有单词集合列表
    :param inputSet: 输入数据集
    :return: 匹配列表[0,1,0,1...]，其中 1与0 表示词汇表中的单词是否出现在输入的数据集中
    """
    # 创建一个和词汇表等长的向量，并将其元素都设置为0
    returnVec = [0] * len(vocabList)# [0,0......]
    # 遍历文档中的所有单词，如果出现了词汇表中的单词，则将输出的文档向量中的对应值设为1
    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


def _trainNB0(trainMatrix, trainCategory):
    """
    训练数据原版
    :param trainMatrix: 文件单词矩阵 [[1,0,1,1,1....],[],[]...]
    :param trainCategory: 文件对应的类别[0,1,1,0....]，列表长度等于单词矩阵数，其中的1代表对应的文件是侮辱性文件，0代表不是侮辱性矩阵
    :return:
    """
    # 文件数
    numTrainDocs = len(trainMatrix)
    # 单词数
    numWords = len(trainMatrix[0])
    # 侮辱性文件的出现概率，即trainCategory中所有的1的个数，
    # 代表的就是多少个侮辱性文件，与文件的总数相除就得到了侮辱性文件的出现概率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 构造单词出现次数列表
    p0Num = zeros(numWords) # [0,0,0,.....]
    p1Num = zeros(numWords) # [0,0,0,.....]

    # 整个数据集单词出现总数
    p0Denom = 0.0
    p1Denom = 0.0
    for i in range(numTrainDocs):
        # 是否是侮辱性文件
        if trainCategory[i] == 1:
            # 如果是侮辱性文件，对侮辱性文件的向量进行加和
            p1Num += trainMatrix[i] #[0,1,1,....] + [0,1,1,....]->[0,2,2,...]
            # 对向量中的所有元素进行求和，也就是计算所有侮辱性文件中出现的单词总数
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    # 类别1，即侮辱性文档的[P(F1|C1),P(F2|C1),P(F3|C1),P(F4|C1),P(F5|C1)....]列表
    # 即 在1类别下，每个单词出现的概率
    p1Vect = p1Num / p1Denom# [1,2,3,5]/90->[1/90,...]
    # 类别0，即正常文档的[P(F1|C0),P(F2|C0),P(F3|C0),P(F4|C0),P(F5|C0)....]列表
    # 即 在0类别下，每个单词出现的概率
    p0Vect = p0Num / p0Denom
    return p0Vect, p1Vect, pAbusive

def trainNB0(trainMatrix, trainCategory):
    """
    训练数据优化版本
    :param trainMatrix: 文件单词矩阵
    :param trainCategory: 文件对应的类别
    :return:
    """
    # 总文件数
    numTrainDocs = len(trainMatrix)
    # 总单词数
    numWords = len(trainMatrix[0])
    # 侮辱性文件的出现概率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 构造单词出现次数列表
    # p0Num 正常的统计
    # p1Num 侮辱的统计
    p0Num = ones(numWords)#[0,0......]->[1,1,1,1,1.....]
    p1Num = ones(numWords)

    # 整个数据集单词出现总数，2.0根据样本/实际调查结果调整分母的值（2主要是避免分母为0，当然值可以调整）
    # p0Denom 正常的统计
    # p1Denom 侮辱的统计
    p0Denom = 2.0
    p1Denom = 2.0
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            # 累加辱骂词的频次
            p1Num += trainMatrix[i]
            # 对每篇文章的辱骂的频次 进行统计汇总
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    # 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
    p1Vect = log(p1Num / p1Denom)
    # 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
    p0Vect = log(p0Num / p0Denom)
    return p0Vect, p1Vect, pAbusive

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    """
    使用算法：
        # 将乘法转换为加法
        乘法：P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
        加法：P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
    :param vec2Classify: 待测数据[0,1,1,1,1...]，即要分类的向量
    :param p0Vec: 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
    :param p1Vec: 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
    :param pClass1: 类别1，侮辱性文件的出现概率
    :return: 类别1 or 0
    """
    # 计算公式  log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
    # 大家可能会发现，上面的计算公式，没有除以贝叶斯准则的公式的分母，也就是 P(w) （P(w) 指的是此文档在所有的文档中出现的概率）就进行概率大小的比较了，
    # 因为 P(w) 针对的是包含侮辱和非侮辱的全部文档，所以 P(w) 是相同的。
    # 使用 NumPy 数组来计算两个向量相乘的结果，这里的相乘是指对应元素相乘，即先将两个向量中的第一个元素相乘，然后将第2个元素相乘，以此类推。
    # 我的理解是：这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
    p1 = sum(vec2Classify * p1Vec) + log(pClass1) # P(w|c1) * P(c1) ，即贝叶斯准则的分子
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1) # P(w|c0) * P(c0) ，即贝叶斯准则的分子·
    if p1 > p0:
        return 1
    else:
        return 0


def testingNB():
    """
    测试朴素贝叶斯算法
    """
    # 1. 加载数据集
    listOPosts, listClasses = loadDataSet()
    # 2. 创建单词集合
    myVocabList = createVocabList(listOPosts)
    # 3. 计算单词是否出现并创建数据矩阵
    trainMat = []
    for postinDoc in listOPosts:
        # 返回m*len(myVocabList)的矩阵， 记录的都是0，1信息
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    # 4. 训练数据
    p0V, p1V, pAb = trainNB0(array(trainMat), array(listClasses))
    # 5. 测试数据
    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)

Scikit-learn版本

import numpy as np


#获取之前的数据loadDataSet()、createVocabList()、setOfWords2Vec() 都是上面的
listOPosts, listClasses = loadDataSet()
#词汇表
myVocabList = createVocabList(listOPosts)
#特征
trainMat = []
for postinDoc in listOPosts:
    trainMat.append(setOfWords2Vec(myVocabList, postinDoc))


X = np.asarray(trainMat)
Y = listClasses

from sklearn.naive_bayes import GaussianNB  #导入模型
clf = GaussianNB() #实例化

clf.fit(X, Y) #拟合

print(clf.predict(X[0])) #预测

在scikit-learn中，一共有3个朴素贝叶斯的分类算法类。分别是GaussianNB，MultinomialNB和BernoulliNB。其中GaussianNB就是先验为高斯分布的朴素贝叶斯，MultinomialNB就是先验为多项式分布的朴素贝叶斯，而BernoulliNB就是先验为伯努利分布的朴素贝叶斯。这三个类适用的分类场景各不相同，一般来说，如果样本特征的分布大部分是连续值，使用GaussianNB会比较好。如果如果样本特征的分大部分是多元离散值，使用MultinomialNB比较合适。而如果样本特征是二元离散值或者很稀疏的多元离散值，应该使用BernoulliNB

One more thing

1.连续特征的处理方式

1.可以使用离散化技术处理，如分箱

2.假设连续特征符合高斯分布：

$\hat{P}\left(X_{j} | C=c_{i}\right)=\frac{1}{\sqrt{2 \pi} \sigma_{j i}} \exp \left(-\frac{\left(X_{j}-\mu_{j i}\right)^{2}}{2 \sigma_{j i}^{2}}\right)$

$\mu_{ji}$ 类别Ci对应的连续特征Xj 的平均值； $\delta _{ji}$ 是对应的标准差。

举个例子：

2.零概率问题--拉普拉斯平滑

零概率问题，就是在计算实例的概率时，如果某个量x，在观察样本库（训练集）中没有出现过，会导致整个实例的概率结果是0

以文本分类为例：在文本分类的问题中，当一个词语没有在训练样本中出现，该词语调概率为0，使用连乘计算文本出现概率时也为0。这是不合理的，不能因为一个事件没有观察到就武断的认为该事件的概率是0。

计算举例：

在文本分类中，有3个类，C1、C2、C3，在指定的训练样本中（共1000个文档），某个词语K1，在各个类中观测计数分别为0，990，10，K1的概率为0，0.99，0.01。对这三个量使用拉普拉斯平滑的计算方法如下：
1/1003 = 0.001，991/1003=0.988，11/1003=0.011

总结一句话：分子加1，分母加K（K等于类别数）

参考资料

https://shunliz.gitbooks.io/machine-learning/content/ml/bayes/scikit-simple-bayes.html

https://github.com/apachecn/AiLearning/blob/master/docs/ml/4.%E6%9C%B4%E7%B4%A0%E8%B4%9D%E5%8F%B6%E6%96%AF.md

scikit-learn文档：https://scikit-learn.org/stable/modules/naive_bayes.html#naive-bayes

<Getting Started with Machine Learning>--Jim Liang