精华内容
下载资源
问答
  • BP算法鸢尾花分类
    2020-12-16 20:30:17

    BP算法鸢尾花分类

    网上很多鸢尾花例子,学习其他人后仿写,我在运行其他人的时候会有溢出和错误。

    下述代码准确率95%

    附鸢尾花数据集链接:https://pan.baidu.com/s/1J3-2INUT19BVZWCUet3X6A

    提取码:y07d

    如果有什么不对的或者有什么不懂Iamzhubaoliang@yeah.net

    工程地址https://git.lug.ustc.edu.cn/Iamzhubaoliang/irissort

    import math

    import random

    import pandas as pd

    random.seed(0)

    def rand(a,b):

    return (b-a)*random.random()+a

    def dsigmoid(x):

    return x*(1-x)

    def sigmoid(gamma):

    if gamma < 0:

    return 1 - 1/(1 + math.exp(gamma))

    else:

    return 1/(1 + math.exp(-gamma))

    def makematrix(I,J):

    m = []

    for i in range(I):

    m.append([0.0]*J)#一维构造二维

    return m

    class BP:

    ''' 三层BP网络'''

    def __init__(self,ni,nh,no):

    self.ni=ni+1

    self.nh=nh+1

    self.no=no

    self.ai=[1.0]*self.ni

    self.ah=[1.0]*self.nh

    self.ao=[1.0]*self.no

    self.wi=makematrix(self.ni,self.nh)

    self.wo=makematrix(self.nh,self.no)

    for i in range(self.ni):

    for j in range(self.nh):

    self.wi[i][j]=rand(-2,2)

    for i in range(self.nh):

    for j in range(self.no):

    self.wo[i][j]=rand(-2,2)

    def Forward(self,input):

    for i in range(self.ni-1):

    self.ai=input

    for i in range(self.nh):

    sum=0.0

    for j in range(self.ni-1):

    #print(self.ai[j])

    sum+=self.wi[j][i]*self.ai[j]

    self.ah[i]=sigmoid(sum)

    for i in range(self.no):

    sum=0.0

    for j in range(self.no):

    sum+=self.wo[j][i]*self.ah[j]

    self.ao[i]=sigmoid(sum)

    return self.ao

    def backward(self,tartget,lv):

    rerror=0.0

    outerror=[1.0]*self.no

    for i in range(self.no):

    error=tartget[i]-self.ao[i]

    rerror=error

    outerror[i]=dsigmoid(self.ao[i])*error

    herror=[1.0]*self.nh

    for i in range(self.nh):

    error=0.0

    for j in range(self.no):

    error+=outerror[j]*self.wo[i][j]

    herror[i]=dsigmoid(self.ah[i])*error

    for i in range(self.nh):

    for j in range(self.no):

    change=outerror[j]*self.ah[i]

    self.wo[i][j]=self.wo[i][j]+lv*change

    for i in range(self.ni-1):

    for j in range(self.nh):

    change=herror[j]*self.ai[i]

    self.wi[i][j]=self.wi[i][j]+lv*change

    error = 0.0

    error += 0.5 * rerror ** 2

    return error

    def train(self, patterns, iterations, lr=0.009):

    # lr: 学习速率(learning rate)

    for i in range(iterations):

    error = 0.0

    for p in patterns:

    inputs = p[0]

    targets = p[1]

    #print(inputs, ",", p[1])

    self.Forward(inputs)

    error = error + self.backward(targets, lr)

    if i%100==0:

    print('error: %-.9f' % error)

    def test(self,patterns):

    count=0

    for p in patterns:

    target=p[1]

    #print(target)

    result=self.Forward(p[0])

    index = result.index(max(result))

    if index==0 and target==[1,0,0]:

    count=count+1

    elif index==1 and target==[0,1,0]:

    count=count+1

    elif index==2 and target==[0,0,1]:

    count = count + 1

    accuracy = float(count / len(patterns))

    print('accuracy: %-.9f' % accuracy)

    def iris():

    data=[]

    raw=pd.read_csv('iris.csv')

    raw_data=raw.values

    raw_feature=raw_data[:,1:6]

    print(raw_feature)

    for i in range(len(raw_feature)):

    ele=[]

    ele.append(raw_feature[i])

    if raw_data[i][5]=='setosa':

    ele.append([1,0,0])

    elif raw_data[i][5]=='versicolor':

    ele.append([0,1,0])

    else:

    ele.append([0,0,1])

    print(ele)

    data.append(ele)

    random.shuffle(data)

    trainning=data[0:100]

    test=data[101:]

    nn=BP(4,7,3)

    nn.train(data,10000)

    nn.test(test)

    if __name__ == '__main__':

    iris()1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66

    67

    68

    69

    70

    71

    72

    73

    74

    75

    76

    77

    78

    79

    80

    81

    82

    83

    84

    85

    86

    87

    88

    89

    90

    91

    92

    93

    94

    95

    96

    97

    98

    99

    100

    101

    102

    103

    104

    105

    106

    107

    108

    109

    110

    111

    112

    113

    114

    115

    116

    117

    118

    119

    120

    121

    122

    123

    124

    125

    126

    127

    128

    129

    130

    131

    132

    133

    134

    135

    136

    137

    138

    139

    140

    141

    更多相关内容
  • 该文件包含鸢尾花分类Python源程序和数据集,数据集内包含 3 类鸢尾花,分别为山鸢尾(setosa)、变色鸢尾(versicolor)和维吉尼亚鸢尾(virginica)。每类各 50 个数据,每条记录有 4 项特征:花萼长度、花萼...
  • 主要介绍了python KNN算法实现鸢尾花数据集分类,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 目标值为三种不同类别的鸢尾花,分别为: Iris Setosa、Iris Versicolour、Iris Virginica 数据集中每朵鸢尾花叫做一个数据点,它的品种叫做它的标签 数据集样式: 导入需要的模块包 import numpy as np from ...
  • 文章目录数据选取和数据情况利用C4.5算法分类离散化连续变量C4.5原理C4.5实现应用训练好的决策树分类 数据选取和数据情况 本次实验选取鸢尾花数据集(http://archive.ics.uci.edu/ml/datasets/Iris) 数据包含5列,...
  • Python鸢尾花分类实现

    2021-04-28 09:49:00
    ") [Python]基于K-Nearest Neighbors[K-NN]算法鸢尾花分类问题解决方案 看了原理,总觉得需要用具体问题实现一下机器学习算法的模型,才算学习深刻.而写此博文的目的是,网上关于K-NN解决此问题的博文很多,但大都是...

    #coding:utf-8

    from sklearn.datasets import load_iris

    from sklearn.model_selection import train_test_split

    from sklearn.neighbors import KNeighborsClassifier

    import numpy as np

    import matplotlib.pyplot as plt

    iris_dataset = load_iris() # 获取数据

    # print("keys of iris_dataset:\n{}".format(iris_dataset.keys()))

    # print(iris_dataset["DESCR"][:193]+"\n...")

    # print("target names:{}".format(iris_dataset["target_names"]))

    # print("feature names:{}".format(iris_dataset["feature_names"]))

    # print(iris_dataset["data"][:5])

    # print(iris_dataset["data"], iris_dataset["target"])

    # 对数据进行拆分,分为训练数据和测试数据

    x_train, x_test, y_train, y_test = train_test_split(iris_dataset["data"], iris_dataset["target"], random_state=0)

    # print(x_train, x_test, y_train, y_test)

    knn = KNeighborsClassifier(n_neighbors=1) # 获取KNN对象

    knn.fit(x_train, y_train) # 训练模型

    # 评估模型

    y_pre = knn.predict(x_test)

    score = knn.score(x_test, y_test) # 调用打分函数

    print("test set predictions:\n{}".format(y_test))

    print("test set score:{:.2f}".format(score))

    if score > 0.9:

    x_new = np.array([[5, 2.9, 1, 0.3]])

    print("x_new.shape:{}".format(x_new.shape))

    prediction = knn.predict(x_new) # 预测

    print("prediction:{}".format(prediction))

    print("predicted target name:{}".format(iris_dataset["target_names"][prediction]))

    # 可视化展示

    plt.title("KNN Classification")

    plt.plot(x_train, y_train, "b.") # 训练数据打点

    plt.plot(x_test, y_test, "y.") # 测试数据打点

    plt.plot(x_new, prediction, "ro") # 预测数据打点

    plt.show()

    else:

    print("used train or test data is not available !")

    71af6c5da7488dbc4ecfd0e45535cfa2.png

    908efc10459df82e6c9256f2c3938df0.png

    &lbrack;Python&rsqb;基于K-Nearest Neighbors&lbrack;K-NN&rsqb;算法的鸢尾花分类问题解决方案

    看了原理,总觉得需要用具体问题实现一下机器学习算法的模型,才算学习深刻.而写此博文的目的是,网上关于K-NN解决此问题的博文很多,但大都是调用Python高级库实现,尤其不利于初级学习者本人对模型的理 ...

    pytorch解决鸢尾花分类

    半年前用numpy写了个鸢尾花分类200行..每一步计算都是手写的  python构建bp神经网络_鸢尾花分类 现在用pytorch简单写一遍,pytorch语法解释请看上一篇pytorch搭建简单网 ...

    02-15 Logistic回归&lpar;鸢尾花分类&rpar;

    目录 Logistic回归(鸢尾花分类) 一.导入模块 二.获取数据 三.构建决策边界 四.训练模型 4.1 C参数与权重系数的关系 五.可视化 更新.更全的的更新网站,更有p ...

    02-19 k近邻算法&lpar;鸢尾花分类&rpar;

    [TOC] 更新.更全的的更新网站,更有python.go.数据结构与算法.爬虫.人工智能教学等着你:https://www.cnblogs.com/nickchen121/ ...

    02-20 kd树&lpar;鸢尾花分类&rpar;

    [TOC] 更新.更全的的更新网站,更有python.go.数据结构与算法.爬虫.人工智能教学等着你:https://www.cnblogs.com/nickchen121/ ...

    04-04 AdaBoost算法代码&lpar;鸢尾花分类&rpar;

    目录 AdaBoost算法代码(鸢尾花分类) 一.导入模块 二.导入数据 三.构造决策边界 四.训练模型 4.1 训练模型(n_e=10, l_r=0.8) 4.2 可视化 4.3 训练模型(n_es ...

    ML&period;NET 示例:多类分类之鸢尾花分类

    写在前面 准备近期将微软的machinelearning-samples翻译成中文,水平有限,如有错漏,请大家多多指正. 如果有朋友对此感兴趣,可以加入我:https://github.com/fei ...

    python 文本分类

    python 文本分类 pyhton 机器学习 待续...

    13、Selenium&plus;python&plus;API分类总结

    Selenium+python+API分类总结 http://selenium-python.readthedocs.org/index.html 分类 方法 方法描述 客户端操作 __init__( ...

    随机推荐

    值得注意的IsHitTestVisible

    这个属性我们平时可能并不怎么用.先来看下MSDN上的解释: 解释的非常专业,然而我并没有看懂. 说说我的理解吧:把这个属性设置为false,看起来没有变化,但操作上已经把他完全忽视了,不触发事件,可以 ...

    linux中档案类型

    我们用ls-l命令时,在第一列的第一个字符表示是档案类型.如: 那d和-等这些都表示什么呢? [ d ]-------目录 [ - ]--------文件 [ l ]---------连结档(link ...

    React常用的API说明

    楼主刚开始学习react,感受到了他的博大精深,看到很多莫名的用法,不知云云,找了很多没有找到参考手册,只有在中文社区和react官方看了一些,收集了一些比较常用的API,有补充的可以楼下评论补充.后 ...

    Rubinius 2&period;0 发布,Ruby 虚拟机

    Rubinius 2.0 发布了,官方发行说明请看这里. Rubinius是一个运行Ruby程序的虚拟机,其带有Ruby的核心库. Rubinius的设计决定了其调试功能的强大,使得在运行时常规的Ru ...

    Linux源代码分析工具链

    前言 看源代码是一个程序员必须经历的事情,也是可以提升能力的一个捷径.个人认为: 要完全掌握一个软件的方法只有阅读源码. 在Windows下有sourceinsight这个源码阅读软件(虽然我没用过, ...

    C&num; 窗体间传值方法大汇总

    第一种方法:创建一个类,里面声明用于存储接收的字段.传的时候存储于字段中,要用的时候,直接类名.字段名 进行调用.(这种方法传递是双向的) 第二种方法:1.在Form1里定义 public strin ...

    debug连线指令

    -當發現原本正常的連線突然斷線的,請用底下的指令debug 1.ifconfig      (看看IPaddress) 2.wpa_clira stat   (看看連線狀態) 3.如果是在連線中(wp ...

    DOM对象本身也是一个js对象,所以严格来说,并不是操作这个对象慢,而是说操作了这个对象后,会触发一些浏览器行为(转)

    一直都听说DOM很慢,要尽量少的去操作DOM,于是就想进一步去探究下为什么大家都会这样说,在网上学习了一些资料,这边整理出来. 首先,DOM对象本身也是一个js对象,所以严格来说,并不是操作这个对象慢 ...

    vs2013执行Add-Migration出现的问题

    1. 无法将"Add-Migration"项识别为 cmdlet.函数.脚本文件或可运行程序的名称.请检查名称的拼写,如果包括路径,请确保路径正确,然后再试一次 网上解决方法为:h ...

    展开全文
  • 主要介绍了python实现鸢尾花三种聚类算法(K-means,AGNES,DBScan),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • KNN实现鸢尾花分类

    2019-05-17 10:49:28
    knn的python代码 #样本数据150*4二维数据,代表150个样本, #每个样本4个属性分别为花瓣和花萼的长、宽
  • 本文详细介绍了决策树算法的原理,构造,交叉验证等知识点。并通过鸢尾花数据集进行了决策树算法分类与预测,对算法的函数用法进行了详细的介绍。

    决策树算法

    原理

    决策树是一种比较常用的分类算法,理解相对容易,所谓决策树分类就是用决策条件构成的一个树状预测模型,通过这个模型,我们可以对未知类别的数据进行分类。
    例如:(评选三好学生)
    在考虑某位同学是否有资格成为三好学生时,可能分别考虑他的品德,成绩,体育三个方面。
    在这里插入图片描述
    上述例子就不多于赘述,相信大家都能看明白。通过这个例子我们大概知道,决策树是一种树形结构,其中每个节点表示一个属性的测试;每个分支代表一个测试输出,每个叶子节点代表一种类别。

    决策树的构造

    使用属性选择度量来选择将元组最好地划分成不同的类的属性,进行属性选择度量确定各个特征属性之间的拓扑结构。
    关键步骤:分裂属性。

    分裂属性

    分裂属性就是在某个节点处按照某一特征属性的不同划分构造不同的分支,其目标是让各个分裂子集尽可能地“纯”。尽可能“纯”就是尽量让一个分裂子集中待分类项属于同一类别。
    分裂属性分为三种不同的情况:

    1. 属性是离散值且不要求生成二叉决策树。此时用属性的每一个划分作为一个分支。
    2. 属性是离散值且要求生成二叉决策树。此时使用属性划分的一个子集进行测试,按照“属于此子集”和“不属于此子集”分成两个分支。
    3. 属性是连续值。此时确定一个值作为分裂点split point,按照>split point和<=split point生成两个分支。

    属性选择度量

    关键性内容:进行属性选择度量,
    属性选择度量是一种选择分裂准则,是将给定了类标记的训练集合划分,“最好”地分成个体类的启发式方法,它决定了拓扑结构及分裂点split point的选择。属性选择度量算法有很多,一般使用自顶向下递归分治法,并采用不回溯的贪心策略。
    常用的算法:

    1. ID3
    2. C4.5。

    剪枝

    在实际构造决策树时,通常要进行剪枝,这是为了处理由于数据中的噪声和离群点导致的过分拟合问题。
    剪枝有两种:

    1. 先剪枝——在构造过程中,当某个节点满足剪枝条件,则直接停止此分支的构造
    2. 后剪枝——先构造完成完整的决策树,再通过某些条件遍历树进行剪枝。

    交叉验证

    ( 将数据集分为测试集和训练集。)
    因为在实际的训练中,训练的结果对于训练集的拟合程度通常还是挺好的(初试条件敏感),但是对于训练集之外的数据的拟合程度通常就不那么令人满意了。因此我们通常并不会把所有的数据集都拿来训练,而是分出一部分来(这一部分不参加训练)对训练集生成的参数进行测试,相对客观的判断这些参数对训练集之外的数据的符合程度。

    函数介绍

    train_test_split函数

    是交叉验证中常用的函数,它能从样本中按比例随机选取训练集和测试集。
    其用法如下:
    X_train,X_test,y_train,y_test=cross_validation.train_test_split(train_data,train_target,test_size=0.25,random_state=None)
    参数解释:

    1. train_data: 所要划分的样本特征集。
    2. train_target: 所要划分的样本结果。
    3. test_size: 样本占比,如果是整数的话就是样本的数量。
    4. random_state: 是随机数的种子。

    tree.DecisionTreeClassifier函数

    DecisionTreeClassifier函数用于创建决策树分类器。
    其用法如下:
    clf = tree.DecisionTreeClassifier()
    常用参数解释:

    1. criterion: string类型,可选(默认为"gini")。指定使用哪种方法衡量分类的质量。支持的标准有"gini"代表的是Gini impurity(不纯度)与"entropy"代表的是information gain(信息增益)。
    2. splitter: string类型,可选(默认为"best")。指定在节点中选择分类的策略。支持的策略有"best",选择最好的分类,"random"选择最好的随机分类。
    3. max_depth: int or None,可选(默认为"None")。表示树的最大深度。
    4. min_samples_split: int,float,可选(默认为2)。一个内部节点需要的最少的样本数。
    5. max_features: int,float,string or None类型,可选(默认为None)。在进行分类时需要考虑的特征数。
    6. random_state: 可为int类型,RandomState 实例或None,可选(默认为"None")。如果是int,random_state 是随机数字发生器的种子;如果是RandomState,random_state是随机数字发生器,如果是None,随机数字发生器是np.random使用的RandomState instance.

    数据说明

    iris数据集是一个经典的用于多类分类的数据集。
    通过sklearn.datasets.load_iris()函数可导入。
    sklearn中的iris数据集有5个key,分别如下:

    1. target_names: 类别名称,分别为setosa、versicolor和virginica;
    2. data:特征集,5列,150行;
    3. target: 样本类别值;
    4. DESCR:关于数据的描述信息;
    5. feature_names:特征名称,分别为sepallength(cm),sepalwidth(cm),petal length (cm)和petal width (cm)。

    决策树分类

    利用决策树算法分类鸢尾花数据。

    from sklearn import tree
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    import numpy as np
    if __name__=="__main__":
        # 加载数据
        dataset = load_iris()
         # 提取属性数据
        X = dataset.data
        # 提取标签数据
        y = dataset.target 
          # train_test_split函数用于划分数据集为训练集和测试集,其中参数test_size默认为0.25,表示将25%的数据划分为测试集
        Xd_train, Xd_test, y_train, y_test = train_test_split(X, y, random_state=14)
          # 创建决策树分类器
        clf = tree.DecisionTreeClassifier()
        # 训练分类器模型
        clf = clf.fit(Xd_train, y_train)
        y_predicted = clf.predict(Xd_test)  
        
        # 计算预测准确率  
        accuracy = np.mean(y_predicted == y_test) * 100
        
        print ("y_test\n",y_test)
        print ("y_predicted\n",y_predicted)
        print ("accuracy:",accuracy)    
    

    代码运行结果:
    在这里插入图片描述
    测试集与预测出来的数据差别不大,正确率为97.37%

    展开全文
  • 使用SVM支持向量机进行鸢尾花分类_Python实现-附件资源
  • 本文将使用感知机模型,对鸢尾花进行分类,并调整参数,对比分类效率。 1. 感知机简介 感知机(perceptron)是二类分类的线性分类模型 输入:实例的特征向量 输出:实例的类别,取 +1 和 -1 二值 感知机对应于输入...
  • 鸢尾花卉数据集,是一类多重变量分析的数据集。通过花萼长度,花萼宽度,花瓣长度,花瓣宽度4个属性预测鸢尾花卉属于(Setosa,Versicolour,Virginica)三个种类中的哪一类。是机器学习基础学习的典型案例。
  • Python机器学习日记——鸢尾花分类书目与章节软件及版本鸢尾花数据集导入库数据集介绍 书目与章节 拜读的是这本《Python机器学习基础教程》,本文选自第一章引言的1.7第一个应用:鸢尾花分类。 软件及版本 ...

    一、书目与章节

    在这里插入图片描述
    拜读的是这本《Python机器学习基础教程》,本文选自第一章引言,主要内容为:鸢尾花分类入门案例

    本书全部代码:https://github.com/amueller/introduction_to_ml_with_python

    二、 前言

    1. 什么是机器学习

    机器学习(machine learnin)是从数据中提取知识。它是统计学、人工智能、和计算机科学交叉的研究领域,也被称为预测分析(predictive analytics)或统计学习(statistical learning)

    2. 熟悉任务和数据

    机器学习中最重要的一部分是理解手头上在处理的数据!以及这些数据与需要解决的问题间的关系!随机选择一个算法并输入数据,这样做是无效的。因此,在建模前理解数据集的内容极其重要!每种算法输入数据类型和最合适解决的问题都是不一样的。以下几个问题都是我们需要预先思考的:

    • 需要解决什么问题?现有数据可否解决?
    • 用什么机器学习方法最好?
    • 提取了什么数据特征?这些特征可否实现正确预测?
    • 如何衡量应用是否成功?
    • 机器学习解决方案与我的研究或商业产品中的其他部分是如何相互影响的?

    3. 本文软件版本

    Anaconda3 2021.05

    import sys
    print(f"Python version:{sys.version}")
    print("--"*40)
    import sklearn
    print(f"scikit-learn version:{sklearn.__version__}")
    print("--"*40)
    import pandas as pd
    print(f"pandas version:{pd.__version__}")
    print("--"*40)
    import numpy as np
    print(f"numpy version:{np.__version__}")
    print("--"*40)
    import scipy as sp
    print(f"Scipy version:{sp.__version__}")
    print("--"*40)
    import matplotlib
    print(f"matplotlib version:{matplotlib.__version__}")
    print("--"*40)
    
    Python version:3.8.8 (default, Apr 13 2021, 15:08:03) [MSC v.1916 64 bit (AMD64)]
    --------------------------------------------------------------------------------
    scikit-learn version:0.24.1
    --------------------------------------------------------------------------------
    pandas version:1.2.4
    --------------------------------------------------------------------------------
    numpy version:1.20.1
    --------------------------------------------------------------------------------
    Scipy version:1.6.2
    --------------------------------------------------------------------------------
    matplotlib version:3.3.4
    --------------------------------------------------------------------------------
    

    4. scikit-learn参考资料

    scikit-learn是最有名的机器学习库,建议学习参考以下内容:
    scikit-learn文档
    scikit-learn用户指南

    三、 问题类型

    监督学习问题(有已知品种的鸢尾花的测量数据)+ 三分类问题(在三个鸢尾花品种中预测一个)

    四、 鸢尾花数据集

    1. 导入库

    from sklearn.datasets import load_iris
    import numpy as np
    import pandas as pd
    iris = load_iris()
    

    2. 数据集初探

    Iris数据集是常用的分类实验数据集,由Fisher于1936收集整理。Iris也称鸢尾花卉数据集,是一类多重变量分析的数据集。

    load_iris返回的是一个Bunch对象,与字典类似,包含键和值:

    >>> type(iris)
    sklearn.utils.Bunch
    

    查看Bunch的键:

    >>> iris.keys()
    dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names', 'filename'])
    

    下面我们分别来看看这些键中的内容是什么:

    2.1. DESCR

    DESCR键对应的为数据集的基本描述:

    >>> print(iris['DESCR'][0:1210]+"\n...")
    .. _iris_dataset:
    
    Iris plants dataset
    --------------------
    
    **Data Set Characteristics:**
    
        :Number of Instances: 150 (50 in each of three classes)
        :Number of Attributes: 4 numeric, predictive attributes and the class
        :Attribute Information:
            - sepal length in cm
            - sepal width in cm
            - petal length in cm
            - petal width in cm
            - class:
                    - Iris-Setosa
                    - Iris-Versicolour
                    - Iris-Virginica
                    
        :Summary Statistics:
    
        ============== ==== ==== ======= ===== ====================
                        Min  Max   Mean    SD   Class Correlation
        ============== ==== ==== ======= ===== ====================
        sepal length:   4.3  7.9   5.84   0.83    0.7826
        sepal width:    2.0  4.4   3.05   0.43   -0.4194
        petal length:   1.0  6.9   3.76   1.76    0.9490  (high!)
        petal width:    0.1  2.5   1.20   0.76    0.9565  (high!)
        ============== ==== ==== ======= ===== ====================
    
        :Missing Attribute Values: None
        :Class Distribution: 33.3% for each of 3 classes.
        :Creator: R.A. Fisher
        :Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)
        :Date: July, 1988
    ...
    

    2.2. target_names

    target_names中返回的为数据集贡献者所研究的三种鸢尾花的名称,我们称之为“类别”,分别为Iris setosa(山鸢尾)、Iris versicolor(杂色鸢尾)、Iris virginica(维吉尼卡鸢尾):

    >>> print(iris.target_names) #  iris的种类
    ['setosa' 'versicolor' 'virginica']
    

    在这里插入图片描述

    2.3. feature_names

    feature_names中返回的是被研究的鸢尾花的4个“特征值”,分别为“花萼长度”、“花萼宽度”、“花瓣长度”、“花瓣宽度”(以cm为单位):

    >>> print(iris.feature_names)
    ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
    

    2.4. data

    data中返回的是特征值的具体数据(这里仅查看前五行):

    >>> iris.data[:5] # iris_datas.values()
    array([[5.1, 3.5, 1.4, 0.2],
           [4.9, 3. , 1.4, 0.2],
           [4.7, 3.2, 1.3, 0.2],
           [4.6, 3.1, 1.5, 0.2],
           [5. , 3.6, 1.4, 0.2]])
    

    数据类型为numpy.ndarray

    >>> type(iris.data)
    numpy.ndarray
    

    该对象含有150行和4列:

    >>> iris.data.shape
    (150, 4)
    

    机器学习中的个体叫做样本(sample),其属性叫做特征(feature)。data数组的形状(shape)是样本数乘以特征数。

    2.5. target

    target返回的为鸢尾花种类,上述三个种类鸢尾花每种各50个样本,分别用0、1、2指代,:

    >>> iris.target
    array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
           0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
    

    数据类型为numpy.ndarray

    >>> type(iris.target)
    numpy.ndarray
    

    对象的大小为150行的一维数组:

    >>> iris.target.shape   #一维数据,后面是n则是n维数据
    (150,)
    

    2.6. frame

    frame返回值为None

    将数据转为dataframe格式看看(列名为4个特征值,数据部分为特征值的大小,索引被我更改为0,1,2三个类型):

    X = iris.data
    y = iris.target
    df = pd.DataFrame(X, columns= iris.feature_names, index = y)
    df
    

    在这里插入图片描述

    五、衡量模型是否成功

    1. 机器学习目的

    利用现有数据预测新测量的鸢尾花的品种。

    2. 泛化能力

    不能用构建模型的数据用于评估模型,否则模型的“记忆”总会预测正确的标签,无法评价模型的“泛化”能力(指机器学习算法对新鲜样本的适应能力:泛化能力

    3. 训练集与测试集

    因此,需要用新的数据(模型未见过的)来评估模型性能。通常是将现有数据分为两分,一部分用于构建机器学习模型,称为“训练数据/训练集”;另一部分用于评估模型性能,称为“测试数据/测试集”。

    train_test_split函数可以利用“伪随机数生成器”将数据集打乱并拆分:默认75%为训练集,25%为测试集(可以自行定义比例),但是一般为3:1。

    数据通常用大写的X表示,标签小写的y表示。

    from sklearn.model_selection import train_test_split
    X_train, X_test, y_train, y_test = train_test_split(iris_datas['data'],iris_datas['target'],random_state=0)
    

    可见150行数据被顺利拆分,比例为112:38 = 3:1。

    训练数据X_train与训练标签y_train:

    >>> print(f"X_train shape:{X_train.shape}")
    >>> print(f"y_train shape:{y_train.shape}")
    X_train shape:(112, 4)
    y_train shape:(112,)
    

    测试数据X_test与测试标签y_test:

    >>> print(f"X_test shape:{X_test.shape}")
    >>> print(f"y_test shape:{y_test.shape}")
    X_test shape:(38, 4)
    y_test shape:(38,)
    

    查看下y_train,确实被打乱了。

    >>> y_train
    array([1, 1, 2, 0, 2, 0, 0, 1, 2, 2, 2, 2, 1, 2, 1, 1, 2, 2, 2, 2, 1, 2,
           1, 0, 2, 1, 1, 1, 1, 2, 0, 0, 2, 1, 0, 0, 1, 0, 2, 1, 0, 1, 2, 1,
           0, 2, 2, 2, 2, 0, 0, 2, 2, 0, 2, 0, 2, 2, 0, 0, 2, 0, 0, 0, 1, 2,
           2, 0, 0, 0, 1, 1, 0, 0, 1, 0, 2, 1, 2, 1, 0, 2, 0, 2, 0, 0, 2, 0,
           2, 1, 1, 1, 2, 2, 1, 1, 0, 1, 2, 2, 0, 1, 1, 1, 1, 0, 0, 0, 2, 1,
           2, 0])
    

    六、观察数据/检查数据

    构建模型之前,检查数据有以下几个好处:

    1. 帮助我们判断机器学习是否可以轻松完成任务。
    2. 查看需要的信息是否包含于数据中。
    3. 发现异常值和特殊值的好方法。

    最佳方法为“数据可视化”:

    !pip install mglearn
    

    散点矩阵图(pair plot)是个不错的选择,适用于大于三个特征的数据集作图,函数为scatter_matrix

    import mglearn
    iris_dataframe = pd.DataFrame(X_train, columns = iris.feature_names) # 选择的是训练集的数据绘图
    grr = pd.plotting.scatter_matrix(iris_dataframe, c = y_train, figsize = (15,15), marker = 'o',
                                     hist_kwds = {'bins':20}, s = 60, alpha = 0.8, cmap = mglearn.cm3)
    

    矩阵的对角线是每个特征的直方图。
    在这里插入图片描述
    从图中可以观察出,利用花瓣和花萼的数据基本可以将三个类别区分开,这说明机器学习模型很可能可以学会区分它们。

    七、k邻近算法

    1. 模型构建

    选择的是“k邻近分类器”:若要对一个新的数据点做出预测,算法会在训练集中寻找出与这个新数据点距离最近的数据点,然后将找的数据点的标签赋值给这个新数据点。

    其中k的含义为:可以考虑训练集这两个与新数据点最近的任意k个邻居(比如,最近的3个或5个),而非只考虑最近的那一个。接着,用这些邻居中数量最多的类别做出预测。

    from sklearn.neighbors import KNeighborsClassifier
    knn = KNeighborsClassifier(n_neighbors = 1) # 此处设置邻居数目为1
    

    这个模型只需要保存训练集即可:

    >>> knn.fit(X_train,y_train)
    KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
                         metric_params=None, n_jobs=None, n_neighbors=1, p=2,
                         weights='uniform')
    

    2. 进行预测

    假设一朵新发现的鸢尾花的数据为:花萼长5cm宽2.9cm;花瓣长1cm宽0.2cm。将数据保存于NumPy数组中:

    >>> X_new = np.array([[5,2.9,1,0.2]])
    >>> X_new.shape
    (1, 4)
    

    进行预测:

    >>> prediction = knn.predict(X_new)
    >>> print('Prediction:', prediction)
    Prediction: [0]
    

    该新数据的预测结果为setosa:

    >>> print('Predicted target name:',iris['target_names'][prediction])
    Predicted target name: ['setosa']
    

    但我们并不知道是否该去相信这个模型,因此需要对模型的预测准确性进行评估。

    3. 模型评估

    对测试集的数据进行标签预测:

    >>> y_pred = knn.predict(X_test)
    >>> print(y_pred)
    [2 1 0 2 0 2 0 1 1 1 2 1 1 1 1 0 1 1 0 0 2 1 0 0 2 0 0 1 1 0 2 1 0 2 2 1 0
     2]
    

    可以通过计算精度(accuracy)来衡量模型优劣:

    >>> np.mean(y_pred == y_test)
    0.9736842105263158
    

    or

    >>> knn.score(X_test,y_test)
    0.9736842105263158
    

    模型准确率达到了97%以上,说明可信度较高。后续还会学习如何提高准确率,以及调参的注意事项。

    To be continued…

    欢迎继续浏览:第二章监督学习第1、2节

    展开全文
  • 鸢尾花分类 一个简单的机器学习应用,构建第一个模型。 对鸢尾花分类,根据测量数据进行,该测量数据则为特征。测量数据:花瓣的长度和宽度、花萼的长度和宽度,所有测量结果的单位为cm 我们的目标是构建一个机器...
  • BP算法实例—鸢尾花分类Python

    万次阅读 热门讨论 2018-08-06 15:29:13
    首先了解下Iris鸢尾花数据集:  Iris数据集(https://en.wikipedia.org/wiki/Iris_flower_data_set)是常用的分类实验数据集,由Fisher,1936收集整理。Iris也称鸢尾花卉数据集,是一类多重变量分析的数据集。数据...
  • from sklearn.datasets import load_iris #导入鸢尾花数据集方法 from sklearn.neural_network import MLPClassifier #导入神经网络包 iris=load_iris()#加载鸢尾花数据集 tr_index=sample(range(0,50...
  • import numpy as np from sklearn.datasets import load_iris #导入数据集iris import matplotlib.pyplot as plt plt.rcParams['font.sans-serif'] = ['SimHei'] # 中文显示 plt.rcParams['axes.unicode_minus'] = ...
  • python机器学习实现鸢尾花分类

    千次阅读 2020-11-29 00:54:08
    鸢尾花(学名:Iris tectorum Maxim)属百合目、鸢尾科,可供观赏,花香气淡雅,可以调制香水,其根状茎可作中药,全年可采,具有消炎作用。鸢尾花主要有三个品种,setosa,versicolor,virginnica(山鸢尾、变色鸢尾...
  • 本文介绍了支持向量机分类算法,详细的介绍了其原理,函数,以及利用该算法预测鸢尾花数据。
  • 文章目录2. 编写代码,实现对iris数据集的KNN算法分类及预测要求:第一步:引入所需库第二步:划分测试集占20%第三步:n_neighbors=5第四步:评价模型的准确率第五步:使用模型预测未知种类的鸢尾花 2. 编写代码,...
  • 逻辑回归逻辑回归(LogisticRegression)是用于处理因变量为分类变量的回归问题,常见的是二分类或二项分布问题,也可以处理多分类问题,它实际上是属于一种分类方法。概率p与因变量往往是非线性的,为了解决该类问题...
  • Iris数据集(鸢尾花数据集下载,密码:ae1e)是常用的分类实验数据集,由Fisher,1936收集整理。Iris也称鸢尾花卉数据集,是一类多重变量分析的数据集。数据集包含150个数据集,分为3类,每类50个数据,每个数据包含4...
  • 最近在学习机器学习,使用SVM算法实现了鸢尾花分类,代码每行基于自己理解,都有注释,供大家一起相互学习
  • Python机器学习基础教程——鸢尾花分类初识数据训练数据与测试数据观察数据—数据可视化模型的建立与评估——K近邻算法 她还有一些鸢尾花的测量数据,这些花之前已经被植物学专家鉴定为属于 setosa、versicolor 或 ...
  • Python机器学习之LogisticRegression: 鸢尾花分类问题: 鸢尾花分类及特征属性 鸢尾花是一种多年生草本植物。人为划分为三类,setosa,versicolor,virginnica。数据集 ...
  • 2、线性分类器的实现原理3、设计线性分类器的主要步骤4、Fisher线性判别二、例题1–鸢尾花数据集的分类可视化及预测1、准备鸢尾花数据集2...鸢尾花数据集的分类可视化的整体python代码三、例题2–判定一下模式属于哪类...
  • Python 基于BP神经网络的鸢尾花分类

    万次阅读 多人点赞 2019-12-27 15:26:18
    本文用Python实现了BP神经网络分类算法,根据鸢尾花的4个特征,实现3种鸢尾花分类
  • 鸢尾花分类

    万次阅读 多人点赞 2019-04-05 22:24:58
    鸢尾花分类: 初识数据: 鸢尾花,测量数据:花瓣的长度和宽度,花萼的长度和宽度,所有测量结果都以厘米为单位。这一类花有三个品种:setosa,versicolor,virginnica。我们的目标是建立一个基础的机器学习的模型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,089
精华内容 2,435
关键字:

鸢尾花分类python算法