sklearn模块全称为scikit-learn
,是机器学习和人工智能领域最知名的模块之一。它提供了非常丰富的机器学习方法函数,详情可以参考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)。
参数 | alpha : float,optional(default = 1.0) |
---|---|
添加拉普拉修/Lidstone平滑参数(0表示无平滑) | |
fit_prior : boolean,optional(default = True) | |
表示是否学习先验概率,参数为False表示所有类标记具有相同的先验概率 | |
class_prior : array-like,size(n_classes,),可选(默认=None) | |
类别的先验概率。如果指定,则不根据数据调整先验。 | |
属性 | class_log_prior_ : array, shape (n_classes, ) |
各类标记的平滑先验概率对数值,其取值会受fit_prior和class_prior参数的影响 | |
intercept_ : array, shape (n_classes, ) | |
将多项式朴素贝叶斯解释的class_log_prior_映射为线性模型,其值和class_log_prior_相同 | |
feature_log_prob_ : array, shape (n_classes, n_features) | |
给出一个类的特征条件概率P(xi | y)的对数值,返回形状为(n_classes, n_features)数组 | |
coef_ : array, shape (n_classes, n_features) | |
将多项式朴素贝叶斯解释feature_log_prob_映射成线性模型,其值和feature_log_prob相同 | |
class_count_ : array, shape (n_classes,) | |
训练样本中各类别对应的样本数,按类的顺序排序输出 | |
feature_count_ : array, shape (n_classes, n_features) | |
各类别各个特征出现的次数,返回形状为(n_classes, n_features)数组 |
(1)使用MultinomialNB构建简单的模型
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)
MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)
print(clf.predict(X[2:3]))
输出:
[3]
(2)使用属性
- class_log_prior_:各类标记的平滑先验概率对数值,其取值会受fit_prior和class_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)
## 观察各类标记的平滑先验概率对数值
clf.class_log_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_:训练样本中各类别对应的样本数,按类的顺序排序输出
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)
# class_count_:训练样本中各类别对应的样本数,按类的顺序排序输出
clf.class_count_
输出:
array([2., 1., 1., 1.])
- feature_count_:各类别各个特征出现的次数,返回形状为(n_classes, n_features)数组
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)
clf.feature_count_
输出:
array([[4., 1., 3., 4.],
[0., 2., 1., 0.],
[1., 0., 3., 1.],
[1., 3., 3., 3.]])
(3)方法
fit(self, X, y, sample_weight=None) | 根据X、y训练模型 |
get_params(deep=True) | 获取分类器的参数,以各参数字典形式返回 |
partial_fit(X, y, classes=None, sample_weight=None) | 对于数据量大时,提供增量式训练,在线学习模型参数,参数X可以是类似数组或稀疏矩阵,在第一次调用函数,必须制定classes参数,随后调用时可以忽略 |
predict(self, X) | 在测试集X上预测,输出X对应目标值 |
predict_log_proba(self, X) | 测试样本划分到各个类的概率对数值 |
predict_proba(self, X) | 输出测试样本划分到各个类别的概率值 |
score(self, X, y[, sample_weight]) | 输出对测试样本的预测准确率的平均值 |
set_params(self, **params) | 设置估计器的参数 |
- fit(X, y, sample_weight=None):根据X、y训练模型
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)
输出:
MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)
- get_params(deep=True):获取分类器的参数,以各参数字典形式返回
clf.get_params
输出:
<bound method BaseEstimator.get_params of MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)>
- 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]
## 使用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,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):测试样本划分到各个类的概率对数值
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)
clf.predict_log_proba([[3,4,5,4],[1,3,5,6]])
输出:
array([[-1.34753906, -1.92376992, -2.02148376, -0.77304163],
[-1.57810037, -3.38647492, -2.13426204, -0.44398716]])
- predict_proba(X):输出测试样本划分到各个类别的概率值
clf.predict_proba([[3,4,5,4],[1,3,5,6]])
输出:
array([[0.25987902, 0.14605531, 0.13245878, 0.46160689],
[0.20636675, 0.03382771, 0.11833188, 0.64147366]])
- score(X, y, sample_weight=None):输出对测试样本的预测准确率的平均值
clf.score([[2,1,4,4],[2,0,1,1]],[1,2])
输出:
0.5
- **set_params(params):设置估计器的参数
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)
## 设置参数
clf.set_params(alpha=2.0)
输出:
MultinomialNB(alpha=2.0, class_prior=None, fit_prior=True)
参考博客:https://blog.csdn.net/kancy110/article/details/72763276
如有版权问题请与我联系。