精华内容
下载资源
问答
  • Wine数据集

    2018-11-12 22:48:24
    UCI标准数据集中的Wine数据集,可以用来数据分析或机器学习
  • wine数据集

    2017-12-25 14:59:02
    数据集共3个类别,178个样本,每个样本13个特征,还不够50字节的吗?
  • UCI Wine 数据集原始数据
  • wine数据集及其描述

    2021-02-08 10:00:20
    UCI机器学习库中的wine数据集及其描述 UCI机器学习库中的wine数据集及其描述 UCI机器学习库中的wine数据集及其描述 UCI机器学习库中的wine数据集及其描述
  • 使用逻辑回归和贝叶斯算法对wine数据集进行分类。包含wine数据集,源代码,实验报告及控制台可执行程序。
  • 《数据仓库与数据挖掘》课程论文, R语言基于wine数据集的数据分析报告
  • UCI 机器学习Wine数据集

    热门讨论 2012-09-04 08:20:25
    UCI Wine 数据集是机器学习标准的公用数据集
  • wine数据集可直接调用

    2011-05-13 20:00:22
    UCI数据集中的wine 数据集 已经整理成可直接利用Malab调用格式
  • Wine is a program which allows running Microsoft Windows programs (including DOS, Windows 3.x, Win32, and Win64 executables) on Unix. It consists of a program loader which loads and executes a ...
  • Python----数据分析-使用scikit-learn构建模型实训(wine数据集、wine_quality数据) 目录: 实训1 使用 sklearn处理wine和wine_quality数据集 实训2 构建基于wine数据集的k- Means聚类模型 实训3 构建基于wine数据...

    Python----数据分析-使用scikit-learn构建模型实训(wine数据集、wine_quality数据)


    目录:

    实训1 使用 sklearn处理wine和wine_quality数据集
    实训2 构建基于wine数据集的k- Means聚类模型
    实训3 构建基于wine数据集的SVM分类模型
    实训4 构建基于wine_quality数据集的回归模型


    wine数据集包含来自3种不同起源的葡萄酒的共178条记录。13个属性是葡萄酒的13种化学成分。通过化学分析可以来推断葡萄酒的起源。值得一提的是所有属性变量都是连续变量。


    实训1 使用 sklearn处理wine和wine_quality数据集

    1.训练要点

    • 掌握 sklearn转换器的用法。
    • 掌握训练集、测试集划分的方法。
    • 掌握使用sklearn进行PCA降维的方法。

    2.需求说明

    • wine数据集和 winequality数据集是两份和酒有关的数据集。wine数据集包含3种 同起源的葡萄酒的记录,共178条。其中,每个特征对应葡萄酒的每种化学成分,并且都 属于连续型数据。通过化学分析可以推断葡萄酒的起源。
    • winequality数据集共有4898个观察值,11个输入特征和一个标签。其中,不同类的
      观察值数量不等,所有特征为连续型数据。通过酒的各类化学成分,预测该葡萄酒的评分

    3.实现思路及步骤

    • 使用pandas库分别读取wine数据集和 winquality数据集
    • 将wine数据集和winequality数据集的数据和标签拆分开(提取)
    • 将winequality数据集划分为训练集和测试集。
    • 标准化wine数据集和 wine quality数据集
    • 对wine数据集和 winequality数据集进行PCA降维

    import pandas as pd
    
    // 读取数据
    wine_quality = pd.read_csv('data/winequality.csv',sep=';')
    wine = pd.read_csv('data/wine.csv')
    print(type(wine),type(wine_quality))
    //<class 'pandas.core.frame.DataFrame'> <class 'pandas.core.frame.DataFrame'>
    
    // 提取 wine_quality 数据
    wine_quality_data = wine_quality.iloc[:,:-1]
    wine_quality_target = wine_quality['quality']
    // 提取 wine 数据
    wine_data = wine.iloc[:,:-1]
    wine_target = wine['Class']
    

    wine数据集和winequality数据集的表现形式不一样,这里的wine数据集可以直接读入,而winequality数据集在文件中是以”;”为间隔的,所以要采用间隔读入的方式获取其数据。读取后数据都以DataFrame的类型保留,使用iloc等切片操作提取所需数据。
    在这里插入图片描述

    // 将 wine_quality 数据划分为训练集和测试集
    from sklearn.model_selection import train_test_split
    
    wine_quality_data_train,wine_quality_data_test,\
    wine_quality_target_train,wine_quality_target_test=\
    train_test_split(wine_quality_data,wine_quality_target,test_size=0.2,random_state=321)
    
    wine_data_train,wine_data_test,\
    wine_target_train,wine_target_test=\
    train_test_split(wine_data,wine_target,test_size=0.2,random_state=321)
    

    在这里插入图片描述
    train_test_split()函数将数据集划分为训练集和测试集两部分,参数test_size=0.2代表着测试集在总数中的占比,通过计算wine_data总共178条记录,wine_data_test有36条,占0.20224171(20%),参数random_state=321,表示随机种子编号,方便测试时得到相同随机结果。

    // 标准化数据集
    from sklearn.preprocessing import StandardScaler
    
    stdScaler = StandardScaler().fit(wine_data_train) // 生成标准化规则
    wine_trainScaler = stdScaler.transform(wine_data_train) // 对训练集标准化
    wine_testScaler = stdScaler.transform(wine_data_test) // 用训练集建立的模型对测试集标准化
    
    Scaler = StandardScaler().fit(wine_quality_data_train) // 生成标准化规则
    winequality_trainScaler = Scaler.transform(wine_quality_data_train) // 对训练集标准化
    winequality_testScaler = Scaler.transform(wine_quality_data_test) // 用训练集建立的模型对测试集标准化
    

    这里有个顺序:生成标准化规则;对训练集标准化;用训练集建立的模型对测试集标准化
    主要是因为在数据分析的时候,各类特征处理相关的操作都需要对训练集和测试集分开进行,同时需要将训练集的操作规则、权重系数等应用到测试集中。这也就是为什么生成规则时fit传入训练集。transform函数紧接着将定义好的规则应用对传入的特征进行对应转换。

    // PCA降维
    from sklearn.decomposition import PCA
    
    pca_model = PCA(n_components=5).fit(wine_trainScaler) // 生成PCA规则
    wine_trainpca = pca_model.transform(wine_trainScaler) // 将规则应用到训练集
    wine_testpca = pca_model.transform(wine_testScaler)   // 将规则应用到测试集 
    
    pca_model = PCA(n_components=5).fit(winequality_trainScaler) // 生成PCA规则
    winequality_trainpca = pca_model.transform(winequality_trainScaler) // 将规则应用到训练集
    winequality_testpca = pca_model.transform(winequality_testScaler)   #// 将规则应用到测试集
    

    PCA(n_components=5)的参数n_components表示将原始数据降低到n个维度。

    返回顶部


    实训2 构建基于wine数据集的k- Means聚类模型

    1.训练要点

    • 了解sklearn估计器的用法。
    • 掌握聚类模型的构建方法。
    • 掌握聚类模型的评价方法。

    2.需求说明

    • wine数据集的葡萄酒总共分为3种,通过将wine数据集的数据进行聚类,聚集为3 个簇,能够实现葡萄酒的类别划分。

    3.实现思路及步骤

    • 根据实训1的wine数据集处理的结果,构建聚类数目为3的- -Means模型
    • 对比真实标签和聚类标签求取FMI
    • 聚类数目为2~10类时,确定最优聚类数目。
    • 求取模型的轮廓系数,绘制轮廓系数折线图,确定最优聚类数目。
    • 取 Calinski-Harabasz-指数,确定最优聚类数目。
    // 构建 K-Means 模型
    from sklearn.cluster import KMeans
    
    kmeans = KMeans(n_clusters=3,random_state=32).fit(wine_trainScaler) //构建训练模型
    print('wine_trainScaler构建的模型为:\n',kmeans)
    //wine_trainScaler构建的模型为:
     KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,
           n_clusters=3, n_init=10, n_jobs=None, precompute_distances='auto',
           random_state=32, tol=0.0001, verbose=0)
    

    在这里插入图片描述

    构建K-Means聚类模型,参数n_clusters=3表示要形成的团簇数目,也就是分为几类,这里是分为3类。

    // 对比真实标签和聚类标签求取FMI
    from sklearn.metrics import fowlkes_mallows_score //FMI评价法
    
    score=fowlkes_mallows_score(wine_target_train,kmeans.labels_)
    print("wine数据集的FMI:%f"%(score))
    //wine数据集的FMI:0.901648
    
    //在聚类数目为2~10类时,确定最优聚类数目
    from sklearn.metrics import fowlkes_mallows_score
    from sklearn.cluster import KMeans
    
    for i in range(2,11):
        kmeans = KMeans(n_clusters=i,random_state=32).fit(wine_trainScaler)
        score = fowlkes_mallows_score(wine_target_train,kmeans.labels_)
        print('wine聚%d类FMI评价分为:%f'%(i,score))
    
    wine聚2FMI评价分为:0.693972
    wine聚3FMI评价分为:0.901648
    wine聚4FMI评价分为:0.801280
    wine聚5FMI评价分为:0.775956
    wine聚6FMI评价分为:0.782225
    wine聚7FMI评价分为:0.607152
    wine聚8FMI评价分为:0.570184
    wine聚9FMI评价分为:0.567783
    wine聚10FMI评价分为:0.559720
    

    在这里插入图片描述

    // 求取模型的轮廓系数,绘制轮廓系数折线图,确定最优聚类数目
    from sklearn.metrics import silhouette_score
    import matplotlib.pyplot as plt
    silhouettteScore = []
    for i in range(2,11):
        // 构建并训练模型
        kmeans = KMeans(n_clusters = i,random_state=1).fit(wine)
        score = silhouette_score(wine,kmeans.labels_)
        silhouettteScore.append(score)
    plt.figure(figsize=(10,6))
    plt.plot(range(2,11),silhouettteScore,linewidth=1.5, linestyle="-")
    plt.show()
    

    在这里插入图片描述
    求取模型的轮廓系数:
    在这里插入图片描述

    //求取 Calinski-Harabasz指数,确定最优聚类数
    from sklearn.metrics import calinski_harabasz_score
    for i in range(2,11):
        // 构建并训练模型
        kmeans = KMeans(n_clusters = i,random_state=1).fit(wine_trainScaler)
        score = calinski_harabaz_score(wine_trainScaler,kmeans.labels_)
        print('seeds数据聚%d类calinski_harabaz指数为:%f'%(i,score))
    
    seeds数据聚2类calinski_harabaz指数为:67.189882
    seeds数据聚3类calinski_harabaz指数为:62.785275
    seeds数据聚4类calinski_harabaz指数为:49.058796
    seeds数据聚5类calinski_harabaz指数为:41.101132
    seeds数据聚6类calinski_harabaz指数为:36.321948
    seeds数据聚7类calinski_harabaz指数为:34.295581
    seeds数据聚8类calinski_harabaz指数为:31.101151
    seeds数据聚9类calinski_harabaz指数为:28.693663
    seeds数据聚10类calinski_harabaz指数为:28.563627
    

    分析FMI评价分值,可以看出wine数据分3类的时候其FMI值最高,故聚类为3类的时候wine数据集K-means聚类效果最好
    分析轮廓系数折线图,可以看出在wine数据集为3的时候,其平均畸变程度最大,故亦可知聚类为3类的时候效果最佳

    返回顶部


    实训3 构建基于wine数据集的SVM分类模型

    1.训练要点

    • 掌握sklearn估计器的用法。
    • 掌握分类模型的构建方法。
    • 掌握分类模型的评价方法。

    2.需求说明

    • wine数据集中的葡萄酒类别为3种,将wie数据集划分为训练集和测试集,使用训练 集训练SVM分类模型,并使用训练完成的模型预测测试集的葡萄酒类别归属。

    3.实现思路及步骤

    • 读取wine数据集,区分标签和数据。
    • 将wine数据集划分为训练集和测试集
    • 使用离差标准化方法标准化wine数据集。
    • 构建SVM模型,并预测测试集结果
    • 打印出分类报告,评价分类模型性能。
    import pandas as pd
    
    // 读取数据
    wine_quality = pd.read_csv('data/winequality.csv',sep=';')
    wine = pd.read_csv('data/wine.csv')
    // 提取 wine_quality 数据
    wine_quality_data = wine_quality.iloc[:,:-1]
    wine_quality_target = wine_quality['quality']
    // 提取 wine 数据
    wine_data = wine.iloc[:,:-1]
    wine_target = wine['Class']
    
    from sklearn.model_selection import train_test_split
    from sklearn.svm import SVC
    from sklearn.preprocessing import MinMaxScaler
    
    // 划分训练集、测试集
    wine_data_train,wine_data_test,wine_target_train,wine_target_test=\
    train_test_split(wine_data,wine_target,test_size=0.2,random_state=123)
    
    // 数据标准化规则
    Scaler = MinMaxScaler().fit(wine_data_train)
    // 应用规则
    wine_trainScaler = Scaler.transform(wine_data_train) // 对训练集进行标准化
    wine_testScaler = Scaler.transform(wine_data_test)    // 用训练集训练的模型对测试集标准化
    
    // 构建SVM分类模型
    svm = SVC().fit(wine_trainScaler,wine_target_train)
    print("建立的SVM模型为:\n",svm)
    //建立的SVM模型为:
     SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,
        decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
        max_iter=-1, probability=False, random_state=None, shrinking=True,
        tol=0.001, verbose=False)
                                       
    // 预测训练结果
    wine_target_pred = svm.predict(wine_testScaler)   
    print('预测前20个结果为:',wine_target_pred[:20])
    //预测前20个结果为: [3 2 3 2 2 3 1 3 3 2 3 3 3 1 1 3 2 2 1 2]
    
    // 打印模型评价报告
    from sklearn.metrics import classification_report
    print('使用SVM预测数据的分析报告为:\n',classification_report(wine_target_test,wine_target_pred))
    //使用SVM预测数据的分析报告为:
                   precision    recall  f1-score   support
    
               1       1.00      1.00      1.00         8
               2       1.00      1.00      1.00        11
               3       1.00      1.00      1.00        17
    
        accuracy                           1.00        36
       macro avg       1.00      1.00      1.00        36
    weighted avg       1.00      1.00      1.00        36
    

    返回顶部


    实训4 构建基于wine_quality数据集的回归模型

    1.训练要点
    (1)熟练sklearn估计器的用法。
    (2)掌握回归模型的构建方法。
    (3)掌握回归模型的评价方法。

    2.需求说明

    • winequality数据集的葡萄酒评分在1~10之间,建线性回归模型与梯度提升回归模 型,训练 winequality数据集的训练集数据,训练完成后预测测试集的葡萄酒评分。结合 真实评分,评价构建的两个回归模型的好坏。

    3.实现思路及步骤

    • 根据winequality数据集处理的结果,构建线性回归模型
    • 根据wine quality数据集处理的结果,构建梯度提升回归模型
    • 结合真实评分和预测评分,计算均方误差中值绝对误差、可解释方差值
    • 根据得分,判定模型的性能优劣。
    // 构建线性回归模型
    from sklearn.linear_model import LinearRegression
    
    clf = LinearRegression().fit(winequality_trainpca,wine_quality_target_train)
    y_pred = clf.predict(winequality_testpca)
    print('线性回归模型预测前10个结果为:','\n',y_pred[:10])
    线性回归模型预测前10个结果为: 
     [5.27204611 5.16410891 6.93394979 6.52520955 5.56143289 5.02815869
     5.17867439 5.95768188 5.68991275 5.33085457]
    
    // 根据wine_quality数据集处理的结果,构建梯度提升回归模型。
    from sklearn.ensemble import GradientBoostingRegressor
    
    gbr_wine = GradientBoostingRegressor().fit(winequality_trainpca,wine_quality_target_train)
    wine_target_pred = gbr_wine.predict(winequality_testpca)
    print('梯度提升回归模型预测前10个结果为:','\n',wine_target_pred[:10])
    print('真实标签前10个预测结果为:','\n',list(wine_quality_target_test[:10]))
    梯度提升回归模型预测前10个结果为: 
     [5.4569842  5.1020336  6.39325331 6.55163291 5.62504565 5.16770619
     5.22503393 5.6942301  5.43575267 5.22052962]
    真实标签前10个预测结果为: 
     [6, 5, 6, 7, 6, 6, 5, 6, 6, 5]
    
    from sklearn.metrics import mean_absolute_error,mean_squared_error,median_absolute_error,explained_variance_score,r2_score
    
    print('线性回归模型评价结果:')
    print('winequality数据线性回归模型的平均绝对误差为:',
         mean_absolute_error(wine_quality_target_test,y_pred))
    print('winequality数据线性回归模型的均方误差为:',
         mean_squared_error(wine_quality_target_test,y_pred))
    print('winequality数据线性回归模型的中值绝对误差为:',
         median_absolute_error(wine_quality_target_test,y_pred))
    print('winequality数据线性回归模型的可解释方差值为:',
         explained_variance_score(wine_quality_target_test,y_pred))
    print('winequality数据线性回归模型的R方值为:',
         r2_score(wine_quality_target_test,y_pred))
    
    线性回归模型评价结果:
    winequality数据线性回归模型的平均绝对误差为: 0.500442590483755
    winequality数据线性回归模型的均方误差为: 0.4116335179704622
    winequality数据线性回归模型的中值绝对误差为: 0.42681355355182804
    winequality数据线性回归模型的可解释方差值为: 0.3304259967770349
    winequality数据线性回归模型的R方值为: 0.32853409414296564
    
    print('梯度提升回归模型评价结果:')
    print('winequality数据梯度提升回归树模型的平均绝对误差为:',
         mean_absolute_error(wine_quality_target_test,wine_target_pred))
    print('winequality数据梯度提升回归树模型的均方误差为:',
         mean_squared_error(wine_quality_target_test,wine_target_pred))
    print('winequality数据梯度提升回归树模型的中值绝对误差为:',
         median_absolute_error(wine_quality_target_test,wine_target_pred))
    print('winequality数据梯度提升回归树模型的可解释方差值为:',
         explained_variance_score(wine_quality_target_test,wine_target_pred))
    print('winequality数据梯度提升回归树模型的R方值为:',
         r2_score(wine_quality_target_test,wine_target_pred))  
    
    梯度提升回归模型评价结果:
    winequality数据梯度提升回归树模型的平均绝对误差为: 0.49135412186249
    winequality数据梯度提升回归树模型的均方误差为: 0.3929327053069297
    winequality数据梯度提升回归树模型的中值绝对误差为: 0.4130905910176561
    winequality数据梯度提升回归树模型的可解释方差值为: 0.3620462459660544
    winequality数据梯度提升回归树模型的R方值为: 0.3590392827808905   
    

    对于一个回归模型来说,平均绝对误差、均方误差、中值绝对误差越接近0越好,可解释方差和R2值越接近1越好。通过对比两者的回归评价指标不难发现,线性回归模型的平均绝对误差、均方误差、中值绝对误差都要大于梯度回归模型,但是可解释方差和R2值都要小于梯度回归模型。因此,梯度回归模型在五个指标上都要优于线性回归模型,故在本实训中,梯度回归模型性能更优!

    返回顶部


    展开全文
  • 机器学习wine数据集

    2018-12-16 18:24:36
    数据集包含来自3种不同起源的葡萄酒的共178条记录。13个属性是葡萄酒的13种化学成分。通过化学分析可以来推断葡萄酒的起源。值得一提的是所有属性变量都是连续变量。
  • Wine数据集分类——贝叶斯分类算法(MATLAB实现)一、Wine数据集的介绍1.1 实验目的1.2 数据介绍1.3 数据来源二、贝叶斯算法理论2.1 贝叶斯分类2.2 贝叶斯公式2.3 朴素贝叶斯分类器的设计流程2.3 朴素贝叶斯分类器的...

    一、Wine数据集的介绍

    1.1 实验目的

      该实验的Wine数据集来自于UCI机器学习数据库中,数据集中的数据则是产自意大利同一地区但来自三个不同品种的葡萄酒进行化学分析的结果,分析确定了三种酒中每种所含13种不同成分的数量。
      实验的目的就是利用分类算法实现Wine数据集中三种不同品种的葡萄酒分类。通过学习贝叶斯分类相关的知识,我们决定使用贝叶斯分类算法对Wine数据集进行分类。Wine数据集含有178个样本,我们将采用k折交叉验证的方法选取训练集和测试集,并采用朴素贝叶斯分类算法实现Wine数据集的分类。实验过程所使用的编程软件为MATLAB仿真软件,利用MATLAB实现算法及分类。

    1.2 数据介绍

      下表是Wine数据集的相关信息。

    Data Set Characteristics: Multivariate Number of Instances: 178 Area: Physical
    Attribute Characteristics: Integer, Real Number of Attributes: 13 Date Donated: 1991-07-01
    Associated Tasks: Classification Missing Values? No Number of Web Hits: 1509517

      这些数据包括了三种酒中13中不同成分的数量。13种成分分别是:Alcohol、Malic acid、Ash、 Alkalinity of ash、Magnesium、Total phenols、Flavanoids 、Nonflavanoid phenols、Proanthocyanins、Color intensity、Hue、OD280/OD315 of diluted wines、Proline。在‘Wine.data’文件中,每一行代表一种酒的样本,共有178个样本;一共14列,其中第一列为类别标志属性,共有3类,分别标记为‘1’、‘2’、‘3’,对于三种不同的葡萄酒;后面13列为每一个样本对应属性的属性值;类别‘1’共有59个样本,类别‘2’共有71个样本,类别‘3’共有48个样本
      由于数据集中每个样本的数据都是完整的,没有空缺值,所以没有对该数据集进行必要的数据清洗工作

    1.3 数据来源

      http://archive.ics.uci.edu/ml/datasets/Wine

    二、贝叶斯算法理论

    2.1 贝叶斯分类

      贝叶斯分类是指通过训练集(已分类的数据子集)训练来归纳出分类器,并利用分类器对未分类的数据(可以看作是测试集)进行分类。其基本思想是依据先验概率、类条件概率的信息,并按照某种准则使分类结果从统计上讲是最佳的。它是一种有监督学习的分类方法。

    2.2 贝叶斯公式

      若已知总共有M类样品,以及各类在n维特征空间的统计分布,根据概率知识可以通过样品库得知各类别wi(i=1,2,...,M)w_i(i=1,2,...,M)的先验概率p(wi)p(w_i)以及类条件概率p(X/wi)p(X/w_i)。对于待测样品,贝叶斯公式可以计算出该样品分属各类别的概率,叫做后验概率p(wi/X)p(w_i/X) 。比较各个后验概率,把X归于后验概率最大的那一个类。


    2.3 朴素贝叶斯分类器的设计流程

      首先,朴素贝叶斯分类其实就是基于最小错误率的贝叶斯分类,同时也称最大后验概率的贝叶斯分类。
    朴素贝叶斯分类的整个流程如下图所示:


      可以看到,整个朴素贝叶斯分类分为三个阶段:

      第一阶段——准备工作阶段,这个阶段的任务是为朴素贝叶斯分类做必要的准备,主要工作是根据具体情况确定特征属性,并对每个特征属性进行适当划分,然后由人工对一部分待分类项进行分类,形成训练样本集合。这一阶段的输入是所有待分类数据,输出是特征属性和训练样本。这一阶段是整个朴素贝叶斯分类中唯一需要人工完成的阶段,其质量对整个过程将有重要影响,分类器的质量很大程度上由特征属性、特征属性划分及训练样本质量决定。

      第二阶段——分类器训练阶段,这个阶段的任务就是生成分类器,主要工作是计算每个类别在训练样本中的出现频率及每个特征属性划分对每个类别的条件概率估计,并将结果记录。其输入是特征属性和训练样本,输出是分类器。这一阶段是机械性阶段,根据前面讨论的公式可以由程序自动计算完成。

      第三阶段——应用阶段。这个阶段的任务是使用分类器对待分类项进行分类,其输入是分类器和待分类项,输出是待分类项与类别的映射关系。这一阶段也是机械性阶段,由程序完成。

    2.3 朴素贝叶斯分类器的数学原理

      本实验中所采用的贝叶斯分类算法是朴素贝叶斯分类算法。朴素贝叶斯算法又叫做基于最小错误率的贝叶斯分类算法,也可称为基于最大后验概率的贝叶斯分类算法。它的原理就是利用贝叶斯公式将样本划分到后验概率最大的那一类中。因此可以定义每一类的判别函数为:

      由于在同一个模式识别问题中,对于不同的类,贝叶斯公式中的全概率是相同的,所以,各类的判别函数也可以定义为:
      假设样本空间被划分成c个类别决策区域,则分类判决规则为:
      此时,任意两个类别之间的决策边界由下述方程决定:
      先分析一下判别函数。在判别函数中,先验概率是一个与特征向量无关的常量,类条件概率密度则满足一定的概率分布。因为类条件概率与我们要识别的样本x有关。可以说,类条件概率是x的函数。对于一个类别的所有样本,x的取值会呈现出某种概率分布,如果我们知道这个概率分布,也就知道了类条件概率密度,那么贝叶斯分类的分类决策规则也就确定下来了。类条件概率具有不同的概率分布,相应贝叶斯分类的分类决策规则就会有不同的形式。
      常见的类条件概率分布有:均匀分布、指数分布、正态分布等。
      对于连续变量,在大多数情况下,采用的是正态分布(高斯分布)。也就是说,类条件概率密度可以采用多维变量的正态密度函数来模拟,得到的贝叶斯分类也叫做高斯朴素贝叶斯分类

    插讲:多维正态分布是样本在更高维度上的正态分布,它的基本形式与一维正态分布是相同的。只是在方差项上由一个协方差矩阵代替了方差,反映了各个维度之间存在的关联。

      因此,我们假设类条件概率符合多维正态分布,则判别函数可以写成:

      由于该判别函数含有指数,不方便计算。故取对数得到新的判别函数:
      将其化简为:
      由于d2ln(2π)\frac{d}{2}\ln (2π)与类别无关,所以判别函数可以进一步简化为:

      我们后面的实验过程就是根据此判别函数作为样本区分的依据。

    三、MATLAB仿真实现

    方案一:利用MATLAB自带的贝叶斯分类工具

    clear 
    clc
    load wine.data
    wine_class = wine;
    
    %训练集与测试集的划分
    data_train = [wine_class(1:35,:);wine_class(55:115,:);wine_class(131:163,:)];
    data_test = [wine_class(36:54,:);wine_class(116:130,:);wine_class(164:178,:)];
    
    train_num = length(data_train);
    test_num = length(data_test);
    train_labels1 = data_train(:,1);
    test_labels1 = data_test(:,1);
    % 这里对数据进行一次处理。贝叶斯分类器要求输入数据中同类别中一个特征的方差不能为0
    % 由公式我们可以知道,计算后验概率时,如果某一列特征全部相同,那么后验概率计算时分母会变为0% 为了避免该种情况,需要对数据进行提前处理
    
    [data_train,position] = data_proc(data_train,train_labels1(1:train_num)');
    %  对训练数据进行处理后,同时也要对测试数据进行同样的处理
    for rows = 1:10
        data_test(:,position{1,rows})=[];
    end
    
    %模型部分
    % 超参数全部取了默认值,比较重要的,如类别的先验概率,如果不进行修改,则计算输入数据中类别的频率
    % 查看nb_model即可确认所使用的超参数
    nb_model = fitcnb(data_train,train_labels1(1:train_num));
    %训练模型
    %测试结果
    result = predict(nb_model,data_test);
    result = result.';
    fprintf('预测结果:');
    result(1:test_num)
    %30个打印出来对比
    fprintf('真实分布:');
    test_labels1(1:test_num)'
    % 整体正确率
    acc = 0.;
    for i = 1:test_num
        if result(i)==test_labels1(i)
            acc = acc+1;
        end
    end
    fprintf('精确度为:%5.2f%%\n',(acc/test_num)*100);
    
    % data_proc.m
    % 函数功能:删除同类数据特征中方差为0的特征列
    % 输入:行向量数据及标签
    % 输出:删除列之后的数据以及删除的列标
    function [output,position] = data_proc(data,label)
        position = cell(1,10);
        %创建cell存储每类中删除的列标
        for i = 0:9
            temp = [];
            pos = [];
            for rows = 1:size(data,1)
                    if label(rows)==i
                        temp = [temp;data(rows,:)];
                    end
            end
            for cols = 1:size(temp,2)
                var_data = var(temp(:,cols));
                if var_data==0
                    pos = [pos,cols];
                end
            end
            position{i+1} = pos;
            data(:,pos)=[];
        end
        output = data;
    end
    

    分类精确度是一个固定值,为:97.96%
    说明:
    (1)此代码采用的MATLAB自带的函数工具,分别为训练模型函数fitcnb()与预测模型函数predict()。两个函数的用法可以参考MATLAB软件:【帮助】,里面有相关函数的解释。
    (2)此代码中的训练集与测试集的划分完全是根据自己的设置调整的,不是十分地严谨。
    (3)代码中没有对数据进行归一化处理。在实际中,数据集中每个属性对应的值可能相差很大,此时就需要归一化处理,将不同类型的特征数值大小变为一致,方便数据处理。

    方案二:自编函数实现贝叶斯分类算法

    clear
    clc
    load wine.data
    wine_class = wine;
    % mapminmax为MATLAB自带的归一化函数
    [wine_class,ps] = mapminmax(wine_class(:,2:size(wine_class,2))',0,1);      %归一化要先转至
    wine_class = [wine(:,1),wine_class'];
    
    % 训练集和测试集的划分
    % K-折交叉验证(k-fold crossValidation)
    [wine_class_r, wine_class_c] = size(wine_class);
    K=10;
    sum_accuracy = 0;
    %将数据样本随机分割为10部分
    indices = crossvalind('Kfold', wine_class_r,K);
    for i = 1 :K
        % 获取第i份测试数据的索引逻辑值
        test = (indices == i);
        % 取反,获取第i份训练数据的索引逻辑值
        train = ~test;
        %1份测试,9份训练
        test_data = wine_class(test, 2 : wine_class_c);
        test_label = wine_class(test, 1);
        train_data = wine_class(train, 2 : wine_class_c );
        train_label = wine_class(train, 1);
        %模型的训练以及预测结果
        train_model = Naive_Bayesian( train_data,train_label);
        result = predict_BN(train_model,test_data,test_label);
        accuracy_test = sum(result == test_label) / length(test_label)*100;
        sum_accuracy = sum_accuracy + accuracy_test;
    end  
    %求平均准确率
    mean_accuracy = sum_accuracy / K;
    disp('平均准确率:');   
    fprintf('%15.2f%%\n',mean_accuracy)
    
    function [model]= Naive_Bayesian(X, Y)
    % 朴素贝叶斯分类器的实现
    m=size(X,1);%记录训练集样本总数
    n=size(X,2);%记录训练集特征属性数目
    %记录类别数及每个类别编号
    yy=Y(:);
    yy=sort(yy);
    d=diff([yy;max(yy)+1]);%差分计算
    count = diff(find([1;d]));%记录每个类别出现次数//find返回非零元素的索引位置
    class_num=yy(find(d));%记录类别编号[1;2;3]
    %计算每个类别的先验概率 p(W)
    for i=1:length(class_num)
        pW(i) = count(i)/m;
    end
    x1 = X(1:count(1),:); %第一类样本
    x2 = X(count(1)+1:count(1)+count(2),:);   %第二类样本
    x3 = X(count(1)+count(2)+1:count(1)+count(2)+count(3),:);   %第三类样本
    x = {x1;x2;x3};
    for i = 1:length(class_num)     
        smean{i} = mean(cell2mat(x(i))); %求各类别的均值
        scov{i} = cov(cell2mat(x(i)));  %求各类别的协方差矩阵
    end
    for i = 1:length(class_num)     
        sinv{i} = pinv(cell2mat(scov(i))); %求各类别协方差矩阵的逆矩阵
        sdet{i} = det(cell2mat(scov(i)));  %求各类别协方差矩阵的行列式
    end
    model.ssmean = smean;
    model.sscov = scov;
    model.ssinv = sinv;
    model.ssdet = sdet;
    model.pW = pW;
    end
    
    function result = predict_BN(model,X,Y)
    %朴素贝叶斯分类器的预测
    ssmean = model.ssmean ;
    sscov = model.sscov ;
    ssinv = model.ssinv ;
    ssdet = model.ssdet ;
    pW = model.pW;
    m = size(X,1);%记录测试样本总数
    n = size(X,2);%记录测试样本特征数13
    %记录每个类别编号
    yy=Y(:);
    yy=sort(yy);
    d=diff([yy;max(yy)+1]);%差分计算
    class_num=yy(find(d));%记录类别编号
    %求判别函数gi(x)
    for i = 1:length(class_num) 
        for j = 1:length(X)
            gi(j,i) =log(pW(i))-(1/2)*(X(j,:)'-cell2mat(ssmean(i))')'*(cell2mat(ssinv(i)))*(X(j,:)'-cell2mat(ssmean(i))')-(1/2)*log(cell2mat(ssdet(i)));         
        end
    end
    for i=1:m
        [max_Pro(i,1), index] = max(gi(i,:));%输出处于最大概率的概率值以及其对应的索引位置
        result(i,1)=class_num(index);%待测样本的预测类别
    end
    end
    

    每次运行的分类精确度不同:大致在98%~100%
    说明:
    (1)代码中数据的归一化函数采用的是mapminmax()。
    (2)训练集与测试集划分不是随意划分的,也不是根据准确率的高低来调整训练集与测试集,而是采用k折交叉验证(K=10),k-折交叉验证的相关知识请大家咨询一下其他博客,本文不一一赘述。
    (3)后面朴素贝叶斯分类训练模型Naive_Bayesian()与预测模型predict_BN()是自己根据上面讲述的判别函数自编的。
    (4)在10折交叉验证中,每次运行都有10次分类结果,将10次分类结果取平均值,就可以得到比较准确的分类精度。

    写到这里很不易,感谢大家大家滴观看!
    有错误敬请指正,看到尽量根据水平改。

    展开全文
  • 聚类数据集,mat格式,matlab直接可用
  • 数据集是从UCI上download下来的Wine数据集,下载地址,这是一个多分类问题,类别标签为1,2,3。 先瞅瞅数据, import numpy as np import pandas as pd from sklearn.linear_model import LogisticRegression #...

    刚学数据分析时做的小例子,从notebook上复制过来,留个纪念~

    数据集是从UCI上download下来的Wine数据集,下载地址这是一个多分类问题,类别标签为1,2,3。

    先瞅瞅数据,

    import numpy as np
    import pandas as pd
    from sklearn.linear_model import LogisticRegression   #逻辑斯特回归,线性分类
    from sklearn.linear_model import SGDClassifier        #随机梯度参数估计
    from sklearn.svm import LinearSVC                     #支持向量机
    from sklearn.naive_bayes import MultinomialNB         #朴素贝叶斯
    from sklearn.neighbors import KNeighborsClassifier    #K近邻
    from sklearn.tree import DecisionTreeClassifier       #决策树
    from sklearn.ensemble import RandomForestClassifier   #随机森林
    from sklearn.ensemble import GradientBoostingClassifier   #梯度提升决策树
    from sklearn.naive_bayes import GaussianNB
    from sklearn.ensemble import ExtraTreesClassifier
    
    from sklearn.preprocessing import MinMaxScaler   #最大最小归一化
    from sklearn.preprocessing import StandardScaler   #标准化
    from scipy.stats import pearsonr                    #皮尔森相关系数
    from sklearn.model_selection import train_test_split     #划分数据集
    from sklearn.model_selection import cross_val_score   
    import matplotlib.pyplot as plt
    import seaborn as sns
    from sklearn.decomposition import PCA
    #计算排列和组合数所需要的包
    from itertools import combinations
    from scipy.special import comb
    
    columns=['0Alcohol','1Malic acid ','2Ash','3Alcalinity of ash',
             '4Magnesium','5Total phenols','6Flavanoid',
             '7Nonflavanoid phenols','8Proanthocyanins ','9Color intensity ','10Hue ','11OD280/OD315 of diluted wines' ,'12Proline ','13category']
    data= pd.read_csv("G:/feature_code/wine_data.csv",header=None,names=columns)
    data.shape
    (178, 14)

    显示前五行,

    data.head()
      0Alcohol 1Malic acid 2Ash 3Alcalinity of ash 4Magnesium 5Total phenols 6Flavanoid 7Nonflavanoid phenols 8Proanthocyanins 9Color intensity 10Hue 11OD280/OD315 of diluted wines 12Proline 13category
    0 14.23 1.71 2.43 15.6 127 2.80 3.06 0.28 2.29 5.64 1.04 3.92 1065 1
    1 13.20 1.78 2.14 11.2 100 2.65 2.76 0.26 1.28 4.38 1.05 3.40 1050 1
    2 13.16 2.36 2.67 18.6 101 2.80 3.24 0.30 2.81 5.68 1.03 3.17 1185 1
    3 14.37 1.95 2.50 16.8 113 3.85 3.49 0.24 2.18 7.80 0.86 3.45 1480 1
    4 13.24 2.59 2.87 21.0 118 2.80 2.69 0.39 1.82 4.32 1.04 2.93 735 1
    data.info()
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 178 entries, 0 to 177
    Data columns (total 14 columns):
    0Alcohol                          178 non-null float64
    1Malic acid                       178 non-null float64
    2Ash                              178 non-null float64
    3Alcalinity of ash                178 non-null float64
    4Magnesium                        178 non-null int64
    5Total phenols                    178 non-null float64
    6Flavanoid                        178 non-null float64
    7Nonflavanoid phenols             178 non-null float64
    8Proanthocyanins                  178 non-null float64
    9Color intensity                  178 non-null float64
    10Hue                             178 non-null float64
    11OD280/OD315 of diluted wines    178 non-null float64
    12Proline                         178 non-null int64
    13category                        178 non-null int64
    dtypes: float64(11), int64(3)
    memory usage: 19.5 KB

    数据说明: 共178条记录,数据没有空缺值,还可以通过describe()方法看数据,主要关注mean这个,对数据分布有个大体的了解。 然后再看数据样本是否均衡

    data['13category'].value_counts()
    2    71
    1    59
    3    48
    Name: 13category, dtype: int64

    样本较为均衡,差别不大

    for i in data.iloc[:,0:13].columns:    
        sns.boxplot(x = data['13category'],y = data[i])  
        ax = sns.boxplot(x='13category', y=i, data=data)
        ax = sns.stripplot(x='13category', y=i, data=data, jitter=True, edgecolor="gray")
        plt.show()

     

     

    通过对以上每个特征与标签的盒装图和散点图分析,区分度不是很大,不容易进行特征筛选,接下来计算特征和分类的Pearson相关系数

    def pearsonar(X,y):   
        pearson=[]
        for col in X.columns.values:
            pearson.append(abs(pearsonr(X[col].values,y)[0]))
        pearsonr_X = pd.DataFrame({'col':X.columns,'corr_value':pearson})
        pearsonr_X = pearsonr_X.sort_values(by='corr_value',ascending=False)
        print pearsonr_X
    pearsonar(X,y)

     结果如下,

           col  corr_value
    6                       6Flavanoid    0.847498
    11  11OD280/OD315 of diluted wines    0.788230
    5                   5Total phenols    0.719163
    12                      12Proline     0.633717
    10                          10Hue     0.617369
    3               3Alcalinity of ash    0.517859
    8                8Proanthocyanins     0.499130
    7            7Nonflavanoid phenols    0.489109
    1                     1Malic acid     0.437776
    0                         0Alcohol    0.328222
    9                9Color intensity     0.265668
    4                       4Magnesium    0.209179
    2                             2Ash    0.049643

    分析发现只有特征2与标签的线性关系较低 ,再计算特征间的线性相关

    c=list(combinations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12],2))
    p=[]
    for i in range(len(c)):
        p.append(abs(pearsonr(X.iloc[:,c[i][0]],X.iloc[:,c[i][1]])[0]))
    pearsonr_ = pd.DataFrame({'col':c,'corr_value':p})
    pearsonr_ = pearsonr_.sort_values(by='corr_value',ascending=False)
    print pearsonr_
     col  corr_value
    50    (5, 6)    0.864564
    61   (6, 11)    0.787194
    55   (5, 11)    0.699949
    58    (6, 8)    0.652692
    11   (0, 12)    0.643720
    52    (5, 8)    0.612413
    75  (10, 11)    0.565468
    20   (1, 10)    0.561296
    8     (0, 9)    0.546364
    60   (6, 10)    0.543479
    57    (6, 7)    0.537900
    72   (9, 10)    0.521813
    70   (8, 11)    0.519067
    66   (7, 11)    0.503270
    56   (5, 12)    0.498115
    62   (6, 12)    0.494193
    51    (5, 7)    0.449935
    23    (2, 3)    0.443367
    41   (3, 12)    0.440597
    54   (5, 10)    0.433681
    73   (9, 11)    0.428815
    16    (1, 6)    0.411007
    49   (4, 12)    0.393351
    21   (1, 11)    0.368710
    63    (7, 8)    0.365845
    36    (3, 7)    0.361922
    35    (3, 6)    0.351370
    15    (1, 5)    0.335167
    71   (8, 12)    0.330417
    34    (3, 5)    0.321113
    ..       ...         ...
    76  (10, 12)    0.236183
    32   (2, 12)    0.223626
    18    (1, 8)    0.220746
    42    (4, 5)    0.214401
    1     (0, 2)    0.211545
    46    (4, 9)    0.199950
    37    (3, 8)    0.197327
    43    (4, 6)    0.195784
    22   (1, 12)    0.192011
    27    (2, 7)    0.186230
    59    (6, 9)    0.172379
    12    (1, 2)    0.164045
    6     (0, 7)    0.155929
    64    (7, 9)    0.139057
    7     (0, 8)    0.136698
    25    (2, 5)    0.128980
    26    (2, 6)    0.115077
    0     (0, 1)    0.094397
    33    (3, 4)    0.083333
    30   (2, 10)    0.074667
    10   (0, 11)    0.072343
    9    (0, 10)    0.071747
    48   (4, 11)    0.066004
    47   (4, 10)    0.055398
    53    (5, 9)    0.055136
    14    (1, 4)    0.054575
    68    (8, 9)    0.025250
    38    (3, 9)    0.018732
    28    (2, 8)    0.009652
    31   (2, 11)    0.003911
    
    [78 rows x 2 columns]

    5、6、11三个特征相关性较大,可能存在冗余特征 

    #通过随机森林特征重要性筛选特征
    def randomF_importfeat(X,y):
        features_list=X.columns
        forest = RandomForestClassifier(oob_score=True, n_estimators=10000)
        forest.fit(X, y)
        feature_importance = forest.feature_importances_
        feature_importance = 100.0 * (feature_importance / feature_importance.max())
        fi_threshold = 0    
        important_idx = np.where(feature_importance > fi_threshold)[0]
        important_features = features_list[important_idx]
        print( "\n", important_features.shape[0], "Important features(>", \
              fi_threshold, "% of max importance)...\n")
        sorted_idx = np.argsort(feature_importance[important_idx])[::-1]
        #get the figure about important features
        pos = np.arange(sorted_idx.shape[0]) + .5
        plt.subplot(1, 2, 2)
        plt.title('Feature Importance')
        plt.barh(pos, feature_importance[important_idx][sorted_idx[::-1]], \
                color='r',align='center')
        plt.yticks(pos, important_features[sorted_idx[::-1]])
        plt.xlabel('Relative Importance')
        plt.draw()
        plt.show()
    randomF_importfeat(X,y)
    ('\n', 13L, 'Important features(>', 0, '% of max importance)...\n')

    2这个特征可以考虑删除

    先试下PCA降维效果

    # 直接PCA降维后枚举各种模型测试
    def _PCA(X,y):
        ss=MinMaxScaler()
        X=ss.fit_transform(X)
        pca=PCA(n_components='mle')
        X_new=pca.fit_transform(X)
        clfs = [LogisticRegression(),SGDClassifier(),LinearSVC(),KNeighborsClassifier(),\
                DecisionTreeClassifier(),RandomForestClassifier(),GradientBoostingClassifier(),GaussianNB()]
        for model in clfs:
                print("模型及模型参数:")
                print(str(model))
                print("模型准确率:")
                print(np.mean(cross_val_score(model,X_new,y,cv=10)))
    _PCA(X,y)

     

    模型及模型参数:
    LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
              intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
              penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
              verbose=0, warm_start=False)
    模型准确率:
    0.983333333333
    模型及模型参数:
    SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,
           eta0=0.0, fit_intercept=True, l1_ratio=0.15,
           learning_rate='optimal', loss='hinge', n_iter=5, n_jobs=1,
           penalty='l2', power_t=0.5, random_state=None, shuffle=True,
           verbose=0, warm_start=False)
    模型准确率:
    0.967251461988
    模型及模型参数:
    LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
         intercept_scaling=1, loss='squared_hinge', max_iter=1000,
         multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,
         verbose=0)
    模型准确率:
    0.983333333333
    模型及模型参数:
    KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
               metric_params=None, n_jobs=1, n_neighbors=5, p=2,
               weights='uniform')
    模型准确率:
    0.971200980392
    模型及模型参数:
    DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,
                max_features=None, max_leaf_nodes=None,
                min_impurity_split=1e-07, min_samples_leaf=1,
                min_samples_split=2, min_weight_fraction_leaf=0.0,
                presort=False, random_state=None, splitter='best')
    模型准确率:
    0.927048933609
    模型及模型参数:
    RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
                max_depth=None, max_features='auto', max_leaf_nodes=None,
                min_impurity_split=1e-07, min_samples_leaf=1,
                min_samples_split=2, min_weight_fraction_leaf=0.0,
                n_estimators=10, n_jobs=1, oob_score=False, random_state=None,
                verbose=0, warm_start=False)
    模型准确率:
    0.971895424837
    模型及模型参数:
    GradientBoostingClassifier(criterion='friedman_mse', init=None,
                  learning_rate=0.1, loss='deviance', max_depth=3,
                  max_features=None, max_leaf_nodes=None,
                  min_impurity_split=1e-07, min_samples_leaf=1,
                  min_samples_split=2, min_weight_fraction_leaf=0.0,
                  n_estimators=100, presort='auto', random_state=None,
                  subsample=1.0, verbose=0, warm_start=False)
    模型准确率:
    0.972222222222
    模型及模型参数:
    GaussianNB(priors=None)
    模型准确率:
    0.977743378053

    数据很标准,随便PCA一下就能得到如此高分

    再试试原始数据在各个默认参数模型上的表现如何,

    #划分训练集和测试集  
    X_train,X_test,y_train,y_test=train_test_split(data.iloc[:,:13],data.iloc[:,13],test_size=0.2,random_state=0) 
    #此处采用最大最小归一化, 可以换成StandardScaler()归一化方法,如果用StandardScaler()方法的话,则不能使用MultinomialNB()模型
    ss=MinMaxScaler()
    #ss=StandardScaler()                           
    X_train=ss.fit_transform(X_train)
    X_test=ss.transform(X_test)
    #模型及模型参数列表
    clfs = [LogisticRegression(),SGDClassifier(),LinearSVC(),MultinomialNB(),KNeighborsClassifier(),\
            DecisionTreeClassifier(),RandomForestClassifier(),GradientBoostingClassifier(),GaussianNB(),ExtraTreesClassifier()]
    #输出模型及参数信息,以及模型分类准确性
    for model in clfs:
            print("模型及模型参数:")   
            print(str(model))
            model.fit(X_train,y_train)
            print("模型准确率:")
            print(model.score(X_test,y_test))
    模型及模型参数:
    LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
              intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
              penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
              verbose=0, warm_start=False)
    模型准确率:
    0.972222222222
    模型及模型参数:
    SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,
           eta0=0.0, fit_intercept=True, l1_ratio=0.15,
           learning_rate='optimal', loss='hinge', n_iter=5, n_jobs=1,
           penalty='l2', power_t=0.5, random_state=None, shuffle=True,
           verbose=0, warm_start=False)
    模型准确率:
    1.0
    模型及模型参数:
    LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
         intercept_scaling=1, loss='squared_hinge', max_iter=1000,
         multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,
         verbose=0)
    模型准确率:
    1.0
    模型及模型参数:
    MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)
    模型准确率:
    0.944444444444
    模型及模型参数:
    KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
               metric_params=None, n_jobs=1, n_neighbors=5, p=2,
               weights='uniform')
    模型准确率:
    0.972222222222
    模型及模型参数:
    DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,
                max_features=None, max_leaf_nodes=None,
                min_impurity_split=1e-07, min_samples_leaf=1,
                min_samples_split=2, min_weight_fraction_leaf=0.0,
                presort=False, random_state=None, splitter='best')
    模型准确率:
    0.972222222222
    模型及模型参数:
    RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
                max_depth=None, max_features='auto', max_leaf_nodes=None,
                min_impurity_split=1e-07, min_samples_leaf=1,
                min_samples_split=2, min_weight_fraction_leaf=0.0,
                n_estimators=10, n_jobs=1, oob_score=False, random_state=None,
                verbose=0, warm_start=False)
    模型准确率:
    1.0
    模型及模型参数:
    GradientBoostingClassifier(criterion='friedman_mse', init=None,
                  learning_rate=0.1, loss='deviance', max_depth=3,
                  max_features=None, max_leaf_nodes=None,
                  min_impurity_split=1e-07, min_samples_leaf=1,
                  min_samples_split=2, min_weight_fraction_leaf=0.0,
                  n_estimators=100, presort='auto', random_state=None,
                  subsample=1.0, verbose=0, warm_start=False)
    模型准确率:
    0.944444444444
    模型及模型参数:
    GaussianNB(priors=None)
    模型准确率:
    0.916666666667
    模型及模型参数:
    ExtraTreesClassifier(bootstrap=False, class_weight=None, criterion='gini',
               max_depth=None, max_features='auto', max_leaf_nodes=None,
               min_impurity_split=1e-07, min_samples_leaf=1,
               min_samples_split=2, min_weight_fraction_leaf=0.0,
               n_estimators=10, n_jobs=1, oob_score=False, random_state=None,
               verbose=0, warm_start=False)
    模型准确率:
    0.972222222222
    

    删除第二个特征后,再试一下

    params=[ 0,1,3,4,5,6,7,8,9,10,11,12]
    X=data.iloc[:,:13]
    X=[params]
    #划分训练集和测试集  
    X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=0) 
    #此处采用最大最小归一化, 可以换成StandardScaler()归一化方法,如果用StandardScaler()方法的话,则不能使用MultinomialNB()模型
    ss=MinMaxScaler()
    #ss=StandardScaler()                           
    X_train=ss.fit_transform(X_train)
    X_test=ss.transform(X_test)
    #模型及模型参数列表
    clfs = [LogisticRegression(),SGDClassifier(),LinearSVC(),MultinomialNB(),KNeighborsClassifier(),\
            DecisionTreeClassifier(),RandomForestClassifier(),GradientBoostingClassifier(),GaussianNB(),ExtraTreesClassifier()]
    #输出模型及参数信息,以及模型分类准确性
    for model in clfs:
            print("模型及模型参数:")   
            print(str(model))
            model.fit(X_train,y_train)
            print("模型准确率:")
            print(model.score(X_test,y_test))
    模型及模型参数:
    LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
              intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
              penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
              verbose=0, warm_start=False)
    模型准确率:
    0.916666666667
    模型及模型参数:
    SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,
           eta0=0.0, fit_intercept=True, l1_ratio=0.15,
           learning_rate='optimal', loss='hinge', n_iter=5, n_jobs=1,
           penalty='l2', power_t=0.5, random_state=None, shuffle=True,
           verbose=0, warm_start=False)
    模型准确率:
    0.944444444444
    模型及模型参数:
    LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
         intercept_scaling=1, loss='squared_hinge', max_iter=1000,
         multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,
         verbose=0)
    模型准确率:
    1.0
    模型及模型参数:
    MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)
    模型准确率:
    0.944444444444
    模型及模型参数:
    KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
               metric_params=None, n_jobs=1, n_neighbors=5, p=2,
               weights='uniform')
    模型准确率:
    0.944444444444
    模型及模型参数:
    DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,
                max_features=None, max_leaf_nodes=None,
                min_impurity_split=1e-07, min_samples_leaf=1,
                min_samples_split=2, min_weight_fraction_leaf=0.0,
                presort=False, random_state=None, splitter='best')
    模型准确率:
    0.972222222222
    模型及模型参数:
    RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
                max_depth=None, max_features='auto', max_leaf_nodes=None,
                min_impurity_split=1e-07, min_samples_leaf=1,
                min_samples_split=2, min_weight_fraction_leaf=0.0,
                n_estimators=10, n_jobs=1, oob_score=False, random_state=None,
                verbose=0, warm_start=False)
    模型准确率:
    0.972222222222
    模型及模型参数:
    GradientBoostingClassifier(criterion='friedman_mse', init=None,
                  learning_rate=0.1, loss='deviance', max_depth=3,
                  max_features=None, max_leaf_nodes=None,
                  min_impurity_split=1e-07, min_samples_leaf=1,
                  min_samples_split=2, min_weight_fraction_leaf=0.0,
                  n_estimators=100, presort='auto', random_state=None,
                  subsample=1.0, verbose=0, warm_start=False)
    模型准确率:
    0.944444444444
    模型及模型参数:
    GaussianNB(priors=None)
    模型准确率:
    0.916666666667
    模型及模型参数:
    ExtraTreesClassifier(bootstrap=False, class_weight=None, criterion='gini',
               max_depth=None, max_features='auto', max_leaf_nodes=None,
               min_impurity_split=1e-07, min_samples_leaf=1,
               min_samples_split=2, min_weight_fraction_leaf=0.0,
               n_estimators=10, n_jobs=1, oob_score=False, random_state=None,
               verbose=0, warm_start=False)
    模型准确率:
    1.0

    对于数据集较小的,试验了一下贪婪搜索了所有特征组合可能

    def greed(X,y):
        ss=MinMaxScaler()
        X=ss.fit_transform(X)
        X=pd.DataFrame(X)
        jilu=pd.DataFrame(columns=['m','feature','score'])    
        params=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12]
        model = LinearSVC()
        best_socre=0
        n=13
        i=1
        index=0
        while i<=n:
            test_params=list(combinations(params, i))
            j=int(comb(n,i))
            i=i+1
            for m in range(j):
                z=list(test_params[m])
                score = np.mean(cross_val_score(model,X[z],y,cv=10))    #10折交叉验证取平均
                if score>best_socre:
                    best_socre=score
                    best_feature=z
                jilu.loc[index,['m']]=m
                jilu.loc[index,['feature']]=str(z)
                jilu.loc[index,['score']]=score
                index=index+1
        print(jilu)
        print ("best_feature=",best_feature,"best_score=",best_socre)
    greed(data.iloc[:,:13],data.iloc[:,13])

     

    展开全文
  • 包含C4.5算法对UCI wine 数据集的MATLAB代码和详细的说明文档
  • KNN分类wine数据集

    2021-02-01 23:16:15
    KNN包含马氏距离和欧式距离
  • 对UCI上的数据集wine利用机器学习的常见分类算法进行分类处理,包含KNN,朴素贝叶斯算法,决策树算法等等。可直接使用,无需更改。
  • CSCI-348-最终项目 使用Wine数据集/实现Tensorflow进行葡萄酒质量预测
  • 用朴素贝叶斯对wine数据集分类

    万次阅读 2015-11-10 09:51:53
    该实验的数据集是MostPopular Data Sets(hits since 2007)中的wine数据集,这是是对在意大利同一地区生产的三种不同品种的酒,做大量分析所得出的数据。这些数据包括了三种酒中13种不同成分的数量。 经过几天对...

    该实验的数据集是MostPopular Data Sets(hits since 2007)中的wine数据集,这是是对在意大利同一地区生产的三种不同品种的酒,做大量分析所得出的数据。这些数据包括了三种酒中13种不同成分的数量。

    经过几天对数据集以及分类算法的研究,详细研究了朴素贝叶斯分类器和其他学习算法,包括决策树和神经网络等等。同时由于这个数据集有13个属性,用决策树实现起来会很复杂。我最终选择了用贝叶斯分类算法来实现。编程的时候采用c++语言实现分类的功能。我将178个样本分成118个训练样本和60个测试样本,采用朴素贝叶斯分类算法,计算出先验概率和后验概率,通过比较概率的最大值,判别出测试样本所属于的酒的类型,同时输出测试样本计算的正确率和错误率。

    1.实验数据集介绍

    1.1Wine数据集

    该实验的数据源是Wine data,这是对在意大利同一地区生产的三种不同品种的酒,做大量分析所得出的数据。如下图1-1所示:


    这些数据包括了三种酒中13种不同成分的数量。13种成分分别为:Alcohol,Malicacid,Ash,Alcalinity of ash,Magnesium,Total phenols,Flavanoids,Nonflavanoid phenols,Proanthocyanins,Color intensity,Hue,OD280/OD315 of diluted wines,Proline。在 “wine.data”文件中,每行代表一种酒的样本,共有178个样本;一共有14列,其中,第一列为类标志属性,共有三类,分别记为“1”,“2”,“3”;后面的13列为每个样本的对应属性的样本值。其中第1类有59个样本,第2类有71个样本,第3类有48个样本。

         由于数据源文件中的每个样本的数据都是完整的,没有空缺值等,所以我没有对该数据源文件进行数据的清理工作。

    2.实验方案

    2.1朴素贝叶斯分类算法

    每个数据样本用一个n维特征向量X={x1,x2,…,xn}表示,分别描述对n个属性A1,A2,..,An样本的n个度量。假定有m个类C1,…,Cm,对于数据样本X,分类法将预测X属于类Ci,当且仅当:P(Ci|X)> P(Cj|X),1<=j<=m而且j不等于i。

    根据贝叶斯定理, :P(Ci|X)=P(X|Ci)P(Ci)/P(X)

    由于P(X)对于所有类都是常数,只需最大化P(X|Ci)P(Ci),计算P(X|Ci),朴素贝叶斯分类假设类条件独立.即给定样本属性值相互条件独立,即:

    ,在使用中,p常用频度代替。

    2.2朴素贝叶斯分类的原理与流程

    朴素贝叶斯的思想基础是这样的:对于给出的待分类项,求解在此项出现的条件下各个类别出现的概率,哪个最大,就认为此待分类项属于哪个类别。通俗来说,就好比这么个道理,你在街上看到一个黑人,我问你猜这哥们哪里来的,你十有八九猜非洲。为什么呢?因为黑人中非洲人的比率最高,当然人家也可能是美洲人或亚洲人,但在没有其它可用信息下,我们会选择条件概率最大的类别,这就是朴素贝叶斯的思想基础。朴素贝叶斯分类的正式定义如下:

          1、设为一个待分类项,而每个a为x的一个特征属性。

          2、有类别集合

          3、计算

          4、如果

    那么现在的关键就是如何计算第3步中的各个条件概率。我们可以这么做:

          1、找到一个已知分类的待分类项集合,这个集合叫做训练样本集。

          2、统计得到在各类别下各个特征属性的条件概率估计。即。

          3、如果各个特征属性是条件独立的,则根据贝叶斯定理有如下推导:


          

    因为分母对于所有类别为常数,因为我们只要将分子最大化皆可。又因为各特征属性是条件独立的,所以有:


          

    根据上述分析,朴素贝叶斯分类的流程可以由下图2-1表示(暂时不考虑验证):


                

    3实验步骤

    3.1数据集的下载

        在http://archive.ics.uci.edu/ml/网页上下载实验所用的Wine数据集。点击Wine数据集,在页面上,点击Data Folder,下载wine.data数据,即为实验所需的数据集。

    3.2朴素贝叶斯算法实现

    首先,将Wine数据集分成118个训练样本和60个测试样本,分别保存在“Ttrainingwine.data”和 “testwine.data”中。用DataRead从文件中读取数值。

    然后用朴素贝叶斯算法的思想:

    1.统计三类红酒数据的数量,各自求和,拿各自类的数量除以总数,求出它们的先验概率p(Q1),p(Q2),p(Q3),保存在数组R中的R[0], R[1], R[2]。

    2.分别求P(Xk|Q1)中 ,P(Xk|Q2)中和 P(Xk|Q3) 中Xk的个数。

    3.计算概率p(X|Q1),计算p(Q1)*p(X|Q1),同样的方法去计算概率p(X|Q2), p(Q2)*p(X|Q2), p(X|Q3), p(Q3)*p(X|Q3),把这三个计算出来的概率值p(Q1)*p(X|Q1),p(Q2)*p(X|Q2),p(Q3)*p(X|Q3)保存在数组gailv中的gailv[0],gailv[1],gailv[2]。

    4.比较gailv[0],gailv[1],gailv[2],找出最大值,最大值所对应的那个类即为我们要找的wine的分类。

    3.3朴素贝叶斯算法实现的源代码

        关于具体的实现代码见下面,此处不做详细的说明。

    3.4实验结果

    实验结果如下面的截图所示。

    源代码:

    MachineLearning.h:

    #include <string>
    #include <set>                       //set是C++标准库中的一种关联容器。所谓关联容器就是通过键(key)来读取和修改元素。
                                       //set容器的每一个键只能对应一个元素,即不存在键相同的不同元素。


    #include <map>                      //map 一种容器 也叫关联数组 
                                                  //你先把它理解成数组  一个个的元素知道吧
                                                //然后你再这样理解,每个元素都有两个值,一个叫“键”,一个叫“值”
                                              //你可以通过“键”找到相关的“值”
                                             //通常map容器 只能存入单一实例,就是说不能有相同的“键/值”
                                            //map 就是 在key和value之间建立映射,是的可以通过key访问/获取value。


    #include <vector>                 //标准库Vector类型,使用需要的头文件
                                              //vector是一种顺序容器,事实上和数组差不多,但它比数组更优越。
                                            //一般来说数组不能动态拓展,因此在程序运行的时候不是浪费内存,就是造成越界。
                                         //而vector正好弥补了这个缺陷,它的特征是相当于可分配拓展的数组,它的随机访问快,
    using namespace std;
    /*
      1) Alcohol
      2) Malic acid
      3) Ash
    4) Alcalinity of ash  
      5) Magnesium
    6) Total phenols
      7) Flavanoids
      8) Nonflavanoid phenols
      9) Proanthocyanins
    10)Color intensity
      11)Hue
      12)OD280/OD315 of diluted wines
      13)Proline            


    */
    int xunlianshuliang = 118; //所有训练数据的范围
    int ceshishuliang= 60;
    struct yuanshishuju
    {
    double M1;
    double M2;
    double M3;
    double M4;
        double M5;
        double M6;
    double M7;
    double M8;
    double M9;
    double M10;
    double M11;
    double M12;
    double M13;
    double M14;
    };

    MachineLearning.cpp:

    #include <iostream>                              //包含输入输出流
    #include <sstream>                               //sstream是字符串流,C++引入了ostringstream、istringstream、stringstream这三个类
                                                     //要使用他们创建对象就必须包含sstream.h头文件 
    #include <fstream>                               //包含文件流,这样就可以使用与文件相关的一些函数,像open(),close()等                                                                                 
    #include "MachineLearning.h"                     //自己所建的一个头文件,名字为MachineLearning
    using namespace std;                             //命名空间,c++中的所有标识符都被定义于std命名空间中
    double R[3];                                     //在这里定义一个数组,用来存放先验概率
    int m;             
    vector<yuanshishuju> ceshishuju;                 //存放测试数据
    vector<yuanshishuju> xunlianshuju;               //存放训练数据,vector是一个能够存放任意类型的动态数组,能够增加和压缩数据。
    const int shuxingzongshu=13;                     //这里定义属性总数为一个常量,而且以后不能对其修改
    map<double, double> Q1_map[13];                  //存放每一类型,每种属性中某数值的概率
    map<double, double> Q2_map[13];                  //自动建立Key - value的对应。key 和 value可以是任意你需要的类型
    map<double, double> Q3_map[13];
    ifstream   file1;                             //ifstream表示是以输入的方式打开文件


    void DataRead(vector<yuanshishuju> &shuju, const char* fileName)   //用DataRead从文件中读取数值 
    {
    file1.open(fileName);                                         //创建或打开一个用于访问文件的对象
    int s;
    if (fileName[0] == 'T')
    s = xunlianshuliang;
    else 
    s = ceshishuliang;
    string line;                                                  //定义一个line变量,string类型
    yuanshishuju Ttrainingwine;
    for (int a = 0;  a < s; a++)
    {
    file1 >> line;
    while (line.find(',') > 0 && line.find(',') < line.length())     //find查找一个元素
    {
    line[line.find(',')] = ' '; 
    }
    istringstream stream(line);                                     //从字符串读,istringstream对象可以绑定一行字符串,然后以空格为分隔符把该行分隔开来
    stream >> Ttrainingwine.M1 >> Ttrainingwine.M2 >> Ttrainingwine.M3 >> Ttrainingwine.M4 >> Ttrainingwine.M5 >> Ttrainingwine.M6 >> Ttrainingwine.M7 >> Ttrainingwine.M8 >> 
    Ttrainingwine.M9 >> Ttrainingwine.M10 >>Ttrainingwine.M11 >>Ttrainingwine.M12 >> Ttrainingwine.M13 >> Ttrainingwine.M14;
    shuju.push_back(Ttrainingwine);                                 //在vector尾部加入一个值为Ttrainingwine的数据
    }
    file1.close();                                                      //关闭文件
    }


    void pusubeiyesi()
    {
    int number1 = 0; 
    int number2 = 0;
    int number3 = 0;
    int a;


        //统计三类红酒数据的数量,各自求和


    for(a = 0; a < xunlianshuliang  ; a++)
    {
    if(xunlianshuju[a].M1 == 1)
    {
    number1 ++;
    }
    if(xunlianshuju[a].M1 == 2)
    {
    number2 ++;
    }
    if(xunlianshuju[a].M1 == 3)
    {
    number3 ++;
    }                                                   
    }


        //求它们的先验概率,拿各自类的数量除以总数


    R[0] = (double)number1/(double)xunlianshuliang;         
    R[1] = (double)number2/(double)xunlianshuliang;
    R[2] = (double)number3/(double)xunlianshuliang;

    map<double, double>::iterator match;                     //interator迭代器,可以把它当做指向所属容器的指针
        for( a= 0 ; a < xunlianshuliang; a++)       
    {
            //分别求P(Xk|Q1)中 ,P(Xk|Q2)中和 P(Xk|Q3) 中Xk的个数


    if(xunlianshuju[a].M1 == 1)                          
    {
    int b=0;
    for(;b< 13 ;b++)
    {
    double n = *(&xunlianshuju[b].M2+b);        //n为指向依次指向13个属性的属性内容

    match = Q1_map[b].find(n);                  //遍历第一类红酒的数组,用find()函数返回一个迭代器指向键值为n的元素
    if(match == Q1_map[b].end())
    {    

                        Q1_map[b].insert(pair<double, double>(n, 1));    //在第一类红酒的表Q1_map中用insert插入pair数据
    }
    else
    {
    double b = match->second;                       //否则的话就指向第2个迭代器
    match->second = b + 1;
    }
    }
    }
            
    if(xunlianshuju[a].M1 == 2)                             
    {
    int b = 0;
    for(;b< 13 ;b++)
    {
    double n = *(&xunlianshuju[a].M2+b);

    match = Q2_map[b].find(n);         //遍历第二类红酒的数组,用find()函数返回一个迭代器指向键值为n的元素                 
    if(match == Q2_map[b].end())
    {

                          Q2_map[b].insert(pair<double, double>(n, 1)); //在第二类红酒的表Q2_map中用insert插入pair数据
    }
    else
    {
    double b = match->second;                       //否则的话就指向第2个迭代器
    match->second = b + 1;
    }
    }
    }


    if(xunlianshuju[a].M1 == 3)                                 
    {
    int b = 0;
    for(;b< 13 ;b++)
    {
    double n = *(&xunlianshuju[a].M2+b);

    match = Q3_map[b].find(n);                             //遍历第三类红酒的各属性值,用find()函数返回一个迭代器指向键值为n的元素  
    if(match == Q3_map[b].end())
    {

                          Q3_map[b].insert(pair<double, double>(n, 1));     //在第三类红酒的表Q3_map中用insert插入pair数据
    }
    else
    {
    double b = match->second;
    match->second = b + 1;
    }
    }
    }
    }


    //计算各自的概率


    for(a = 0; a < shuxingzongshu; a++)
    {
    for(match=Q1_map[a].begin(); match!=Q1_map[a].end(); ++match) 
    {
    double number = match->second;                            
    match->second = (double)number/(double)number1;
    }

    for(match=Q2_map[a].begin(); match!=Q2_map[a].end(); ++match) 
    {
    double number = match->second; 
    match->second = (double)number/(double)number2;
    }


    for(match=Q3_map[a].begin(); match!=Q3_map[a].end(); ++match) 
    {
    double number = match->second; 
    match->second = (double)number/(double)number3;
            }

    }
    }


         //计算后验概率,找出最大值,最大值所对应的那个类即为我们要找的分类



    void houyangailv()                    

    {
    int a,b,c;
    double gailv[3];
       for(a = 0; a<ceshishuliang; a++)
    {
    double pXQ[3]={0,0,0};
    for(b = 0; b < 3; b++)
    {
    map<double, double>::iterator match;

       //计算概率p(X|Q1)


    for(c = 0; c < shuxingzongshu; c++)
    {
    match = Q1_map[c].find(*(&ceshishuju[a].M2+c));
    if(match != Q1_map[c].end())
    {
    pXQ[0] =pXQ[0]+match->second;
    }
    }


    //计算p(Q1)*p(X|Q1)


    gailv[0] = R[0] * pXQ[0];
       
    //计算概率p(X|Q2)
    for(c = 0; c < shuxingzongshu; c++)
    {
    match = Q2_map[c].find(*(&ceshishuju[a].M2+c));
    if(match != Q2_map[c].end())
    {
    pXQ[1] =pXQ[1]+match->second;
    }
    }
                    
    //计算p(Q2)*p(X|Q2)


    gailv[1] = R[1]*pXQ[1];


       //计算概率p(X|Q3)


    for(c = 0; c < shuxingzongshu; c++)
    {
    match = Q3_map[c].find(*(&ceshishuju[a].M2+c));
    if(match != Q3_map[c].end())
    {
    pXQ[2] =pXQ[2]+match->second;
    }
    }


                    //计算p(Q3)*p(X|Q3)


    gailv[2] = R[2]*pXQ[2];

    }
               
      
     //找出计算出的概率最大值
               
     if(gailv[0] > gailv[1] && gailv[0] >gailv[2])
    {   
    cout<<"    "<<1<<"        "<<gailv[0]<<"   "<<gailv[1]<<"         "<<gailv[3]<<"                  "<<gailv[0]<<endl;
    cout<<endl;
    if(ceshishuju[a].M1==1)
       m++;
    }
    else
    {
    if(gailv[1] > gailv[2])
    {
     
     cout<<"    "<<2<<"        "<<gailv[0]<<"          "<<gailv[1]<<"         "<<gailv[3]<<"                  "<<gailv[1]<<endl; 
     cout<<endl;
    if(ceshishuju[a].M1==2)
           m++;
    }
    else
    {  
      
                      cout<<"    "<<3<<"        "<<gailv[0]<<"          "<<gailv[1]<<"        "<<gailv[3]<<"                  "<<gailv[2]<<endl;
                      cout<<endl;
           m++;
    }
    }
    }
    }

    void  main()
    {
    double zhengquelv,cuowulv;
    cout<<endl;


    //输出计算出来的各种分类的信息


            cout<<"分类结果"<<"    "<<"概率1"<<"          "<<"概率2"<<"          "<<"概率3"<<"           "<<"计算出来的概率的最大值"<<endl;
       DataRead(xunlianshuju,"Ttrainingwine.data");
    pusubeiyesi();
    DataRead(ceshishuju,"testwine.data");
    houyangailv();
            zhengquelv=(double)m/60;
    cuowulv=1-zhengquelv;
    cout<<endl<<endl<<endl;


    //输出正确率和错误率


    cout<<"测试样本计算的正确率(百分比):"<<zhengquelv*100<<"%"<<" ,"<<"测试样本计算的错误率(百分比):"<<cuowulv*100<<"%"<<endl;
          
    }


    训练数据集:Ttrainingwine.data

    1,13.71,1.86,2.36,16.6,101,2.61,2.88,.27,1.69,3.8,1.11,4,1035
    1,12.85,1.6,2.52,17.8,95,2.48,2.37,.26,1.46,3.93,1.09,3.63,1015
    1,13.5,1.81,2.61,20,96,2.53,2.61,.28,1.66,3.52,1.12,3.82,845
    1,13.05,2.05,3.22,25,124,2.63,2.68,.47,1.92,3.58,1.13,3.2,830
    1,13.39,1.77,2.62,16.1,93,2.85,2.94,.34,1.45,4.8,.92,3.22,1195
    1,13.3,1.72,2.14,17,94,2.4,2.19,.27,1.35,3.95,1.02,2.77,1285
    1,13.87,1.9,2.8,19.4,107,2.95,2.97,.37,1.76,4.5,1.25,3.4,915
    1,14.02,1.68,2.21,16,96,2.65,2.33,.26,1.98,4.7,1.04,3.59,1035
    1,13.73,1.5,2.7,22.5,101,3,3.25,.29,2.38,5.7,1.19,2.71,1285
    1,13.58,1.66,2.36,19.1,106,2.86,3.19,.22,1.95,6.9,1.09,2.88,1515
    1,13.68,1.83,2.36,17.2,104,2.42,2.69,.42,1.97,3.84,1.23,2.87,990
    1,13.76,1.53,2.7,19.5,132,2.95,2.74,.5,1.35,5.4,1.25,3,1235
    1,13.51,1.8,2.65,19,110,2.35,2.53,.29,1.54,4.2,1.1,2.87,1095
    1,13.48,1.81,2.41,20.5,100,2.7,2.98,.26,1.86,5.1,1.04,3.47,920
    1,13.28,1.64,2.84,15.5,110,2.6,2.68,.34,1.36,4.6,1.09,2.78,880
    1,13.05,1.65,2.55,18,98,2.45,2.43,.29,1.44,4.25,1.12,2.51,1105
    1,13.07,1.5,2.1,15.5,98,2.4,2.64,.28,1.37,3.7,1.18,2.69,1020
    1,14.22,3.99,2.51,13.2,128,3,3.04,.2,2.08,5.1,.89,3.53,760
    1,13.56,1.71,2.31,16.2,117,3.15,3.29,.34,2.34,6.13,.95,3.38,795
    1,13.41,3.84,2.12,18.8,90,2.45,2.68,.27,1.48,4.28,.91,3,1035
    1,13.88,1.89,2.59,15,101,3.25,3.56,.17,1.7,5.43,.88,3.56,1095
    1,13.24,3.98,2.29,17.5,103,2.64,2.63,.32,1.66,4.36,.82,3,680
    1,13.05,1.77,2.1,17,107,3,3,.28,2.03,5.04,.88,3.35,885
    1,14.21,4.04,2.44,18.9,111,2.85,2.65,.3,1.25,5.24,.87,3.33,1080
    1,14.38,3.59,2.28,16,102,3.25,3.17,.27,2.19,4.9,1.04,3.44,1065
    1,13.9,1.68,2.12,16,101,3.1,3.39,.21,2.14,6.1,.91,3.33,985
    1,14.1,2.02,2.4,18.8,103,2.75,2.92,.32,2.38,6.2,1.07,2.75,1060
    1,13.94,1.73,2.27,17.4,108,2.88,3.54,.32,2.08,8.90,1.12,3.1,1260
    1,13.05,1.73,2.04,12.4,92,2.72,3.27,.17,2.91,7.2,1.12,2.91,1150
    1,13.83,1.65,2.6,17.2,94,2.45,2.99,.22,2.29,5.6,1.24,3.37,1265
    1,13.82,1.75,2.42,14,111,3.88,3.74,.32,1.87,7.05,1.01,3.26,1190
    1,13.77,1.9,2.68,17.1,115,3,2.79,.39,1.68,6.3,1.13,2.93,1375
    1,13.74,1.67,2.25,16.4,118,2.6,2.9,.21,1.62,5.85,.92,3.2,1060
    1,13.56,1.73,2.46,20.5,116,2.96,2.78,.2,2.45,6.25,.98,3.03,1120
    1,14.22,1.7,2.3,16.3,118,3.2,3,.26,2.03,6.38,.94,3.31,970
    1,13.29,1.97,2.68,16.8,102,3,3.23,.31,1.66,6,1.07,2.84,1270
    1,13.72,1.43,2.5,16.7,108,3.4,3.67,.19,2.04,6.8,.89,2.87,1285
    2,12.37,1.13,2.16,19,87,3.5,3.1,.19,1.87,4.45,1.22,2.87,420
    2,12.17,1.45,2.53,19,104,1.89,1.75,.45,1.03,2.95,1.45,2.23,355
    2,12.37,1.21,2.56,18.1,98,2.42,2.65,.37,2.08,4.6,1.19,2.3,678
    2,13.11,1.01,1.7,15,78,2.98,3.18,.26,2.28,5.3,1.12,3.18,502
    2,12.37,1.17,1.92,19.6,78,2.11,2,.27,1.04,4.68,1.12,3.48,510
    2,13.34,.94,2.36,17,110,2.53,1.3,.55,.42,3.17,1.02,1.93,750
    2,12.21,1.19,1.75,16.8,151,1.85,1.28,.14,2.5,2.85,1.28,3.07,718
    2,12.29,1.61,2.21,20.4,103,1.1,1.02,.37,1.46,3.05,.906,1.82,870
    2,11.96,1.09,2.3,21,101,3.38,2.14,.13,1.65,3.21,.99,3.13,886
    2,11.84,2.89,2.23,18,112,1.72,1.32,.43,.95,2.65,.96,2.52,500
    2,12.33,.99,1.95,14.8,136,1.9,1.85,.35,2.76,3.4,1.06,2.31,750
    2,12.7,3.87,2.4,23,101,2.83,2.55,.43,1.95,2.57,1.19,3.13,463
    2,12,.92,2,19,86,2.42,2.26,.3,1.43,2.5,1.38,3.12,278
    2,12.72,1.81,2.2,18.8,86,2.2,2.53,.26,1.77,3.9,1.16,3.14,714
    2,12.08,1.13,2.51,24,78,2,1.58,.4,1.4,2.2,1.31,2.72,630
    2,13.05,3.86,2.32,22.5,85,1.65,1.59,.61,1.62,4.8,.84,2.01,515
    2,11.84,.89,2.58,18,94,2.2,2.21,.22,2.35,3.05,.79,3.08,520
    2,12.67,.98,2.24,18,99,2.2,1.94,.3,1.46,2.62,1.23,3.16,450
    2,12.16,1.61,2.31,22.8,90,1.78,1.69,.43,1.56,2.45,1.33,2.26,495
    2,11.65,1.67,2.62,26,88,1.92,1.61,.4,1.34,2.6,1.36,3.21,562
    2,11.64,2.06,2.46,21.6,84,1.95,1.69,.48,1.35,2.8,1,2.75,680
    2,12.08,1.33,2.3,23.6,70,2.2,1.59,.42,1.38,1.74,1.07,3.21,625
    2,12.08,1.83,2.32,18.5,81,1.6,1.5,.52,1.64,2.4,1.08,2.27,480
    2,12,1.51,2.42,22,86,1.45,1.25,.5,1.63,3.6,1.05,2.65,450
    2,12.69,1.53,2.26,20.7,80,1.38,1.46,.58,1.62,3.05,.96,2.06,495
    2,12.29,2.83,2.22,18,88,2.45,2.25,.25,1.99,2.15,1.15,3.3,290
    2,11.62,1.99,2.28,18,98,3.02,2.26,.17,1.35,3.25,1.16,2.96,345
    2,12.47,1.52,2.2,19,162,2.5,2.27,.32,3.28,2.6,1.16,2.63,937
    2,11.81,2.12,2.74,21.5,134,1.6,.99,.14,1.56,2.5,.95,2.26,625
    2,12.29,1.41,1.98,16,85,2.55,2.5,.29,1.77,2.9,1.23,2.74,428
    2,12.37,1.07,2.1,18.5,88,3.52,3.75,.24,1.95,4.5,1.04,2.77,660
    2,12.29,3.17,2.21,18,88,2.85,2.99,.45,2.81,2.3,1.42,2.83,406
    2,12.52,2.43,2.17,21,88,2.55,2.27,.26,1.22,2,.9,2.78,325
    2,11.76,2.68,2.92,20,103,1.75,2.03,.6,1.05,3.8,1.23,2.5,607
    2,11.41,.74,2.5,21,88,2.48,2.01,.42,1.44,3.08,1.1,2.31,434
    2,12.08,1.39,2.5,22.5,84,2.56,2.29,.43,1.04,2.9,.93,3.19,385
    2,11.03,1.51,2.2,21.5,85,2.46,2.17,.52,2.01,1.9,1.71,2.87,407
    2,11.82,1.47,1.99,20.8,86,1.98,1.6,.3,1.53,1.95,.95,3.33,495
    2,12.42,1.61,2.19,22.5,108,2,2.09,.34,1.61,2.06,1.06,2.96,345
    2,12.77,3.43,1.98,16,80,1.63,1.25,.43,.83,3.4,.7,2.12,372
    2,12,3.43,2,19,87,2,1.64,.37,1.87,1.28,.93,3.05,564
    2,11.45,2.4,2.42,20,96,2.9,2.79,.32,1.83,3.25,.8,3.39,625
    2,12.04,4.3,2.38,22,80,2.1,1.75,.42,1.35,2.6,.79,2.57,580
    3,12.81,2.31,2.4,24,98,1.15,1.09,.27,.83,5.7,.66,1.36,560
    3,12.7,3.55,2.36,21.5,106,1.7,1.2,.17,.84,5,.78,1.29,600
    3,12.51,1.24,2.25,17.5,85,2,.58,.6,1.25,5.45,.75,1.51,650
    3,12.6,2.46,2.2,18.5,94,1.62,.66,.63,.94,7.1,.73,1.58,695
    3,12.25,4.72,2.54,21,89,1.38,.47,.53,.8,3.85,.75,1.27,720
    3,12.53,5.51,2.64,25,96,1.79,.6,.63,1.1,5,.82,1.69,515
    3,13.49,3.59,2.19,19.5,88,1.62,.48,.58,.88,5.7,.81,1.82,580
    3,12.84,2.96,2.61,24,101,2.32,.6,.53,.81,4.92,.89,2.15,590
    3,12.93,2.81,2.7,21,96,1.54,.5,.53,.75,4.6,.77,2.31,600
    3,13.36,2.56,2.35,20,89,1.4,.5,.37,.64,5.6,.7,2.47,780
    3,13.52,3.17,2.72,23.5,97,1.55,.52,.5,.55,4.35,.89,2.06,520
    3,13.62,4.95,2.35,20,92,2,.8,.47,1.02,4.4,.91,2.05,550
    3,12.25,3.88,2.2,18.5,112,1.38,.78,.29,1.14,8.21,.65,2,855
    3,13.16,3.57,2.15,21,102,1.5,.55,.43,1.3,4,.6,1.68,830
    3,13.88,5.04,2.23,20,80,.98,.34,.4,.68,4.9,.58,1.33,415
    3,12.87,4.61,2.48,21.5,86,1.7,.65,.47,.86,7.65,.54,1.86,625
    3,13.32,3.24,2.38,21.5,92,1.93,.76,.45,1.25,8.42,.55,1.62,650
    3,13.08,3.9,2.36,21.5,113,1.41,1.39,.34,1.14,9.40,.57,1.33,550
    3,13.5,3.12,2.62,24,123,1.4,1.57,.22,1.25,8.60,.59,1.3,500
    3,12.79,2.67,2.48,22,112,1.48,1.36,.24,1.26,10.8,.48,1.47,480
    3,13.11,1.9,2.75,25.5,116,2.2,1.28,.26,1.56,7.1,.61,1.33,425
    3,13.23,3.3,2.28,18.5,98,1.8,.83,.61,1.87,10.52,.56,1.51,675
    3,12.58,1.29,2.1,20,103,1.48,.58,.53,1.4,7.6,.58,1.55,640
    3,13.17,5.19,2.32,22,93,1.74,.63,.61,1.55,7.9,.6,1.48,725
    3,13.84,4.12,2.38,19.5,89,1.8,.83,.48,1.56,9.01,.57,1.64,480
    3,12.45,3.03,2.64,27,97,1.9,.58,.63,1.14,7.5,.67,1.73,880
    3,14.34,1.68,2.7,25,98,2.8,1.31,.53,2.7,13,.57,1.96,660
    3,14.16,2.51,2.48,20,91,1.68,.7,.44,1.24,9.7,.62,1.71,660
    3,13.71,5.65,2.45,20.5,95,1.68,.61,.52,1.06,7.7,.64,1.74,740
    3,13.4,3.91,2.48,23,102,1.8,.75,.43,1.41,7.3,.7,1.56,750
    3,13.27,4.28,2.26,20,120,1.59,.69,.43,1.35,10.2,.59,1.56,835
    3,13.17,2.59,2.37,20,120,1.65,.68,.53,1.46,9.3,.6,1.62,840
    3,14.13,4.1,2.74,24.5,96,2.05,.76,.56,1.35,9.2,.61,1.6,560
    3,13.45,3.7,2.6,23,111,1.7,.92,.43,1.46,10.68,.85,1.56,695
    3,12.82,3.37,2.3,19.5,88,1.48,.66,.4,.97,10.26,.72,1.75,685
    3,13.58,2.58,2.69,24.5,105,1.55,.84,.39,1.54,8.66,.74,1.8,750
    3,13.4,4.6,2.86,25,112,1.98,.96,.27,1.11,8.5,.67,1.92,630
    3,12.2,3.03,2.32,19,96,1.25,.49,.4,.73,5.5,.66,1.83,510


    测试数据集:testwine.data

    1,13.16,2.36,2.67,18.6,101,2.8,3.24,.3,2.81,5.68,1.03,3.17,1185
    1,12.93,3.8,2.65,18.6,102,2.41,2.41,.25,1.98,4.5,1.03,3.52,770
    1,14.23,1.71,2.43,15.6,127,2.8,3.06,.28,2.29,5.64,1.04,3.92,1065
    1,13.2,1.78,2.14,11.2,100,2.65,2.76,.26,1.28,4.38,1.05,3.4,1050
    1,13.16,2.36,2.67,18.6,101,2.8,3.24,.3,2.81,5.68,1.03,3.17,1185
    1,12.93,3.8,2.65,18.6,102,2.41,2.41,.25,1.98,4.5,1.03,3.52,770
    1,13.71,1.86,2.36,16.6,101,2.61,2.88,.27,1.69,3.8,1.11,4,1035
    1,12.85,1.6,2.52,17.8,95,2.48,2.37,.26,1.46,3.93,1.09,3.63,1015
    1,13.5,1.81,2.61,20,96,2.53,2.61,.28,1.66,3.52,1.12,3.82,845
    1,13.05,2.05,3.22,25,124,2.63,2.68,.47,1.92,3.58,1.13,3.2,830
    1,13.39,1.77,2.62,16.1,93,2.85,2.94,.34,1.45,4.8,.92,3.22,1195
    1,13.3,1.72,2.14,17,94,2.4,2.19,.27,1.35,3.95,1.02,2.77,1285
    1,13.87,1.9,2.8,19.4,107,2.95,2.97,.37,1.76,4.5,1.25,3.4,915
    1,14.02,1.68,2.21,16,96,2.65,2.33,.26,1.98,4.7,1.04,3.59,1035
    1,13.73,1.5,2.7,22.5,101,3,3.25,.29,2.38,5.7,1.19,2.71,1285
    1,13.58,1.66,2.36,19.1,106,2.86,3.19,.22,1.95,6.9,1.09,2.88,1515
    1,13.68,1.83,2.36,17.2,104,2.42,2.69,.42,1.97,3.84,1.23,2.87,990
    1,13.76,1.53,2.7,19.5,132,2.95,2.74,.5,1.35,5.4,1.25,3,1235
    1,13.51,1.8,2.65,19,110,2.35,2.53,.29,1.54,4.2,1.1,2.87,1095
    1,13.48,1.81,2.41,20.5,100,2.7,2.98,.26,1.86,5.1,1.04,3.47,920
    2,12.64,1.36,2.02,16.8,100,2.02,1.41,.53,.62,5.75,.98,1.59,450
    2,13.67,1.25,1.92,18,94,2.1,1.79,.32,.73,3.8,1.23,2.46,630
    2,12.37,.94,1.36,10.6,88,1.98,.57,.28,.42,1.95,1.05,1.82,520
    2,12.33,1.1,2.28,16,101,2.05,1.09,.63,.41,3.27,1.25,1.67,680
    2,12.64,1.36,2.02,16.8,100,2.02,1.41,.53,.62,5.75,.98,1.59,450
    2,13.67,1.25,1.92,18,94,2.1,1.79,.32,.73,3.8,1.23,2.46,630
    2,12.37,1.13,2.16,19,87,3.5,3.1,.19,1.87,4.45,1.22,2.87,420
    2,12.17,1.45,2.53,19,104,1.89,1.75,.45,1.03,2.95,1.45,2.23,355
    2,12.37,1.21,2.56,18.1,98,2.42,2.65,.37,2.08,4.6,1.19,2.3,678
    2,13.11,1.01,1.7,15,78,2.98,3.18,.26,2.28,5.3,1.12,3.18,502
    2,12.37,1.17,1.92,19.6,78,2.11,2,.27,1.04,4.68,1.12,3.48,510
    2,13.34,.94,2.36,17,110,2.53,1.3,.55,.42,3.17,1.02,1.93,750
    2,12.21,1.19,1.75,16.8,151,1.85,1.28,.14,2.5,2.85,1.28,3.07,718
    2,12.29,1.61,2.21,20.4,103,1.1,1.02,.37,1.46,3.05,.906,1.82,870
    2,11.96,1.09,2.3,21,101,3.38,2.14,.13,1.65,3.21,.99,3.13,886
    2,11.84,2.89,2.23,18,112,1.72,1.32,.43,.95,2.65,.96,2.52,500
    2,12.33,.99,1.95,14.8,136,1.9,1.85,.35,2.76,3.4,1.06,2.31,750
    2,12.7,3.87,2.4,23,101,2.83,2.55,.43,1.95,2.57,1.19,3.13,463
    2,12,.92,2,19,86,2.42,2.26,.3,1.43,2.5,1.38,3.12,278
    2,12.72,1.81,2.2,18.8,86,2.2,2.53,.26,1.77,3.9,1.16,3.14,714
    3,12.86,1.35,2.32,18,122,1.51,1.25,.21,.94,4.1,.76,1.29,630
    3,12.88,2.99,2.4,20,104,1.3,1.22,.24,.83,5.4,.74,1.42,530
    3,12.86,1.35,2.32,18,122,1.51,1.25,.21,.94,4.1,.76,1.29,630
    3,12.88,2.99,2.4,20,104,1.3,1.22,.24,.83,5.4,.74,1.42,530
    3,12.81,2.31,2.4,24,98,1.15,1.09,.27,.83,5.7,.66,1.36,560
    3,12.7,3.55,2.36,21.5,106,1.7,1.2,.17,.84,5,.78,1.29,600
    3,12.51,1.24,2.25,17.5,85,2,.58,.6,1.25,5.45,.75,1.51,650
    3,12.6,2.46,2.2,18.5,94,1.62,.66,.63,.94,7.1,.73,1.58,695
    3,12.25,4.72,2.54,21,89,1.38,.47,.53,.8,3.85,.75,1.27,720
    3,12.53,5.51,2.64,25,96,1.79,.6,.63,1.1,5,.82,1.69,515
    3,13.49,3.59,2.19,19.5,88,1.62,.48,.58,.88,5.7,.81,1.82,580
    3,12.84,2.96,2.61,24,101,2.32,.6,.53,.81,4.92,.89,2.15,590
    3,12.93,2.81,2.7,21,96,1.54,.5,.53,.75,4.6,.77,2.31,600
    3,13.36,2.56,2.35,20,89,1.4,.5,.37,.64,5.6,.7,2.47,780
    3,13.52,3.17,2.72,23.5,97,1.55,.52,.5,.55,4.35,.89,2.06,520
    3,13.62,4.95,2.35,20,92,2,.8,.47,1.02,4.4,.91,2.05,550
    3,12.25,3.88,2.2,18.5,112,1.38,.78,.29,1.14,8.21,.65,2,855
    3,13.16,3.57,2.15,21,102,1.5,.55,.43,1.3,4,.6,1.68,830
    3,13.88,5.04,2.23,20,80,.98,.34,.4,.68,4.9,.58,1.33,415
    3,12.87,4.61,2.48,21.5,86,1.7,.65,.47,.86,7.65,.54,1.86,625


    实验贴图:














    展开全文
  • 1.导入load_wine数据集 from sklearn.datasets import load_wine # data是一种bunch对象 含有键值对 data = load_wine() # print(data) print(data.keys()) # print(data['data'].shape) # print(data['DESCR']) ...
  • seeds、wine数据集arff版

    2018-03-18 10:11:32
    wine、seeds的arrf版本,可用于聚类分析或者分类分析的性能判断。
  • C4.5 决策树算法对UCI wine数据集分类的实现(MATLAB)

    万次阅读 多人点赞 2018-07-11 14:18:13
    本文实现了利用决策树算法对UCI 机器学习库上的经典wine数据集进行分类的目的。为达到相应的分类目的,需要先对数据集样本进行分析。表1 wine数据集样本特征不用化学成分的含量与酒的所属类别息息...
  • 基于朴素贝叶斯的wine数据集分类预测-机器学习实验-朴素贝叶斯 公众号:我是TIME0101 回复:贝叶斯 即可获取源码
  • [机器学习笔记]k-means实战 (以wine数据集为例)

    万次阅读 多人点赞 2019-09-19 23:12:12
    本博客将以wine数据集,一步一步的演示K-means实战的全过程,让大家学会和使用k-means方法进行聚类(本人也是初学伊始,大佬勿锤) 1.数据集来源 特征分别为:酒精 苹果酸 艾熙 灰分碱性 镁 总酚类 黄酮类 非...
  • 决策树实例-红酒数据集 无参数模型 from sklearn import tree from sklearn.datasets import load_wine from sklearn.model_selection import train_test_split import pandas as pd wine = load_wine() df1 = pd....

空空如也

空空如也

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

wine数据集