精华内容
下载资源
问答
  • 常规操作: import numpy as np import ...min, x2_max) plt.title(u'GaussianNB对鸢尾花数据的分类结果, 正确率:%.3f%%' % (100 * accuracy_score(y_test, y_test_hat)), fontsize=18) plt.grid(True) plt.show()

    常规操作:

    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, MultinomialNB#高斯贝叶斯和多项式朴素贝叶斯

    from sklearn.pipeline import Pipeline

    from sklearn.metrics import accuracy_score

    from sklearn.model_selection import train_test_split

    from sklearn.neighbors import KNeighborsClassifier

    ## 设置属性防止中文乱码

    mpl.rcParams['font.sans-serif'] = [u'SimHei']

    mpl.rcParams['axes.unicode_minus'] = False

    # 花萼长度、花萼宽度,花瓣长度,花瓣宽度

    iris_feature_E = 'sepal length', 'sepal width', 'petal length', 'petal width'

    iris_feature_C = u'花萼长度', u'花萼宽度', u'花瓣长度', u'花瓣宽度'

    iris_class = 'Iris-setosa', 'Iris-versicolor', 'Iris-virginica'

    features = [2,3]

    ## 读取数据

    path = './datas/iris.data' # 数据文件路径

    data = pd.read_csv(path, header=None)

    x = data[list(range(4))]

    x = x[features]

    y = pd.Categorical(data[4]).codes ## 直接将数据特征转换为0,1,2

    print ("总样本数目:%d;特征属性数目:%d" % x.shape)

    总样本数目:150;特征属性数目:2

    数据分割,形成模型训练数据和测试数据

    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]))

    训练数据集样本数目:120, 测试数据集样本数目:30

    高斯贝叶斯模型构建

    clf = Pipeline([

    ('sc', StandardScaler()),#标准化,把它转化成了高斯分布

    ('poly', PolynomialFeatures(degree=1)),

    ('clf', GaussianNB())]) # MultinomialNB多项式贝叶斯算法中要求特征属性的取值不能为负数

    ## 训练模型

    clf.fit(x_train, y_train)

    Pipeline(memory=None,

    steps=[('sc', StandardScaler(copy=True, with_mean=True, with_std=True)), ('poly', PolynomialFeatures(degree=1, include_bias=True, interaction_only=False)), ('clf', GaussianNB(priors=None))])

    计算预测值并计算准确率

    y_train_hat = clf.predict(x_train)

    print ('训练集准确度: %.2f%%' % (100 * accuracy_score(y_train, y_train_hat)))

    y_test_hat = clf.predict(x_test)

    print ('测试集准确度:%.2f%%' % (100 * accuracy_score(y_test, y_test_hat)))

    训练集准确度: 95.83%

    测试集准确度:96.67%

    产生区域图

    N, M = 500, 500 # 横纵各采样多少个值

    x1_min1, x2_min1 = x_train.min()

    x1_max1, x2_max1 = x_train.max()

    x1_min2, x2_min2 = x_test.min()

    x1_max2, x2_max2 = x_test.max()

    x1_min = np.min((x1_min1, x1_min2))

    x1_max = np.max((x1_max1, x1_max2))

    x2_min = np.min((x2_min1, x2_min2))

    x2_max = np.max((x2_max1, x2_max2))

    t1 = np.linspace(x1_min, x1_max, N)

    t2 = np.linspace(x2_min, x2_max, N)

    x1, x2 = np.meshgrid(t1, t2) # 生成网格采样点

    x_show = np.dstack((x1.flat, x2.flat))[0] # 测试点

    cm_light = mpl.colors.ListedColormap(['#77E0A0', '#FF8080', '#A0A0FF'])

    cm_dark = mpl.colors.ListedColormap(['g', 'r', 'b'])

    y_show_hat = clf.predict(x_show) # 预测值

    y_show_hat = y_show_hat.reshape(x1.shape)

    画图

    plt.figure(facecolor='w')

    plt.pcolormesh(x1, x2, y_show_hat, cmap=cm_light) # 预测值的显示

    plt.scatter(x_train[features[0]], x_train[features[1]], c=y_train, edgecolors='k', s=50, cmap=cm_dark)

    plt.scatter(x_test[features[0]], x_test[features[1]], c=y_test, marker='^', edgecolors='k', s=120, cmap=cm_dark)

    plt.xlabel(iris_feature_C[features[0]], fontsize=13)

    plt.ylabel(iris_feature_C[features[1]], fontsize=13)

    plt.xlim(x1_min, x1_max)

    plt.ylim(x2_min, x2_max)

    plt.title(u'GaussianNB对鸢尾花数据的分类结果, 正确率:%.3f%%' % (100 * accuracy_score(y_test, y_test_hat)), fontsize=18)

    plt.grid(True)

    plt.show()

    5d248c0f0f82?spm=a2c4e.11153940.blogcont680519.7.358f3938hY6LDL

    展开全文
  • Task05 基于鸢尾花数据集的贝叶斯分类算法实践 一、学习内容概括 学习资料: 1.阿里云天池-AI训练营机器学习:https://tianchi.aliyun.com/specials/promotion/aicampml?invite_channel=1&accounttraceid=7df...

    Task05 基于鸢尾花数据集的贝叶斯分类算法实践

    一、学习内容概括

    学习资料:

    1.阿里云天池-AI训练营机器学习:https://tianchi.aliyun.com/specials/promotion/aicampml?invite_channel=1&accounttraceid=7df048c2ce194081b514fd2c8e9a3f00cqmm

    2.sklearnAPI:https://scikit-learn.org/stable/modules/classes.html

    二、具体学习内容

    朴素贝叶斯算法原理:

    由上述原理,分析出朴素贝叶斯解决什么问题:

    样本数据集D和对应的特征属性集X可以合二为一形成一个二维数组(样本数n_samples,特征数n_features),我们把这个二维数组称为数据集。原理中提到的类变量Y,我们也形成一个一维数组(样本数n_samples,),我们把这个一维数组称为标签集。从整个数据集中可以再划分出训练集和测试集,标签集也相应划分出训练标签集和测试标签集。

    我们先输入训练集和对应的标签集进行学习,通过学习得到朴素贝叶斯模型。基于模型,输入某个样本X,就可以得到相应的标签预测概率值集P(Y|X)(X条件下Y的概率),这里为什么说是一个值集,因为Y中有很多类别,针对一个样本,属于什么类别,每种类别都有其预测概率值P(Yi|X),有的值大有的值小,其实这个值集在代码中表示就是一个(1,标签数)型的二维数组(当然这是针对一个样本而言,多个样本就是(样本数,标签数))。通过预测结果,我们可以直接看出P(Y|X)中最大的那个概率值,这个概率值对应的类别就是我们想知道的类别Yi。这就是朴素贝叶斯解决的问题。另外,我们把P(Y|X)记为Y的后验概率。

    说到这里还是比较抽象,下面从代码中一步步解读。

    代码流程:

    • Step1: 库函数导入
    • Step2: 数据导入&分析
    • Step3: 模型训练
    • Step4: 模型预测

    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

    1.1 忽略警告信息

    Q:在python中,代码可以正常运行但是会提示警告。

    A:调用warnings模块中警告过滤器filterwarnings()函数忽略警告消息。

    1.2 sklearn.naive_bayes:朴素贝叶斯。其中naive_bayes.GaussianNB(* [,先验,...]):高斯朴素贝叶斯(GaussianNB)

    https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html#sklearn.naive_bayes.GaussianNB

    1.3 sklearn.model_selection:选型。model_selection.train_test_split(*数组,...)用于数据集的分割,分割成训练集和测试集

    https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html#sklearn.model_selection.train_test_split

    2 数据导入&分析

    ## return_X_y默认为False,如果为True,表示返回的是(data,target)
    ## X=data是(样本数,特征数)数组;y=target是(1,标签数)数组
    X, y = datasets.load_iris(return_X_y=True)
    ## X,y是待拆分的数据集;test_size是指将0.2比例的数据集拿出来作为测试集;
    ## random_state默认值为None,不设置则每次复现代码时都会随机分割,如果设置为一个值,那复现代码时会是与本次一样的分割结果
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

    这里可以看一下各个数据的形状:X(150,4)、y(150,)、X_train(120,4)、X_test(30,4)、y_train(120,)、y_test(30,4)。看得出来150*0.2=30。这里的X就是数据集,y就是标签集。X_train和X_test是从X中划分出的训练集、测试集;y_train、y_test是从y中划分出的与X相对应的标签集。

    通过分析发现训练数据是数值类型的数据,这里假设每个特征服从高斯分布,因此我们选择高斯朴素贝叶斯来进行分类计算。高斯朴素贝叶斯假设每个特征都服从高斯分布,我们把一个随机变量X服从数学期望为μ,方差为σ^2的数据分布称为高斯分布。对于每个特征我们一般使用平均值来估计μ和使用所有特征的方差估计σ^2。

    3 模型训练

    # 使用高斯朴素贝叶斯进行计算
    ## var_smoothing:float,默认值= 1e-9。表示所有特征的最大方差部分,已添加到方差中以提高计算稳定性。
    ## var_smoothing是sklearn0.20版中的新功能
    clf = GaussianNB(var_smoothing=1e-8)
    clf.fit(X_train, y_train)

    我们根据X_train和y_train训练出高斯朴素贝叶斯模型。

    通过sklearn.__version__检查sklearn版本,发现是“0.19”,var_smoothing是sklearn0.20版中的新功能,所以var_smoothing不能用。因此我们在控制台更新sklearn版本:pip install scikit-learn==0.23 

    4 模型预测

    # 评估
    ## GaussianNB.predict(X)对测试向量X进行分类,返回X的预测目标值。
    ## 输入(n_samples, n_features)型数组。输出(n_samples,)型数组。
    ## X_test.shape(30,4),y_pred.shape(30,)
    y_pred = clf.predict(X_test)
    print(y_pred.shape[0],"个预测值:",y_pred)
    
    ## 测试集标签值y_test与估计值y_pred比较,共30个测试样本。得到一个正确率acc
    acc = np.sum(y_test == y_pred) / X_test.shape[0]
    print("Test Acc : %.3f" % acc)

    输出结果:

    30 个预测值: [2 1 0 2 0 2 0 1 1 1 1 1 1 1 1 0 1 1 0 0 2 1 0 0 2 0 0 1 1 0]
    Test Acc : 0.967

    通过训练得到的模型,在测试集上表现不错,正确率达到96.7%。

    基于训练好的模型,对X_test进行一个预测,与y_test对比来对模型进行一个评估。

    # 预测
    ## GaussianNB.predict_proba(X)对测试向量X的概率估计。输入、输出都是(n_samples, n_features)型数组,
    ## X_test[:1]数组切片,只取一行样本
    y_proba = clf.predict_proba(X_test[:1])
    
    print("\n测试样本",X_test[:1],"的预测类别为:",clf.predict(X_test[:1]))
    print("\n测试样本",X_test[:1],"的预测概率为:\n",y_proba)

     输出结果:

    测试样本 [[5.8 2.8 5.1 2.4]] 的预测类别为: [2]
    
    测试样本 [[5.8 2.8 5.1 2.4]] 的预测概率为:
     [[1.63542393e-232 2.18880483e-006 9.99997811e-001]]

    输入一个样本,不光可以根据predict()函数直接得到其预测类别,还可以根据predict_proba()函数看到针对每一种类别/标签,预测的概率都是多少,几个预测概率值相比较,最大的那个预测值9.99997811e-001对应的类别[2]就是我们想要的类别,也就是predict()函数直接预测到的那个。

    重复一遍朴素贝叶斯的功能,就是输入样本,根据学习好的模型进行预测,预测出样本属于几种类别的概率,其中,几种类别预测概率值中最大的那个对应的类别就是我们想要的类别Yi。也就是说事件X最有可能的结果是Yi。

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

    三、学习总结

    sklearn对朴素贝叶斯算法进行了封装,我们就像在使用一个黑盒子。这个例子只是展示了贝叶斯算法的使用,并没有展现算法的具体细节。

     

    展开全文
  • 机器学习之鸢尾花-朴素贝叶斯方法

    千次阅读 2021-02-12 15:07:01
    在所有的机器学习分类算法中,朴素贝叶斯和其他绝大多数的分类算法都不同。 对于大多数的分类算法,比如决策树,KNN,逻辑回归,支持向量机等,他们都是判别方法,也就是直接学习出特征输出Y和特征X之间的关系,要么是...

    在所有的机器学习分类算法中,朴素贝叶斯和其他绝大多数的分类算法都不同。 对于大多数的分类算法,比如决策树,KNN,逻辑回归,支持向量机等,他们都是判别方法,也就是直接学习出特征输出Y和特征X之间的关系,要么是决策函数Y=f(X),要么是条件分布P(Y|X)。 朴素贝叶斯方法是基于贝叶斯定理的一组有监督学习算法,即“简单”地假设每对特征之间相互独立,也就是直接找出特征输出Y和特征X的联合分布P(X,Y),然后用P(Y|X)=P(X,Y)/P(X)得出。 朴素贝叶斯很直观,计算量也不大,在很多领域有广泛的应用 在scikit-learn中,一共有3个朴素贝叶斯的分类算法类。 分别是GaussianNB,MultinomialNB和BernoulliNB。 其中GaussianNB就是先验为高斯分布的朴素贝叶斯, MultinomialNB就是先验为多项式分布的朴素贝叶斯, 而BernoulliNB就是先验为伯努利分布的朴素贝叶斯。 就鸢尾花例子而言,高斯朴素贝叶斯的准确率>多项分布朴素贝叶斯准确率>伯努利朴素贝叶斯准确率,大概和数据的分布情况有关,后续专门再针对性的评估和学习一下 如下:

    # 在所有的机器学习分类算法中,朴素贝叶斯和其他绝大多数的分类算法都不同。

    # 对于大多数的分类算法,比如决策树,KNN,逻辑回归,支持向量机等,他们都是判别方法,也就是直接学习出特征输出Y和特征X之间的关系,要么是决策函数Y=f(X),要么是条件分布P(Y|X)。

    # 朴素贝叶斯方法是基于贝叶斯定理的一组有监督学习算法,即“简单”地假设每对特征之间相互独立,也就是直接找出特征输出Y和特征X的联合分布P(X,Y),然后用P(Y|X)=P(X,Y)/P(X)得出。

    # 朴素贝叶斯很直观,计算量也不大,在很多领域有广泛的应用

    # 在scikit-learn中,一共有3个朴素贝叶斯的分类算法类。

    # 分别是GaussianNB,MultinomialNB和BernoulliNB。

    #     其中GaussianNB就是先验为高斯分布的朴素贝叶斯,

    #     MultinomialNB就是先验为多项式分布的朴素贝叶斯,

    #     而BernoulliNB就是先验为伯努利分布的朴素贝叶斯。

    # GaussianNB类参数

    #     GaussianNB类的主要参数仅有一个,即先验概率priors,对应Y的各个类别的先验概率P(Y=Ck)。

    #         这个值默认不给出,如果不给出此时P(Y=Ck)=mk/m。

    #         其中m为训练集样本总数量,mk为输出为第k类别的训练集样本数。

    #         如果给出的话就以priors 为准。

    #     在使用GaussianNB的fit方法拟合数据后,我们可以进行预测。

    #         此时预测有三种方法,包括predict,predict_log_proba和predict_proba。

    #         GaussianNB一个重要的功能是有 partial_fit方法,这个方法的一般用在如果训练集数据量非常大,一次不能全部载入内存的时候。

    #         这时我们可以把训练集分成若干等分,重复调用partial_fit来一步步的学习训练集

    # MultinomialNB类参数

    #     MultinomialNB参数比GaussianNB多,但是一共也只有仅仅3个。

    #         其中,参数alpha即为上面的常数λ,如果你没有特别的需要,用默认的1即可。

    #         如果发现拟合的不好,需要调优时,可以选择稍大于1或者稍小于1的数。

    #         布尔参数fit_prior表示是否要考虑先验概率,如果是false,则所有的样本类别输出都有相同的类别先验概率。

    #         否则可以自己用第三个参数class_prior输入先验概率,或者不输入第三个参数class_prior让MultinomialNB自己从训练集样本来计算先验概率,此时的先验概率为P(Y=Ck)=mk/m。

    #         其中m为训练集样本总数量,mk为输出为第k类别的训练集样本数。

    # BernoulliNB类参数

    #     BernoulliNB一共有4个参数,其中3个参数的名字和意义和MultinomialNB完全相同。

    #         唯一增加的一个参数是binarize。

    #         这个参数主要是用来帮BernoulliNB处理二项分布的,可以是数值或者不输入。

    #         如果不输入,则BernoulliNB认为每个数据特征都已经是二元的。

    #         否则的话,小于binarize的会归为一类,大于binarize的会归为另外一类。

    from sklearn.naive_bayes import GaussianNB,MultinomialNB,BernoulliNB

    def test_naive_bayes(X_train, X_test, y_train, y_test,X,y):

    # 训练数据和测试数据进行标准化

    # sc = StandardScaler()

    # X_train = sc.fit_transform(X_train)

    # X_test = sc.transform(X_test)

    scores_train=[]

    scores_test=[]

    names= ['GaussianNB', 'MultinomialNB', 'BernoulliNB' ]

    classifiers = [

    GaussianNB(),

    MultinomialNB(),

    BernoulliNB()

    ]

    h=0.02

    X= X[:,:2]

    #X = StandardScaler().fit_transform(X)

    # X_train = StandardScaler().fit_transform(X_train)

    # X_test = StandardScaler().fit_transform(X_test)

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42)

    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5

    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5

    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),

    np.arange(y_min, y_max, h))

    # just plot the dataset first

    #cmap_light = ListedColormap(['#AAAAFF', '#AAFFAA', '#FFAAAA'])  # 给不同区域赋以颜色

    #cmap_bold = ListedColormap(['#FF0000', '#003300', '#0000FF'])  # 给不同属性的点赋以颜色

    cmap_bold = ListedColormap(['#AAAAFF', '#AAFFAA', '#FFAAAA'])  # 给不同区域赋以颜色

    cmap_light = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])  # 给不同属性的点赋以颜色

    plt.figure(figsize=(10,6))

    plt.title("Input data")

    plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cmap_light,edgecolors='k')

    # Plot the testing points

    plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cmap_light, alpha=0.5,edgecolors='k')

    plt.xlim(xx.min(), xx.max())

    plt.ylim(yy.min(), yy.max())

    plt.xticks(())

    plt.yticks(())

    plt.show()

    i=1

    136be34314a57ba454d97dfa8ef5d707.png

    figure = plt.figure(figsize=(10, 6))

    for name, clf in zip(names, classifiers):

    ax = plt.subplot(2, 2, i)

    clf.fit(X_train, y_train)

    score = clf.score(X_test, y_test)

    print('模型名称:{},得分={}'.format(name,score))

    # 模型名称:GaussianNB,得分=0.8333333333333334

    # 模型名称:MultinomialNB,得分=0.4666666666666667

    # 模型名称:BernoulliNB,得分=0.3

    #Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]

    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

    Z = Z.reshape(xx.shape)

    ax.contourf(xx, yy, Z, cmap=cmap_bold, alpha=.6)

    #plt.pcolormesh(xx, yy, Z, cmap=cmap_bold, alpha=.6)

    # Plot the training points

    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cmap_light,edgecolors='k')

    # Plot the testing points

    ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cmap_light,edgecolors='k', alpha=0.6)

    ax.set_xlim(xx.min(), xx.max())

    ax.set_ylim(yy.min(), yy.max())

    ax.set_xticks(())

    ax.set_yticks(())

    ax.set_title(name)

    ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'), size=15, horizontalalignment='right')

    i=i+1

    plt.show()

    if __name__=='__main__':

    X_train,X_test,y_train,y_test,X,y=load_data(iris)

    # -----------------------逻辑回归--------------------------------

    # test_LogisticRegression(X_train,X_test,y_train,y_test)

    # test_LogisticRegression_C(X_train, X_test, y_train, y_test)

    # test_LogisticRegression_Cpenaltyssolvers(X_train, X_test, y_train, y_test)

    # test_LogisticRegression_Cmulti_classsolvers(X_train, X_test, y_train, y_test)

    # test_LogisticRegression_penaltyssolvers(X_train, X_test, y_train, y_test)

    # test_LogisticRegression_multi_classssolvers(X_train, X_test, y_train, y_test)

    # test_LogisticRegression_best(X_train, X_test, y_train, y_test)

    # ---------------------K近邻算法-----------------------

    #test_KNeighborsClassifier(X_train, X_test, y_train, y_test, X, y)

    # ------------------朴素贝叶斯-----------------------

    # 高斯朴素贝叶斯

    # 多项分布朴素贝叶斯

    # 伯努利朴素贝叶斯

    test_naive_bayes(X_train, X_test, y_train, y_test, X, y)

    # ---------------------决策树-----------------------

    # ---------------------K Means聚类-----------------------

    # ------------------高斯混合模型聚类-----------------------

    # -------------------SVM支撑向量机-----------------------

    展开全文
  • 朴素贝叶斯算法写的关于鸢尾花分类的程序,有需要的可以自己下载修改使用.
  • 前面我们已经详细介绍过鸢尾花数据集以及sklearn的使用,下面我们就来调用sklearn中的贝叶斯分类器来实现鸢尾花数据集的分类。 首先,我们需要导入需要用到的包,模型以及数据集 import numpy as np # 导入sklearn...

    前面我们已经详细介绍过鸢尾花数据集以及sklearn的使用,下面我们就来调用sklearn中的贝叶斯分类器来实现鸢尾花数据集的分类。

    1. 首先,我们需要导入需要用到的包,模型以及数据集
    import numpy as np
    # 导入sklearn中有关于数据集的包
    from sklearn import datasets
    # 导入高斯朴素贝叶斯分类器
    from sklearn.naive_bayes import GaussianNB
    from sklearn.model_selection import train_test_split
    # 加载鸢尾花特征数据及其标签
    # 当load_iris函数中的参数return_X_y=True,函数会返回前面介绍的鸢尾花数据集中的data和target
    X, y = datasets.load_iris(return_X_y=True)
    

    sklearn.datasets.load_iris函数

    1. 样本划分,将数据划分为训练集和测试集
    # train_test_split函数用于划分数据集,按照test_size=0.2,将80%的数据划分为训练集,20%的数据划分为测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
    
    1. 导入定义的高斯朴素贝叶斯模型,并利用训练集数据进行训练
    # 定义模型,给出模型的相关参数,该参数在sklearn 0.20以上的版本才有,低于此版本的sklearn会报错
    clf = GaussianNB(var_smoothing=1e-8)
    # 利用训练数据训练定义好的模型
    clf.fit(X_train, y_train)
    
    # GaussianNB(var_smoothing=1e-08)
    

    sklearn.naive_bayes.GaussianNB

    1. 利用训练好的模型进行预测
    # 利用模型对测试集进行预测
    y_pred = clf.predict(X_test)
    # 评判模型预测的准确率(真确预测的个数/测试样本总个数)
    acc = np.sum(y_test == y_pred) / X_test.shape[0]
    # 打印准确率
    print("Test Acc : %.3f" % acc)
    
    # Test Acc : 0.967
    

    可以看到模型在测试集上的准确率为96.7%

    1. 我们挑选测试集中的一个样本来看看具体情况
    # predict_proba函数分别计算该样本属于每一类的概率,概率总和为1
    y_proba = clf.predict_proba(X_test[:1])
    # 打印测试集第一个样本的预测结果
    print(clf.predict(X_test[:1]))
    # 打印测试集第一个样本分别属于每一类的概率
    print("预计的概率值:", y_proba)
    
    # [2]
    # 预计的概率值: [[1.63542393e-232 2.18880483e-006 9.99997811e-001]]
    

    可以看到模型预测出测试集第一个样本标签为第二类的可能性更大,且输出的标签也是2

    1. 我们来看一下测试集第一个样本的真实标签是多少
    print(y_test[:1])
    
    # [2]
    

    可以看到预测结果和真实结果是一致的。

    至此,我们就完成了利用鸢尾花数据训练贝叶斯分类器的过程。

    展开全文
  • 基于贝叶斯鸢尾花数据进行分类 1. python3.7 2. numpy >= '1.16.4' 3. sklearn >= '0.23.1' # import base package import warnings warnings.filterwarnings('ignore') import numpy as np from ...
  • 基于鸢尾花数据集实战贝叶斯分类

    千次阅读 2020-12-23 23:59:04
    鸢尾花数据集–贝叶斯分类 Step1:库函数导入 import warnings warnings.filterwarnings('ignore') import numpy as np # 加载莺尾花数据集 from sklearn import datasets # 导入高斯朴素贝叶斯分类器 from sklearn....
  • 利用决策树,KNN和朴素贝叶斯三种分类器,对鸢尾花数据集进行分类。下面是具体的流程和代码:1、 数据读取:实验数据是直接加载的sklearn内置的鸢尾花数据集,共150条数据,包含4个特征,而且是一个三分类问题。from...
  • (3) 使用朴素贝叶斯处理鸢尾花数据集分类 二、实验内容 (1)导入库,加载鸢尾花数据,输出样本和鸢尾花特征 (2)数据分割,数据分割,形成模型训练数据和测试数据 (3)高斯贝叶斯模型构建 (4)计算预测值并计算...
  • 朴素贝叶斯算法原理及鸢尾花分类代码实现 一、概率模型 1、全概率公式(由因推果) 设事件B1,B2,…,Bn构成一个完备事件组,即两两不相容,和为全集且P(Bi)>0,则对任意事件A,有 由因推果的理解:如上图:可以理解...
  • 贝叶斯方法完整代码 import seaborn as sns iris = sns.load_dataset('iris') X_iris = iris.drop('species', axis=1) y_iris = iris['species'] print(X_iris) from sklearn.cross_validation import train_test_...
  • 本文主要讲解朴素贝叶斯及其推理,并实现鸢尾花数据的分类问题 2、算法解释 朴素贝叶斯最初来源于统计科学领域。根据朴素贝叶斯公式: 由于类似然涉及到多个特征的组合求解较为困难。所以为了简化运算,降低...
  • 鸢尾花分类(四种方法)

    千次阅读 2021-05-23 08:54:17
    鸢尾花分类 iris数据集的中文名是安德森鸢尾花卉数据集,含有5个key,分别是DESCT,target_name(分类名称,即四个特征值的名称),target(分类,有150个数值,有(0,1,2)三种取值,分别代表三个种类),...
  • 主要介绍了python KNN算法实现鸢尾花数据集分类,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • import numpy as np import pandas as pd import matplotlib.pyplot as plt import matplotlib as mpl ...from sklearn.naive_bayes import GaussianNB, MultinomialNB#高斯贝叶斯和多项式朴素贝叶斯 from
  • 使用的贝叶斯分类算法实现的,编程语言为java。是我本学期修的数据库与数据挖掘的课程的期末课程作业,算法本身不难,思路理清楚了很简单。先看看鸢尾花(Iris)数据集(下图为数据集的部分截图),鸢尾花有setosa、...
  • 朴素贝叶斯算法(Naive Bayes, NB) 是应用最为广泛的分类算法之一。它是基于贝叶斯定义和特征条件独立假设的分类器方法。由于朴素贝叶斯法基于贝叶斯公式计算得到,有着坚实的数学基础,以及稳定的分类效率。NB模型...
  • import pandas as pdfrom sklearn.naive_bayes import GaussianNBfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_scorefrom sklearn import datasetsiris=datasets.lo....
  • 第一个应用:鸢尾花分类需要的几个python库scikit-learn:两个 Python 包:NumPy 和 SciPy。NumPy包括多维数组、高级数学函数(比如线性代数运算和傅里叶变换),以及伪随机数生成器。SciPy具有线性代数高级程序、数学...
  • 鸢尾花数据集8:2划分训练集和测试集,并进行决策树分类算法练习Graphviz的安装训练集、测试集的划分输出训练模型可视化树状图训练模型的精度F1-Score测试集的精度F1-Score遇到的问题 针对鸢尾花数据集,按照80%训练...
  • 今天小编就为大家分享一篇Python sklearn库实现PCA教程(以鸢尾花分类为例),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 决策树,人工神经网络,朴素贝叶斯,对比分类
  • 鸢尾花用ID3算法

    2018-03-27 17:34:27
    建立决策树模型基于R软件,利用DI3算法,利用鸢尾花数据
  • 使用高斯朴素贝叶斯鸢尾花数据进行分类 代码: 1 # 通过朴素贝叶斯鸢尾花数据进行分类 2 3 from sklearn import datasets 4 from sklearn.model_selection import train_test_split 5 from ...
  • 从读取文件、去除重用词、正则化、到词向量、再到预测分类。最后ROC曲线评估,一整套(带数据集),下载即运行。如果好用,还请给个好评
  • 自编程实现朴素贝叶斯算法,Navie Bayes程序(python),并对鸢尾花数据进行分类。 目录自编程实现朴素贝叶斯算法,Navie Bayes程序(python),并对鸢尾花数据进行分类。朴素贝叶斯完整程序代码运行结果实现过程及...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,385
精华内容 554
关键字:

鸢尾花贝叶斯分类算法