朴素贝叶斯处理鸢尾花数据集
朴素贝叶斯公式


上代码
from sklearn import datasets
from sklearn.model_selection import GridSearchCV,train_test_split,cross_val_score
iris = datasets.load_iris()#下载鸢尾花数据集
data_x = iris["data"]#特征x
# print(data_x)
data_y = iris["target"]#类别y
#将每一列特征划分成几份区间，标准化
num_1=5#每个特征分成五份，我这里是每个特征都分成5个区间，也可以分开。不过代码自己改
def standard_feature(feature_col,num):
    max_0 = max(data_x[:,feature_col])
    min_0 = min(data_x[:,feature_col])
    width_0 = (max_0-min_0)/num
    for j in range(len(data_x[:,feature_col])):
        for i in range(1, num + 1):
            if min_0+(i-1)*width_0<=data_x[j,feature_col]<=min_0+i*width_0:
                data_x[j,feature_col] =i
                # print(data_x[j,feature])
                break
x_col_num = len(data_x[0])#获取列数及特征数目
def get_pb(one_feature,col,x_train):
    '''
    one_feature在该x_train数据集的col列的概率
    :param one_feature:查找的特征是啥
    :param col: 列
    :param x_train:
    :return: 返回该特征的概率
    '''
    fea_sum = 0
    for i in x_train[:,col]:
        if i == one_feature:
            fea_sum+=1
    col_all = len(x_train)
    p_b1 =fea_sum/col_all
    # if p_b1 == 0:
    #     print("第几列第几个特征个数为0",col,one_feature,len(x_train))#如果当你把x特征分的太细会出现有些特征测试集有但训练集没有。看len(x_train）当这个等于训练集总数第78行会除数为0
    return p_b1
for i in range(x_col_num):#data_x将所有特征标准化
    standard_feature(i,num_1)
x_train,x_test,y_train,y_test = train_test_split(data_x,data_y,test_size=0.3)#拆分成测试集，训练集
print("训练集样本数量",len(x_train))
print("测试集样本数量",len(x_test))

test_PB_list =[]#
for row_i in range(len(x_test)):
    P_B = 1
    for col_i in range(x_col_num):
        one_pb = get_pb(x_test[row_i,col_i],col_i,x_train)
        P_B *= one_pb
    #经过for循环得到每个测试集样本的P（B）
    test_PB_list.append(P_B)
print("test_PB_list元素个数",len(test_PB_list))
y =3
y_index_list = []#分别存放对应y的全部训练集的全部列索引，该列表元素的列表索引对应y
for y_num in range(y):
    one_y_index_list =[]
    for y_index in range(len(y_train)):
        if y_train[y_index] == y_num:
            one_y_index_list.append(y_index)
    y_index_list.append(one_y_index_list)
print("训练集中每类拥有索引个数",*[len(a) for a in y_index_list])
y_num_list = []
for y_num in range(y):
    one_y_num = 0
    for y_index in range(len(y_train)):
        if y_train[y_index] == y_num:
            one_y_num+=1
    y_num_list.append(one_y_num)
print("训练集每类拥有个数",y_num_list)
test_y_predict =[]#测试集预测Y
for test_row in range(len(x_test)):#test_row为测试集每行样本，每行样本都需要计算分类为各个y的概率，哪个概率最大，说明就是哪一类
    final_y_P = []
    for y_index in range(y):
        x_train_yindex = x_train[y_index_list[y_index],:]
        P_BinA = 1
        for col_i in range(x_col_num):
            one_pb = get_pb(x_test[test_row, col_i], col_i, x_train_yindex)
            P_BinA *= one_pb
        PAinB=(y_num_list[y_index]/len(y_train))*P_BinA/test_PB_list[test_row]
        final_y_P.append(PAinB)
    belong_class = final_y_P.index(max(final_y_P))
    test_y_predict.append(belong_class)
print(test_y_predict)
print(list(y_test))
predict_right_num = 0
for i in range(len(test_y_predict)):
    if test_y_predict[i] == y_test[i]:
        predict_right_num+=1
probability = predict_right_num/len(test_y_predict)
print("预测正确概率",probability)

接下来打算用其他方法实现分类，以鸢尾花为数据集KNN logistic 决策树

一、实验目的
(1)	掌握贝叶斯算法原理；

(2)	掌握朴素贝叶斯原理；

(3)	使用朴素贝叶斯处理鸢尾花数据集分类
二、实验内容
（1）导入库，加载鸢尾花数据，输出样本和鸢尾花特征

（2）数据分割，数据分割，形成模型训练数据和测试数据

（3）高斯贝叶斯模型构建

（4）计算预测值并计算准确率

（5）画图
三、实验代码
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib as mpl
from sklearn.preprocessing import StandardScaler, MinMaxScaler, PolynomialFeatures
from sklearn.naive_bayes import GaussianNB
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
data = pd.read_csv('iris.csv',header=None)
x = data.drop([4],axis=1)
x = x.drop([0],axis=0)
x = np.array(x,dtype=float)
print(x)
y=pd.Categorical(data[4]).codes
print(data[4])
y=y[1:151]
print(y)
p=x[:,2:5]

x_train1,x_test1,y_train1,y_test1=train_test_split(x,y,train_size=0.8,random_state=14)
x_train,x_test,y_train,y_test=x_train1,x_test1,y_train1,y_test1
print('训练数据集样本数目：%d，测试数据集样本数目：%d'%(x_train.shape[0],x_test.shape[0]))
clf=GaussianNB()
ir=clf.fit(x_train,y_train)
y_pred=ir.predict(x_test)
acc = np.sum(y_test == y_pred)/x_test.shape[0]
print('测试集准确度：%.3f'% acc)
y_pred = ir.predict(x_train)
acc = np.sum(y_train == y_pred)/x_train.shape[0]
print('训练集准确度：%.3f'% acc)

print('选取前两个特征值')
p=x[:,:2]
p_train1,p_test1,y_train1,y_test1=train_test_split(p,y,train_size=0.8,random_state=1)
p_train,p_test,y_train,y_test=p_train1,p_test1,y_train1,y_test1
print('训练数据集样本数目：%d，测试数据集样本数目：%d'%(p_train.shape[0],p_test.shape[0]))
clf=GaussianNB()
ir=clf.fit(p_train,y_train)
y_pred=ir.predict(p_test)
acc = np.sum(y_test == y_pred)/p_test.shape[0]
print('测试集准确度：%.3f'% acc)
y_pred = ir.predict(p_train)
acc = np.sum(y_train == y_pred)/p_train.shape[0]
print('训练集准确度：%.3f'% acc)

p1_max,p1_min = max(p_test[:,0]),min(p_test[:,0])
p2_max,p2_min = max(p_test[:,1]),min(p_test[:,1])
t1 = np.linspace(p1_min,p1_max,500)
t2 = np.linspace(p2_min,p2_max,500)
p1,p2 = np.meshgrid(t1,t2)#生成网格采样点
p_test1 = np.stack((p1.flat, p2.flat), axis=1)
y_hat = ir.predict(p_test1)
mpl.rcParams['font.sans-serif'] = [u'SimHei']
mpl.rcParams['axes.unicode_minus'] = False
cm_light = mpl.colors.ListedColormap(['#77E0A0', '#FF8080', '#A0A0FF'])
cm_dark = mpl.colors.ListedColormap(['g', 'r', 'b'])
plt.figure(facecolor='w')
plt.pcolormesh(p1, p2, y_hat.reshape(p1.shape),shading='auto', cmap=cm_light) # 预测值的显示
plt.scatter(p_test[:, 0], p_test[:, 1], c=y_test, edgecolors='k', s=50, cmap=cm_dark)  # 样本
plt.xlabel(u'花萼长度', fontsize=14)
plt.ylabel(u'花萼宽度', fontsize=14)
plt.title(u'GaussianNB对鸢尾花数据的分类结果', fontsize=16)
plt.grid(True)
plt.xlim(p1_min, p1_max)
plt.ylim(p2_min, p2_max)
plt.show()

print('选取后两个特征值')
q=x[:,2:4]
q_train1,q_test1,y_train1,y_test1=train_test_split(q,y,train_size=0.8,random_state=1)
q_train,q_test,y_train,y_test=q_train1,q_test1,y_train1,y_test1
print('训练数据集样本数目：%d，测试数据集样本数目：%d'%(q_train.shape[0],q_test.shape[0]))
clf=GaussianNB()
ir=clf.fit(q_train,y_train)
y_pred=ir.predict(q_test)
acc = np.sum(y_test == y_pred)/q_test.shape[0]
print('测试集准确度：%.3f'% acc)
y_pred = ir.predict(q_train)
acc = np.sum(y_train == y_pred)/q_train.shape[0]
print('训练集准确度：%.3f'% acc)

q1_max,q1_min = max(q_test[:,0]),min(q_test[:,0])
q2_max,q2_min = max(q_test[:,1]),min(q_test[:,1])
t1 = np.linspace(q1_min,q1_max,500)
t2 = np.linspace(q2_min,q2_max,500)
q1,q2 = np.meshgrid(t1,t2)#生成网格采样点
q_test1 = np.stack((q1.flat, q2.flat), axis=1)
y_hat = ir.predict(q_test1)
mpl.rcParams['font.sans-serif'] = [u'SimHei']
mpl.rcParams['axes.unicode_minus'] = False
cm_light = mpl.colors.ListedColormap(['#A0FFA0', '#FFA0A0', '#A0A0FF'])
cm_dark = mpl.colors.ListedColormap(['g', 'r', 'b'])
plt.figure(facecolor='w')
plt.pcolormesh(q1, q2, y_hat.reshape(q1.shape),shading='auto', cmap = cm_light) # 预测值的显示
plt.scatter(q_test[:, 0], q_test[:, 1], c=y_test, edgecolors='k', s=50, cmap= cm_dark)  # 样本
plt.xlabel(u'花瓣长度', fontsize=14)
plt.ylabel(u'花瓣宽度', fontsize=14)
plt.title(u'GaussianNB对鸢尾花数据的分类结果', fontsize=16)
plt.grid(True)
plt.xlim(q1_min, q1_max)
plt.ylim(q2_min, q2_max)
plt.show()

print('选第一个特征值')
a=x[:,:1]
a_train1,a_test1,y_train1,y_test1=train_test_split(a,y,train_size=0.8,random_state=1)
a_train,a_test,y_train,y_test=a_train1,a_test1,y_train1,y_test1
print('训练数据集样本数目：%d，测试数据集样本数目：%d'%(a_train.shape[0],a_test.shape[0]))
clf=GaussianNB()
ir=clf.fit(a_train,y_train)
y_pred=ir.predict(a_test)
acc = np.sum(y_test == y_pred)/a_test.shape[0]
print('测试集准确度：%.3f'% acc)
y_pred = ir.predict(a_train)
acc = np.sum(y_train == y_pred)/a_train.shape[0]
print('训练集准确度：%.3f'% acc)

print('选第二个特征值')
b=x[:,1:2]
b_train1,b_test1,y_train1,y_test1=train_test_split(b,y,train_size=0.8,random_state=1)
b_train,b_test,y_train,y_test=b_train1,b_test1,y_train1,y_test1
print('训练数据集样本数目：%d，测试数据集样本数目：%d'%(b_train.shape[0],b_test.shape[0]))
clf=GaussianNB()
ir=clf.fit(b_train,y_train)
y_pred=ir.predict(b_test)
acc = np.sum(y_test == y_pred)/b_test.shape[0]
print('测试集准确度：%.3f'% acc)
y_pred = ir.predict(b_train)
acc = np.sum(y_train == y_pred)/b_train.shape[0]
print('训练集准确度：%.3f'% acc)

print('选第三个特征值')
c=x[:,2:3]
c_train1,c_test1,y_train1,y_test1=train_test_split(c,y,train_size=0.8,random_state=1)
c_train,c_test,y_train,y_test=c_train1,c_test1,y_train1,y_test1
print('训练数据集样本数目：%d，测试数据集样本数目：%d'%(c_train.shape[0],c_test.shape[0]))
clf=GaussianNB()
ir=clf.fit(c_train,y_train)
y_pred=ir.predict(c_test)
acc = np.sum(y_test == y_pred)/c_test.shape[0]
print('测试集准确度：%.3f'% acc)
y_pred = ir.predict(c_train)
acc = np.sum(y_train == y_pred)/c_train.shape[0]
print('训练集准确度：%.3f'% acc)

print('选第四个特征值')
d=x[:,3:4]
d_train1,d_test1,y_train1,y_test1=train_test_split(d,y,train_size=0.8,random_state=1)
d_train,d_test,y_train,y_test=d_train1,d_test1,y_train1,y_test1
print('训练数据集样本数目：%d，测试数据集样本数目：%d'%(d_train.shape[0],d_test.shape[0]))
clf=GaussianNB()
ir=clf.fit(d_train,y_train)
y_pred=ir.predict(d_test)
acc = np.sum(y_test == y_pred)/d_test.shape[0]
print('测试集准确度：%.3f'% acc)
y_pred = ir.predict(d_train)
acc = np.sum(y_train == y_pred)/d_train.shape[0]
print('训练集准确度：%.3f'% acc)




四、实验结果与分析
1、成功加载鸢尾花数据，并输出样本和特征


2、成功进行数据分割，形成模型训练数据和测试数据，高斯贝叶斯模型构建完成后，可计算预测值并计算准确率


3、取样本前两个特征值，成功计算预测值并计算准确率



4、取样本后两个特征值，成功计算预测值并计算准确率



5、取样本第一个特征值，成功计算预测值并计算准确率

6、取样本第二个特征值，成功计算预测值并计算准确率


7、取样本第三个特征值，成功计算预测值并计算准确率


8、取样本第四个特征值，成功计算预测值并计算准确率


9、当训练样本与测试样本比为3：2时







我们发现前两个特征值误差变大，但后两个特征值的误差没有明显变化。

10、当训练样本与测试样本比为9：1时






我们发现前两个特征值测试误差变大，后两个特征值测试误差变小

11、经过分析发现，前两个特征值对检测结果的误差更大，后两个特征值更适合进行分类。

训练样本与测试样本之间的比重也会在很大程度上影响到测试误差。

注：本人纯粹为了练手熟悉各个方法的用法
使用高斯朴素贝叶斯对鸢尾花数据进行分类
代码：

 1 # 通过朴素贝叶斯对鸢尾花数据进行分类
 2 
 3 from sklearn import datasets
 4 from sklearn.model_selection import train_test_split
 5 from sklearn.naive_bayes import MultinomialNB, GaussianNB
 6 import matplotlib.pyplot as plt
 7 import numpy as np
 8 import matplotlib as mpl
 9 from sklearn.preprocessing import StandardScaler
10 from sklearn.pipeline import Pipeline
11 
12 iris = datasets.load_iris() # 加载鸢尾花数据
13 iris_x = iris.data  # 获取数据
14 # print(iris_x)
15 iris_x = iris_x[:, :2]  # 取前两个特征值
16 # print(iris_x)
17 iris_y = iris.target    # 0， 1， 2
18 x_train, x_test, y_train, y_test = train_test_split(iris_x, iris_y, test_size=0.75, random_state=1) # 对数据进行分类 一部分最为训练一部分作为测试
19 # clf = GaussianNB()
20 # ir = clf.fit(x_train, y_train)
21 clf = Pipeline([
22         ('sc', StandardScaler()),
23         ('clf', GaussianNB())])     # 管道这个没深入理解 所以不知所以然
24 ir = clf.fit(x_train, y_train.ravel())  # 利用训练数据进行拟合
25 
26 # 画图：   
27 x1_max, x1_min = max(x_test[:, 0]), min(x_test[:, 0])   # 取0列特征得最大最小值
28 x2_max, x2_min = max(x_test[:, 1]), min(x_test[:, 1])   # 取1列特征得最大最小值
29 t1 = np.linspace(x1_min, x1_max, 500)   # 生成500个测试点
30 t2 = np.linspace(x2_min, x2_max, 500)   
31 x1, x2 = np.meshgrid(t1, t2)  # 生成网格采样点
32 x_test1 = np.stack((x1.flat, x2.flat), axis=1)
33 y_hat = ir.predict(x_test1) # 预测
34 mpl.rcParams['font.sans-serif'] = [u'simHei']   # 识别中文保证不乱吗
35 mpl.rcParams['axes.unicode_minus'] = False
36 cm_light = mpl.colors.ListedColormap(['#77E0A0', '#FF8080', '#A0A0FF']) # 测试分类的颜色
37 cm_dark = mpl.colors.ListedColormap(['g', 'r', 'b'])    # 样本点的颜色
38 plt.figure(facecolor='w')
39 plt.pcolormesh(x1, x2, y_hat.reshape(x1.shape), cmap=cm_light)  # y_hat  25000个样本点的画图，
40 plt.scatter(x_test[:, 0], x_test[:, 1], edgecolors='k', s=50, c=y_test, cmap=cm_dark)   # 测试数据的真实的样本点（散点） 参数自行百度
41 plt.xlabel(u'花萼长度', fontsize=14)
42 plt.ylabel(u'花萼宽度', fontsize=14)
43 plt.title(u'GaussianNB对鸢尾花数据的分类结果', fontsize=18)
44 plt.grid(True)
45 plt.xlim(x1_min, x1_max)
46 plt.ylim(x2_min, x2_max)
47 plt.show()
48 y_hat1 = ir.predict(x_test)
49 result = y_hat1 == y_test
50 print(result)
51 acc = np.mean(result)
52 print('准确度: %.2f%%' % (100 * acc))

图片显示：

正确率：
　　
 
转载于:https://www.cnblogs.com/bianjing/p/10247173.html

朴素贝叶斯
朴素贝叶斯的介绍
朴素贝叶斯算法（Naive Bayes, NB) 是应用最为广泛的分类算法之一。它是基于贝叶斯定义和特征条件独立假设的分类器方法。由于朴素贝叶斯法基于贝叶斯公式计算得到，有着坚实的数学基础，以及稳定的分类效率。NB模型所需估计的参数很少，对缺失数据不太敏感，算法也比较简单。当年的垃圾邮件分类都是基于朴素贝叶斯分类器识别的。
我们用一句话理解贝叶斯：世间很多事都存在某种联系，假设事件A和事件B。人们常常使用已经发生的某个事件去推断我们想要知道的之间的概率。 例如，医生在确诊的时候，会根据病人的舌苔、心跳等来判断病人得了什么病。对病人来说，只会关注得了什么病，医生会通过已经发生的事件来 确诊具体的情况。这里就用到了贝叶斯思想，A是已经发生的病人症状，在A发生的条件下是B_i的概率。
朴素贝叶斯的应用
朴素贝叶斯算法假设所有特征的出现相互独立互不影响，每一特征同等重要，又因为其简单，而且具有很好的可解释性一般。相对于其他精心设计的更复杂的分类算法，朴素贝叶斯分类算法是学习效率和分类效果较好的分类器之一。朴素贝叶斯算法一般应用在文本分类，垃圾邮件的分类，信用评估，钓鱼网站检测等。
算法实战
鸢尾花数据集-贝叶斯分类
step 1：库函数导入
import warnings
warnings.filterwarnings('ignore') #使系统忽略运行过程中发出的警告
import numpy as np
# 加载莺尾花数据集
from sklearn import datasets
# 导入高斯朴素贝叶斯分类器
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split

step 2: 数据导入&分析
x, y = datasets.load_iris(return_x_y=True)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0)

step 3: 模型训练
# 使用高斯朴素贝叶斯进行计算。
#通过分析发现训练数据是数值类型的数据，这里假设每个特征服从高斯分布，因此我们选择高斯朴素贝叶斯来进行分类计算。
clf = GaussianNB(var_smoothing=1e-8)
clf.fit(X_train, y_train)

step 4: 模型预测
# 评估
y_pred = clf.predict(X_test)
acc = np.sum(y_test == y_pred) / X_test.shape[0]
print("Test Acc : %.3f" % acc)

# 预测
y_proba = clf.predict_proba(X_test[:1])
print(clf.predict(X_test[:1]))
print("预计的概率值:", y_proba)

输出如下：


step 5: 原理简析
高斯朴素贝叶斯假设每个特征都服从高斯分布，我们把一个随机变量X服从数学期望为μ，方差为σ2的数据分布称为高斯分布。对于每个特征我们一般使用平均值来估计μ和使用所有特征的方差估计σ2。



从上述例子中的预测结果中，我们可以看到类别2对应的后验概率值最大，所以我们认为类目2是最优的结果。