朴素贝叶斯算法

Posted 韩非囚秦

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了朴素贝叶斯算法相关的知识,希望对你有一定的参考价值。

一、朴素贝叶斯分类算法简述

  1、贝叶斯公式和全概率公式

  举一个概率论中的例子。设某工厂有甲、乙、丙三个车间生产同一种产品,已知各车间的产量分别占全厂产量的25%、35%、40%,而且各车间的次品率依次为5%、4%、2%。现问:

  (1)生产的产品是次品的概率是多少?

  (2)如果是次品,该次品是甲工厂生产的概率是多少?

  显然:

  设一个产品属于甲、乙、丙工厂的概率分别为P(A) = 0.25, P(B) = 0.35, P(C) = 0.4。如果用no 表示次品,则有p(no|A) = 0.05, p(no|B) = 0.04, p(no|C) = 0.02。

  那么对于第一问,可以用全概率公式计算:

  p(no) = p(no|A)*p(A) + p(no|B)*p(B) + p(no|C)*p(C) = 0.25*0.05 + 0.35*0.04 + 0.4*0.02 = 0.0345

  对于第二问,则计算p(no)中出现p(no|A)*p(A)的概率即可:

  p(A|no) = p(no|A)*p(A) / p(no) = 0.3623

  2、朴素贝叶斯之核

  贝叶斯分类算法的一个核心思想是:如果知道某些特征,怎么可以确定它属于哪个类别?

  观察贝叶斯公式:

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

  我们可以借用贝叶斯公式,将贝叶斯分类器表达为:

      $$ P("属于某类"|"具有某些特征") = \frac{P("具有某些特征"|"属于某类") P("属于某类")}{P("具有某特征")} $$

  对于上面的一些概率,作如下解释:

    1.P("具有某些特征"|"属于某类"):在已知某样本"属于某类"的条件下,该样本"具有某特征"的概率。对于已有的训练集,这个条件是已知的。

    2.P("属于某类"):在未知某样本"具有某特征"的条件下,该样本"属于某类"的概率。对于已有的训练集,这个条件也是已知的。比如100个样本,有60个是a,有40个是b。那么在不知道新样本的具体数值时,我们认为它属于a的概率是60%,属于b的概率是40%。它叫作先验概率。

    3.P("具有某特征"):在未知某样本"属于某类"的条件下,该样本"具有某特征"的概率。对于一个给定的样本,我们认为它具有某特征的概率恒为1,因为它的特征已完全给定。

    4.P("属于某类"|"具有某特征"):在已知某样本"具有某特征"的条件下,该样本"属于某类"的概率。它叫作后验概率。这是我们想要得到的结果。

  由此可见,对于P("属于某类"|"具有某特征")的计算,只需要计算P("具有某些特征"|"属于某类") P("属于某类")即可。而P("属于某类")在给定带标签的数据集时可以很简便的计算得到,所以计算P("具有某些特征"|"属于某类")才是朴素贝叶斯分类器的核心。

  值得注意的是:全概率公式要求条件概率两两独立。为了满足其要求,朴素贝叶斯分类器在套用贝叶斯公式时,也假定所有的特征两两独立。尽管在现实中这是不可能的,但在某些应用场景中,朴素贝叶斯的分类效果仍然令人惊叹。

  3、朴素贝叶斯之刃

  朴素贝叶斯分类器通常出现在文本处理中。提到文本处理就应想到它的一系列流程:获取文档、切词(用户字典)、清洗(包括停用词、特殊字符、标点符号等)、降维(稀疏矩阵)、构建向量空间模型(TF-IDF)、建模(LDA等), 或者构建word2Vec、建模(RNN、LSTM)。

  朴素贝叶斯既然认为词与词之间的是相互独立的,显然要立足于向量空间模型(Vector space model)。

  向量空间模型做法如下:

    将所有语句中的词生成唯一值(bag of words)序列,作为特征向量。每条语句(文本)出现词的频数作为行向量。从而构成向量空间模型。

  举个例子:

import numpy as np
import pandas as pd
lis = [
    ["dog", "cat", "fish"],
    ["lion", "tiger"],
    ["cat", "fish"],
    ["dog"],
]
bags = list(set([word for row in lis for word in row]))
vsm = np.zeros([len(lis), len(bags)])
for i, row in enumerate(lis):
    for word in row:
        vsm[i, bags.index(word)] += 1
vsm = pd.DataFrame(vsm, columns=bags)
print(vsm)

  打印结果为:

 dogtigerfishlioncat
0 1.0 0.0 1.0 0.0 1.0
1 0.0 1.0 0.0 1.0 0.0
2 0.0 0.0 1.0 0.0 1.0
3 1.0 0.0 0.0 0.0 0.0

  TF-IDF在向量空间模型的基础上,对每个词的权重做了一些处理。它认为,如果一个词在该条句子(对应上表中的一行)中出现的频率非常高,并且在其它句子中出现的频率又非常低,那么这个词代表的信息量就越大,其权重值也越大。TF(词频)用于计算一个词在该条句子中的频率,IDF(反文档频率)用于计算一个词在每个句子中出现的频率。

  例如:

    第0行dog的TF词频为:$\frac{[0, dog]}{[0, dog] + [0, fish] + [0, cat]} = 0.33$

    第0行dog的IDF反文档频率为:$\log \frac{数据集长度}{[0, dog] + [3, dog]} = \log(4/2) = 0.69$

    第0行dog的TF-IDF权重值为:$ 0.33 * 0.69 = 0.228 $

  向量空间模型中所有元素的TF-IDF权重值构成的矩阵,称为TF-IDF权重矩阵。TF-IDF权重矩阵为p("属于某类"|"具有某些特征")的计算提供了基础。

  4、朴素贝叶斯算法的流程

    计算每个类别中的文档数目和其频率  # 实际计算P("属于某类”)

    对每篇训练文档:
          对每个类别:
              如果词条出现在文档中,增加该词条的计数值
              增加所有词条的计数值
          对每个类别:
              对每个词条:
                  将该词条的数目除以总词条数目得到条件概率
         返回每个类别的条件概率   # 实际计算P("具有某些特征"|"属于某类")

二、python3实现朴素贝叶斯

  1、python3实现朴素贝叶斯

  创建LoadDataSet类,用于生成数据集;创建NavieBayes类,用于实现朴素贝叶斯。

    NavieBayes

    train:训练数据集

    predict:测试数据集

    _calc_wordfreq

import numpy as np
import pandas as pd

class LoadDataSet(object):
    def get_dataSet(self):
        """lis是一行行文字切词后的文档集合,内容是斑点犬评论"""
        lis = [
            ["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"],
        ]
        vec= [0, 1, 0, 1, 0, 1]  # 1代表侮辱性文字,0代表正常言论;对应lis的6行数据
        return lis, vec

class NavieBayes(object):
    def __init__(self):
        self.Pcates = {}
        self.vocabulary  = None
        self.tf = None
    def train(self, trainSet, classVec):
        """训练集计算"""
        self.Pcates = {
            label:{
                "prob": classVec.count(label)/len(classVec),  # 记录P("属于某类")
                "tdm": None                                   # 记录p("具有某特征"|"属于某类")
            } for label in set(classVec)
}  # 计算每个类别的先验概率,保存成字典格式
        self.vocabulary = list(set([word for doc in trainSet for word in doc]))  # 生成词袋
        self.tf = self._tf_idf(trainSet)
        self._bulid_tdm(trainSet, classVec)
    
    def _tf_idf(self, trainSet):
        """生成tf和idf"""
        # 心中要有tf-idf矩阵
        vocLength = len(self.vocabulary)
        docLength = len(trainSet)
        idf = np.zeros([1, vocLength])  # 因为vocabulary是特征向量,所以写1 x N的向量,用以表示一个文档向量中葛格慈的频率
        tf = np.zeros([docLength, vocLength])  # tf矩阵:每个词的词频矩阵
        for i, doc in enumerate(trainSet):
            for word in doc:   # 统计每一行中的每个词在该行中出现的次数
                tf[i, self.vocabulary.index(word)] += 1  # 遍历每个词,计算其出现的次数并写到tf矩阵对应的位置
            tf[i] = tf[i] / len(trainSet[i])
            # 这一行的tf除以该行文件中的词总数(实际上就是row长度)以消除长短句的影响
            for singleword in set(doc):
                idf[0, self.vocabulary.index(singleword)] += 1  # 统计每个文档里的词在所有文档里出现的次数
            idf = np.log(len(trainSet) / (idf + 1))   # +1是为了防止0除
        return np.multiply(tf, idf)
    
    def _bulid_tdm(self, trainSet, classVec):
        """计算每个类别下每个词出现的概率"""
        tf_labels = np.c_[self.tf, labels]  # 在权重矩阵后面增加一列labels
        for label in self.Pcates.keys():
            label_tf_group = tf_labels[tf_labels[:, -1] == label][:, :-1]  # 获取label类对应的tf子矩阵
            label_tf = np.sum(label_tf_group, axis=0)/np.sum(label_tf_group)  # 行累加除以总值
            self.Pcates[label]["tdm"] = label_tf  # p("具有某特征"|"属于某类")
    
    def predict(self, test_wordList):
        """测试分类数据"""
        # 首先根据word_list生成词向量
        test_wordArray = np.zeros([1, len(self.vocabulary)])
        for word in test_wordList:
            test_wordArray[0, self.vocabulary.index(word)] += 1
        # 其次计算p("具有某特征"|"属于某类") * p("属于某类")
        # 不计算p("具有某特征")是因为假定对于每个测试的样本,它们具有的特征是完全随机的,都是一样的概率。
        pred_prob = 0
        pred_label = None
        for label, val in self.Pcates.items():
            test_prob = np.sum(test_wordArray * val["tdm"] * val["prob"])
            if test_prob > pred_prob:
                pred_prob = test_prob
                pred_label = label
        return {"predict_probability": round(pred_prob,4), "predict_label": pred_label}

  来一段测试代码:

load = LoadDataSet()
trainSet, labels = load.get_dataSet()
bayes = NavieBayes()
bayes.train(trainSet, labels)
bayes.predict(trainSet[0])

  2、sikit-learn实现朴素贝叶斯

   这里要用到sklearn.feature_extraction.text中的TfidfTransformerCountVectorizer

from sklearn import naive_bayes
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.feature_extraction.text import CountVectorizer

trainSet, labels = LoadDataSet().get_dataSet()
trainSet = [" ".join(row) for row in trainSet]

vectorizer = CountVectorizer()     # 用拼接的句子输入,它要生成svm,不接受长短不一的列表
transformer = TfidfTransformer()   # tf-idf权重矩阵

vsm = vectorizer.fit_transform(trainSet)  # 训练vsm模型
# print(vsm.toarray())  
# 更多方法请参阅 http://scikit-learn.org/stable/modules/feature_extraction.html#common-vectorizer-usage
tfidf = transformer.fit_transform(svm)    # 转换成tf-idf模型

# 生成测试用的数据
test = vectorizer.transform([trainSet[0]])
test = transformer.transform(test)

# 这里用混合贝叶斯模型;有兴趣的可以看伯努利模型、高斯模型
bys = naive_bayes.MultinomialNB()
bys.fit(tfidf, labels)

testData = trainSet[0]
bys.predict(test)

  

以上是关于朴素贝叶斯算法的主要内容,如果未能解决你的问题,请参考以下文章

朴素贝叶斯并不朴素

朴素贝叶斯算法简介及python代码实现分析

利用朴素贝叶斯算法进行分类-Java代码实现

机器学习——朴素贝叶斯算法

机器学习--朴素贝叶斯算法原理方法及代码实现

译文:朴素贝叶斯算法简介(Python和R中的代码)