sklearn模块之朴素贝叶斯：（一）多项式模型的实现

约定不等于承诺〃 2021-11-02 15:38 448阅读 0赞

sklearn模块全称为`scikit-learn`，是机器学习和人工智能领域最知名的模块之一。它提供了非常丰富的机器学习方法函数，详情可以参考[scikit-learn官网文档API][scikit-learn_API]。

本次学习的是朴素贝叶斯，官方提供了三种方式实现：

*  GaussianNB(高斯朴素贝叶斯)
 *  MultinomialNB(多项式朴素贝叶斯)
 *  BernoulliNB(伯努利朴素贝叶斯)

由于博主目前只涉及到一种的学习，所以其它两种后续会更新。

### 一、多项式朴素贝叶斯的实现 ###

> class sklearn.naive\_bayes.MultinomialNB（alpha = 1.0，fit\_prior = True，class\_prior = None ）

用于多项式模型的朴素贝叶斯分类器

`多项式朴素贝叶斯分类器`适用于具有离散特征的分类（例如，用于文本分类的字数）。例如文本分类单词统计，以出现的次数作为特征值（`统计频数`）。在实践中，诸如TF-IDF的分数计数也可以起作用。 `TF-IDF`（term frequency–inverse document frequency）是一种用于信息检索与数据挖掘的常用加权技术。TF意思是词频(Term Frequency)，IDF意思是逆文本频率指数(Inverse Document Frequency)。

<table> 
 <tbody> 
  <tr> 
   <th>参数</th> 
   <td>alpha ： float，optional（default = 1.0）</td> 
  </tr> 
  <tr> 
   <td>添加拉普拉修/Lidstone平滑参数（0表示无平滑）</td> 
  </tr> 
  <tr> 
   <td>fit_prior ： boolean，optional（default = True）</td> 
  </tr> 
  <tr> 
   <td>表示是否学习先验概率，参数为False表示所有类标记具有相同的先验概率</td> 
  </tr> 
  <tr> 
   <td>class_prior ： array-like，size（n_classes，），可选（默认=None）</td> 
  </tr> 
  <tr> 
   <td>类别的先验概率。如果指定，则不根据数据调整先验。</td> 
  </tr> 
  <tr> 
   <th>属性</th> 
   <td>class_log_prior_ : array, shape (n_classes, )</td> 
  </tr> 
  <tr> 
   <td>各类标记的平滑先验概率对数值，其取值会受fit_prior和class_prior参数的影响</td> 
  </tr> 
  <tr> 
   <td>intercept_ : array, shape (n_classes, )</td> 
  </tr> 
  <tr> 
   <td>将多项式朴素贝叶斯解释的class_log_prior_映射为线性模型，其值和class_log_prior_相同</td> 
  </tr> 
  <tr> 
   <td>feature_log_prob_ : array, shape (n_classes, n_features)</td> 
  </tr> 
  <tr> 
   <td>给出一个类的特征条件概率P(xi | y)的对数值，返回形状为(n_classes, n_features)数组</td> 
  </tr> 
  <tr> 
   <td>coef_ : array, shape (n_classes, n_features)</td> 
  </tr> 
  <tr> 
   <td>将多项式朴素贝叶斯解释feature_log_prob_映射成线性模型，其值和feature_log_prob相同</td> 
  </tr> 
  <tr> 
   <td>class_count_ : array, shape (n_classes,)</td> 
  </tr> 
  <tr> 
   <td>训练样本中各类别对应的样本数，按类的顺序排序输出</td> 
  </tr> 
  <tr> 
   <td>feature_count_ : array, shape (n_classes, n_features)</td> 
  </tr> 
  <tr> 
   <td>各类别各个特征出现的次数，返回形状为(n_classes, n_features)数组</td> 
  </tr> 
 </tbody> 
</table>

**（1）使用MultinomialNB构建简单的模型**

输出：

[3]

**（2）使用属性**

*  **class\_log\_prior\_**：各类标记的平滑先验概率对数值，其取值会受fit\_prior和class\_prior参数的影响

输出：

array([-1.60943791, -1.60943791, -1.60943791, -1.60943791, -1.60943791])

① 若指定了`class_prior`参数，不管`fit_prior`为True或False，`class_log_prior_`取值是class\_prior转换成log后的结果

import numpy as np
    from sklearn.naive_bayes import MultinomialNB
    X = np.array([[2,1,1,3,3],[2,0,2,1,1],[0,2,1,0,4],[1,0,3,1,3],[1,3,3,3,2]])
    y = np.array([1, 2, 3, 4, 5])
    clf = MultinomialNB()
    clf.fit(X, y)
    ## 观察各类标记的平滑先验概率对数值
    print(clf.class_log_prior_)
    ## 指定先验概率
    clf1 = MultinomialNB(alpha=1.0,fit_prior=False,class_prior=[0.3,0.2,0.1,0.2,0.2])
    clf1.fit(X,y)
    print(clf1.class_log_prior_)

输出：

[-1.60943791 -1.60943791 -1.60943791 -1.60943791 -1.60943791]
    [-1.2039728  -1.60943791 -2.30258509 -1.60943791 -1.60943791]

② 若`fit_prior`参数为False，`class_prior`=None，则各类标记的先验概率相同等于类标记总个数N分之一

import numpy as np
    from sklearn.naive_bayes import MultinomialNB
    X = np.array([[2,1,1,3,3],[2,0,2,1,1],[0,2,1,0,4],[1,0,3,1,3],[1,3,3,3,2]])
    y = np.array([1, 2, 3, 4, 5])
    clf = MultinomialNB(fit_prior=False,class_prior=None)
    clf.fit(X, y)
    ## 观察各类标记的平滑先验概率对数值
    print(clf.class_log_prior_)
    
    # 验证是否是1/5
    print(np.log(0.2))

输出：

[-1.60943791 -1.60943791 -1.60943791 -1.60943791 -1.60943791]
    -1.6094379124341003

③ 若`fit_prior`参数为True，`class_prior`=None，则各类标记的先验概率等于各类标记个数除以各类标记个数之和（将y的类别稍加改动即可）

import numpy as np
    from sklearn.naive_bayes import MultinomialNB
    X = np.array([[2,1,1,3,3],[2,0,2,1,1],[0,2,1,0,4],[1,0,3,1,3],[1,3,3,3,2]])
    y = np.array([1, 1, 2, 3, 4])
    clf = MultinomialNB(fit_prior=True,class_prior=None)
    clf.fit(X, y)
    ## 观察各类标记的平滑先验概率对数值
    print(clf.class_log_prior_)
    
    # 验证是否是2/5 、 1/5 、1/5 、1/5
    print(np.log(2/5),np.log(1/5),np.log(1/5),np.log(1/5))

输出：

[-0.91629073 -1.60943791 -1.60943791 -1.60943791]
    -0.916290731874155 -1.6094379124341003 -1.6094379124341003 -1.6094379124341003

*  **intercept\_**：将多项式朴素贝叶斯解释的`class_log_prior_`映射为线性模型，其值和class\_log\_prior\_相同

import numpy as np
    from sklearn.naive_bayes import MultinomialNB
    X = np.array([[2,1,1,3,3],[2,0,2,1,1],[0,2,1,0,4],[1,0,3,1,3],[1,3,3,3,2]])
    y = np.array([1, 2, 3, 4, 5])
    clf = MultinomialNB()
    clf.fit(X, y)
    ## 观察各类标记的平滑先验概率对数值
    print(clf.class_log_prior_)
    
    ## intercept_：将多项式朴素贝叶斯解释的class_log_prior_映射为线性模型，其值和class_log_propr相同
    print(clf.intercept_)

输出：

[-1.60943791 -1.60943791 -1.60943791 -1.60943791 -1.60943791]
    [-1.60943791 -1.60943791 -1.60943791 -1.60943791 -1.60943791]

*  **feature\_log\_prob\_**：指定类的各特征概率(**条件概率**)对数值，返回形状为(n\_classes, n\_features)数组

> 特征的条件概率=（指定类下指定特征出现的次数+alpha）/（指定类下所有特征出现次数之和+类的可能取值个数\*alpha）

特征条件概率计算过程，以类为1各个特征对应的`条件概率`为例：

import numpy as np
    from sklearn.naive_bayes import MultinomialNB
    X = np.array([[2,1,1,3],[2,0,2,1],[0,2,1,0],[1,0,3,1],[1,3,3,3]])
    y = np.array([1, 1, 2, 3, 4])
    clf = MultinomialNB(alpha=1.0,fit_prior=True)
    clf.fit(X, y)
    # 查看各特征的条件概率
    print(clf.feature_log_prob_)
    print('---'*10)
    
    # 验证是否正确
    print(np.log((2+2+1)/(2+1+1+3+2+2+1+4*1)),np.log((1+0+1)/(2+1+1+3+2+2+1+4*1)),
          np.log((1+2+1)/(2+1+1+3+2+2+1+4*1)),np.log((3+1+1)/(2+1+1+3+2+2+1+4*1)))

输出：

[[-1.16315081 -2.07944154 -1.38629436 -1.16315081]
     [-1.94591015 -0.84729786 -1.25276297 -1.94591015]
     [-1.5040774  -2.19722458 -0.81093022 -1.5040774 ]
     [-1.94591015 -1.25276297 -1.25276297 -1.25276297]]
    ------------------------------
    -1.1631508098056809 -2.0794415416798357 -1.3862943611198906 -1.1631508098056809

*  **coef\_**：将多项式朴素贝叶斯解释feature\_log\_prob\_映射成线性模型，其值和feature\_log\_prob相同

import numpy as np
    from sklearn.naive_bayes import MultinomialNB
    X = np.array([[2,1,1,3],[2,0,2,1],[0,2,1,0],[1,0,3,1],[1,3,3,3]])
    y = np.array([1, 1, 2, 3, 4])
    clf = MultinomialNB(alpha=1.0,fit_prior=True)
    clf.fit(X, y)
    # 查看各特征的条件概率
    print(clf.feature_log_prob_)
    print('---'*10)
    # coef_：将多项式朴素贝叶斯解释feature_log_prob_映射成线性模型，其值和feature_log_prob相同
    print(clf.coef_)

输出：

[[-1.16315081 -2.07944154 -1.38629436 -1.16315081]
     [-1.94591015 -0.84729786 -1.25276297 -1.94591015]
     [-1.5040774  -2.19722458 -0.81093022 -1.5040774 ]
     [-1.94591015 -1.25276297 -1.25276297 -1.25276297]]
    ------------------------------
    [[-1.16315081 -2.07944154 -1.38629436 -1.16315081]
     [-1.94591015 -0.84729786 -1.25276297 -1.94591015]
     [-1.5040774  -2.19722458 -0.81093022 -1.5040774 ]
     [-1.94591015 -1.25276297 -1.25276297 -1.25276297]]

*  **class\_count\_**：训练样本中各类别对应的样本数，按类的顺序排序输出

输出：

array([2., 1., 1., 1.])

*  **feature\_count\_**：各类别各个特征出现的次数，返回形状为(n\_classes, n\_features)数组

输出：

array([[4., 1., 3., 4.],
           [0., 2., 1., 0.],
           [1., 0., 3., 1.],
           [1., 3., 3., 3.]])

**（3）方法**

<table> 
 <tbody> 
  <tr> 
   <td>fit(self, X, y, sample_weight=None)</td> 
   <td>根据X、y训练模型</td> 
  </tr> 
  <tr> 
   <td>get_params(deep=True)</td> 
   <td>获取分类器的参数，以各参数字典形式返回</td> 
  </tr> 
  <tr> 
   <td>partial_fit(X, y, classes=None, sample_weight=None)</td> 
   <td>对于数据量大时，提供增量式训练，在线学习模型参数，参数X可以是类似数组或稀疏矩阵，在第一次调用函数，必须制定classes参数，随后调用时可以忽略</td> 
  </tr> 
  <tr> 
   <td>predict(self, X)</td> 
   <td>在测试集X上预测，输出X对应目标值</td> 
  </tr> 
  <tr> 
   <td>predict_log_proba(self, X)</td> 
   <td>测试样本划分到各个类的概率对数值</td> 
  </tr> 
  <tr> 
   <td>predict_proba(self, X)</td> 
   <td>输出测试样本划分到各个类别的概率值</td> 
  </tr> 
  <tr> 
   <td>score(self, X, y[, sample_weight])</td> 
   <td>输出对测试样本的预测准确率的平均值</td> 
  </tr> 
  <tr> 
   <td>set_params(self, **params)</td> 
   <td>设置估计器的参数</td> 
  </tr> 
 </tbody> 
</table>

*  **fit(X, y, sample\_weight=None)**：根据X、y训练模型

输出：

MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)

*  **get\_params(deep=True)**：获取分类器的参数，以各参数字典形式返回

clf.get_params

输出：

*  **partial\_fit(X, y, classes=None, sample\_weight=None)**：对于数据量大时，提供增量式训练，在线学习模型参数，参数X可以是类似数组或稀疏矩阵，在第一次调用函数，必须制定classes参数，随后调用时可以忽略
    
     *  参数：**classes** : array-like, shape = \[n\_classes\] (default=None)
     *  可能出现在y向量中的所有类的列表。 必须在第一次调用partial\_fit时提供，在后续调用中可以省略。

## 使用partial_fit
    import numpy as np
    from sklearn.naive_bayes import MultinomialNB
    X = np.array([[2,1,1,3],[2,0,2,1],[0,2,1,0],[1,0,3,1],[1,3,3,3]])
    y = np.array([1, 1, 2, 3, 4])
    clf = MultinomialNB(alpha=1.0,fit_prior=True)
    clf.partial_fit(X,y)

输出：

ValueError: classes must be passed on the first call to partial_fit.

添加`classes=[1,2,3,4]`

输出：

MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)

*  **predict(X)**：在测试集X上预测，输出X对应目标值

clf.predict([[2,1,4,4],[2,0,1,1]])

输出：

array([1, 1])

*  **predict\_log\_proba(X)**：测试样本划分到各个类的概率对数值

输出：

array([[-1.34753906, -1.92376992, -2.02148376, -0.77304163],
           [-1.57810037, -3.38647492, -2.13426204, -0.44398716]])