机器学习 之朴素贝叶斯_gaussiannb()参数

朴素贝叶斯

贝叶斯模型同样是流行的十大挖掘算法之一，属于有监督的学习算法，是专门用于解决分类问题的模型，该模型的数学理论并不复杂，只需要具备概率论和数理统计的部分知识，该分类器的实现思想非常简单，即通过已知类别的训练数据及计算样本先验概率，然后利用贝叶斯公式测算未知类别样本属于某个类别的后验概率，最终以最大的后验概率所对应的类别作为样本的预测值。

朴素贝叶斯模型，在对于未知类别的样本进行预测时，有几大优点：

• 首先算法在运算过程中简单而且高效
• 其次算法拥有古典概型的理论支撑分类效率稳定
• 最后算法对于缺失数据和异常数据不太敏感

同时缺点也是存在的：

• 模型的判断结果依赖于先验概率，所以分类结果存在一定的错误率
• 对于输入的自变量X要求具有相同的特征
• 模型的前提假设在实际应用中很难得满足。

由于该模型只用到数理统计中的朴素贝叶斯公式，所以在这里就不再赘述，相信大家也都有所了解朴素贝叶斯。

高斯朴素贝叶斯中的参数

GaussianNB(priors=None) # 没错，它的主要参数就这一个。
该参数用于指定因变量各类别的先验概率，默认以数据集中的类别频率作为先验概率
所以通常情况下，我们不对高斯普速被淹死，做任何参数的调整。
1
2
3

高斯朴素贝叶斯的使用

from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix as CM
from sklearn.datasets import load_digits
digits=load_digits()
x,y=digits.data,digits.target
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.3,random_state=10)
gnb=GaussianNB().fit(x_train,y_train)
gnb.score(x_train,y_train)
gnb.predict_proba(x_test).sum(axis=1).shape
y_pro=gnb.predict(x_test)
CM(y_test,y_pro)

1
2
3
4
5
6
7
8
9
10
11
12
13

模型评估指标

布里尔分数

from sklearn.metrics import brier_score_loss
brier_score_loss(y_true # 真实标签
				, y_prob # 标签正概率
				, pos_label=None # 填写正样本标签
				)
需要注意的是布里尔分数只能用于二分类，不能用于多分类。
他返回的是一个浮点类型的数据，表示的是模型丢失数据的比例。所以越小越好。
1
2
3
4
5
6
7

对数似然

from sklearn.metrics import log_loss
log_loss(y_true# 真是标签结果
		, y_prede # 预测结果，predict_proba返回的值，不是predict返回的值  
		)
返回的是损失值，因此对数自然函数的取值越小，证明概率估计越准确。
1
2
3
4
5

高斯朴素贝叶斯对不同数据集的效果

from sklearn.naive_bayes import GaussianNB
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification

######生成三种数据集######
# 二分类数据集
X, y = make_classification(n_samples=100, #生成100个样本
 n_features=2,#有两个特征
 n_redundant=0, #添加冗余特征0个
 n_informative=2, #包含信息的特征是2个
 random_state=1,#随机模式1
n_clusters_per_class=1 #每个簇内包含的标签类别有1个
 )
rng = np.random.RandomState(2) #生成一种随机模式
X += 2 * rng.uniform(size=X.shape) #加减0~1之间的随机数
linearly_separable = (X, y) #生成了新的X，依然可以画散点图来观察一下特征的分布
#plt.scatter(X[:,0],X[:,1])

#用make_moons创建月亮型数据，make_circles创建环形数据，并将三组数据打包起来放在列表datasets中
moons=make_moons(noise=0.3, random_state=0)
circles=make_circles(noise=0.2, factor=0.5, random_state=1)
datasets = [moons,circles,linearly_separable]


figure = plt.figure(figsize=(6, 9))
i=1
#设置用来安排图像显示位置的全局变量i i = 1
#开始迭代数据，对datasets中的数据进行for循环
for ds_index, ds in enumerate(datasets):
    X, y = ds
    # 对数据进行标准化处理
    X = StandardScaler().fit_transform(X)
    #划分数据集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4,
random_state=42)

    #定数据范围，以便后续进行画图背景的确定
    #注意X[:,0]指横坐标，X[：，1]指纵坐标
    x1_min, x1_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    x2_min, x2_max = X[:, 1].min() - .5, X[:, 1].max() + .5

    #使画板上每个点组成坐标的形式（没间隔0.2取一个），array1表示横坐标，array2表示纵坐标
    array1,array2 = np.meshgrid(np.arange(x1_min, x1_max, 0.2), np.arange(x2_min, x2_max, 0.2))
    # 颜色列表
    cm_bright = ListedColormap(['#FF0000', '#0000FF'])

########## 原始数据的现实  #########

    # 用画板上六个图片位置（3，2）的第i个
    ax = plt.subplot(len(datasets), 2, i)

    # 便签添加
    if ds_index == 0:
        ax.set_title("Input data")

    #画出训练数据集散点图
    ax.scatter(X_train[:, 0],#横坐标
               X_train[:, 1],#纵坐标
               c=y_train,#意思是根据y_train标签从cm_bright颜色列表中取出对应的颜色，也就是说相同的标签有相同的颜色。
               cmap = cm_bright, #颜色列表
               edgecolors = 'k'#生成散点图，每一个点边缘的颜色
               )
    #画出测试数据集的散点图，其中比训练集多出alpha = 0.4参数，以分辨训练测试集
    ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test,cmap = cm_bright, alpha = 0.4, edgecolors = 'k')
    #显示的坐标范围
    ax.set_xlim(array1.min(), array1.max())
    ax.set_ylim(array2.min(), array2.max())
    #不显示坐标值
    ax.set_xticks(())
    ax.set_yticks(())

    #i+1显示在下一个子图版上画图
    i += 1

####### 经过决策的数据显示 #######
    ax = plt.subplot(len(datasets), 2, i)
    #实例化训练模型
    gnd = GaussianNB().fit(X_train, y_train)
    score = gnd.score(X_test, y_test)

    # np.c_是能够将两个数组组合起来的函数
    # ravel()能够将一个多维数组转换成一维数组
    #通过对画板上每一个点的预测值确定分类结果范围，并以此为依据通，通过不同的颜色展现出来范围

    # 为了展示不同概率对应不同的颜色就不用这句代码作为contourf的z参数了Z = clf.predict(np.c_[array1.ravel(), array2.ravel()])
    # 通过计算每一个结果对应的概率，并选出其中的最大值作为contourf参数
    Z = gnd.predict_proba(np.c_[array1.ravel(), array2.ravel()])
    Z = Z[:,0].reshape(array1.shape)
    cm = plt.cm.RdBu # 自动选取颜色的实例化模型。
    ax.contourf(array1#画板横坐标。
                , array2#画板纵坐标
                , Z# 画板每个点对应的预测值m,并据此来确定底底板的颜色。
                , cmap=cm#颜颜色选取的模型，由于Z的值只有两个，也可以写出一个颜色列表，指定相应颜色，不让其自动生成
                , alpha=0.8
                )
    #和原始数据集一样，画出每个训练集和测试集的散点图
    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors = 'k')
    ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, edgecolors = 'k', alpha = 0.4)
    ax.set_xlim(array1.min(), array1.max())
    ax.set_ylim(array2.min(), array2.max())
    ax.set_xticks(())
    ax.set_yticks(())

    if ds_index == 0:
        ax.set_title("GaussianNB")

    #在右下角添加模型的分数
    ax.text(array1.max() - .3, array2.min() + .3, ('{:.1f}%'.format(score * 100)),
    size = 15, horizontalalignment = 'right')
    i += 1

#自动调整子画板与子画板之间的的距离
plt.tight_layout()
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

可以看出高斯朴素这些线性的数据有着非常好的效果，但是对于非线性的数据的结果并不是特别的理想

不同样本量对于高斯朴素贝叶斯的影响

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression as LR
from sklearn.model_selection import learning_curve
from sklearn.model_selection import ShuffleSplit
import time

def plot_learning_curve(estimator,title,x,y,ax,ylim=None,cv=None,n_jobs=None):
    train_size,train_scores,test_scores=learning_curve(estimator # 分类器
                                                       ,x,y# 数据
                                                       ,cv=cv # 交叉验证的模式
                                                       ,n_jobs=n_jobs)
    # train_size 为每次训练和测试集划分后，在训练集上的样本数量，会自动选取
    # train_scores为(5,50)5表示划分了5次数据，50代表每次划分训练集50次交叉验证对应的分数，所以要取均值
    # test_scores为(5,50)5表示划分了5次数据，50代表每次划分测试集50次交叉验证对应的分数，所以要取均值
    ax.set_title(title)
    if ylim is not None:
        ax.set_ylim(ylim)
    ax.set_xlabel("Training examples")
    ax.set_ylabel("Score")
    ax.grid()
    ax.plot(train_size,np.mean(train_scores,axis=1),"o-",label="Training scores",color="red")
    ax.plot(train_size, np.mean(test_scores, axis=1), "o-", label="Training scores", color="green")
    ax.legend(loc="lower right")


title_list=["GaussianNB","LR","RandomForestClassifier","SVC"]
model_list=[GaussianNB()
    ,LR(C=1,solver="lbfgs",max_iter=3000,multi_class="auto")
    ,RandomForestClassifier(n_estimators=20)
    ,SVC(kernel="rbf",gamma=0.001)]

cv=ShuffleSplit(n_splits=50 # 将数据分成50份，验证次数
                ,test_size=0.2 # 将20%作为测试集
                ,random_state=10
                )

digits=load_digits()
x=pd.DataFrame(digits.data)
y=pd.Series(digits.target)

fig=plt.figure(figsize=(20,4))
for i in range(0,4):
    start=time.time()
    ax=fig.add_subplot(1,4,i+1)
    plot_learning_curve(model_list[i],title_list[i],x,y,ax,[0.7,1.05],cv,1)
    end=time.time()
    print(title_list[i])
    print(end-start)
plt.tight_layout()
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

GaussianNB
2.445056200027466
LR
19.8220853805542
RandomForestClassifier
12.856705665588379
SVC
26.9399311542511
1
2
3
4
5
6
7
8

通过这段代码也能够非常明显的看出，高斯朴素贝叶斯和其他算法之间的优劣，对于其他算法来说，在模型过拟合的时候，可以通过大量的数据对通过对于模型的提升，使测试集的分数不断上升而达到比较好的效果，但是对于高斯朴素贝叶斯来说，随着样本数据的增大，虽然过拟合的程度降低，但是测试训练及的分数也随之降低，模型的效果也相对没有其他模型那么好。但是对于它的优点来说，我们可以直观的发现，它使用的时间是非常短的效率是非常高的。