精华内容
下载资源
问答
  • 本代码主要利用MATLAB工具进行MATLAB——有导师学习神经网络分类——鸢尾花种类识别
  • 神经网络实现鸢尾花分类及结果可视化,详见https://blog.csdn.net/qq_41573860/article/details/105870072
  • 鸢尾花识别经典算法有很多,处于分类的一块的知识,对于分类的技术也有很多很多,通过BP神经网络也可以实现,在这里介绍一种更好的神经网络来实现鸢尾花的识别问题。
  • 内含山鸢尾、变色鸢尾、弗吉尼亚鸢尾花分类器,归一化函数,输入excel文档中的鸢尾花花瓣花萼长宽计算分类器的准确率的完整过程和注释,配套150个鸢尾花数据
  • MATLAB BP_神经网络(鸢尾花数据分类自编代码)

    千次阅读 热门讨论 2019-08-13 13:54:08
    周志华《机器学习》中的BP神经网络有其变量的推导,很详细,我在以下给出几页推导过程。我在我的资源里上传了PDF版的,谁要的话可以下载。 以下是我的代码,仅供参考,大部分是矩阵直接运算 clear clc ...

    学习了周志华《机器学习》中的BP神经网络,编代码的时候想找别人的作参考,发现好多人都直接调用工具箱。所得非所求,只能是自己写了代码,仅供新手参考,其中大部分是矩阵直接运算,对鸢尾花2/3数据训练,1/3数据训练。准确率在96%左右
    说明:代码的直接矩阵运算也是我坐那里耗费一些时间自己去想的,所以新手要看懂可能需要一些时间。一些人可能没读过这本书也会感觉云里雾里,鉴于篇幅问题,我在我的资源了上传了直接运行的代码、数据集和《机器学习》相应的理论说明,那里面有详细的梯度项理论推导,地址如下:https://download.csdn.net/download/weixin_44405310/11530170 有书的人自然心领神会。
    以下是我的一些学习心得:
    **什么是梯度下降法:**在这里我推一篇博文:https://blog.csdn.net/pengchengliu/article/details/80932232 大家可以参考,讲这个的人很多。
    数据归一化问题: 有人不理解为什么要数据归一化,我举一个浅显的例子:一个属性集的数据数量级是10 4 ^4 4,它的阈值是0.1;另一个属性集的数据数量级是10,就算它的阈值是1,把它们分别乘起来;我们发现数量级是10的那个属性集分明就是鸡肋嘛!影响不了大局。
    而matlab自带归一化函数mapminmax好像只能对行归一化,我不想转置,就自己写了一段程序。
    分类: 鸢尾花是要分类的,那么输出神经元该怎么办。我们可以这样,看它有几个类别,那就定义几个输出神经元。对本例而言:[0 1 0]就可以说是第二类,刚开始的类别标签也要这么处理。当然计算的输出神经元不可能那么准确,但是非常接近1。总之,就是取最大的位置作为它的类别。其实我还有一个想法,就是把最后的激活函数乘3,只设置一个输出神经元,如果输出是0~1就是第一类, 输出在1~2就判定第二类。
    隐层神经元的数目我是随便设的,这个我也不知道设置多少。

    clear 
    clc
    f=fopen('C:\Users\HP\Desktop\iris.data');
    Iris=textscan(f,'%f%f%f%f%s','delimiter',',');
    fclose(f);
    [~,n]=size(Iris);
    for i=1:n-1
        data(:,i)=Iris{1,i};
    end
    [m,n]=size(data);
    for i=1:m
        if strcmp(Iris{1,5}{i,1},'Iris-setosa')
            data(i,5:7)=[1 0 0];
        elseif  strcmp(Iris{1,5}{i,1}, 'Iris-versicolor')
            data(i,5:7)=[0 1 0];
        else 
            data(i,5:7)=[0 0 1];
        end
    end
    %数据归一化处理[0,1]区间内,
    x_max=max(data);
    x_min=min(data);
    data=(data-ones(m,1)*x_min)./(ones(m,1)*(x_max-x_min));
    % 这里可用函数data=mapminmax(data,0,1)替换
    %但data需要转置因为mapminmax只能对行进行归一化
    %%
    %划分训练样本和测试样本 大约2/3用作训练,1/3用作测试
    num=round(m/3/3);
    for i=1:3
        temp=data(1+50*(i-1):50*i,:);
        sel=randperm(50,num);
        test(1+num*(i-1):num*i,:)=temp(sel,1:4);
        test_label(1+num*(i-1):num*i,:)=temp(sel,5:7);
        temp(sel,:)=[];
        train(1+(50-num)*(i-1):(50-num)*i,:)=temp(:,1:4);
        train_label(1+(50-num)*(i-1):(50-num)*i,:)=temp(:,5:7);
    end
    %%
    [m,n]=size(train);
    alpha=4;%输入神经元数目
    beta=8;%隐层神经元数目
    lamda=3;%输出神经元数目
    rng('shuffle')
    W1=rand(alpha,beta);%输入层和隐层之间的权值矩阵
    W2=rand(beta,lamda);%隐层和输出层间的权值矩阵
    B1=rand(1,beta);%隐层阈值矩阵
    B2=rand(1,lamda);%输出层阈值矩阵
    B22=B2;
    W11=W1;
    Eta=1;%学习率
    iter_max=10000;%最大迭代次数
    iter=1;
    %BP神经网络,每次仅针对一个训练样例更新连接权和阈值
    while iter<=iter_max
       for i=1:m
        hidden_in=train(i,:)*W1;%隐层输入
        hidden_out=sigmod(hidden_in-B1);%隐层输出
        output_in=hidden_out*W2;%输出层输入
        output_out=sigmod(output_in-B2);%输出层输出
        %计算误差
        E(i)=sum((output_out-train_label(i,:)).^2);%求平方和可用sumsqr函数
        %%
        %更新参数,BP神经网络中最核心的部分
       g=output_out.*(1-output_out).*(train_label(i,:)-output_out);%计算输出层神经元的梯度项
       e=hidden_out.*(1-hidden_out).*(g*W2');%计算隐层神经元的梯度项
       Deta_W2=Eta*hidden_out'*g;
       Deta_B2=-Eta*g;
       Deta_W1=Eta*train(i,:)'*e;
       Deta_B1=-Eta*e;
       W1=W1+Deta_W1;
       W2=W2+Deta_W2;
       B1=B1+Deta_B1;
       B2=B2+Deta_B2;
       end
    %计算训练集的累积误差
    E=mean(E);
    if E<1e-4  %目标误差
        iter
        break
    end
    if mod(iter,1000)==0
           iter
    end
       iter=iter+1;%更新迭代次数
    end
    %%
    %测试
    [result,accuracy]=BP_test(test,test_label,W1,W2,B1,B2);
    disp('结果为:')
    result';
    disp(strcat('准确率为',num2str(accuracy*100),'%'))
    function [result,accuracy]=BP_test(test,test_label,W1,W2,B1,B2)
    %返回分类的结果
    %accuracy准确率
    Hidden_in=test*W1;%隐层输入
    Hidden_out=sigmod(Hidden_in-B1);%隐层输出
    Output_in=Hidden_out*W2;%输入层输入
    Output_out=sigmod(Output_in-B2);
    [~,result]=max(Output_out,[],2);
    [~,index2]=max(test_label,[],2);
    right=sum(result==index2);%统计分类正确的个数
    total=size(test,1);%总个数
    accuracy=right/total;
    end
    %sigmod函数在matlab里是logsig函数
    function [Y]=sigmod(X)
    Y=1./(1+exp(-1).^X);
    end     
    

    这是结果:
    ans =

    1 至 19 列

     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     2     2
    

    20 至 38 列

     2     2     2     3     2     2     3     2     2     2     2     2     2     2     2     3     3     3     3
    

    39 至 51 列

     3     3     3     3     3     3     3     3     3     3     3     3     3
    

    准确率为96.0784%

    展开全文
  • 神经网络(BP网)—鸢尾花分类问题华南师范大学计算机学院 – 神经网络鸢尾花分类BP网实现作者:杨劲松2013-4-24BPBPBBPP鸢尾花分类 网实现� 问题描述� 感知器网络� BP网BP� 用 网实现鸢尾花分类问题2013-4-24 2/...

    神经网络(BP网)—鸢尾花分类问题

    华南师范大学计算机学院 – 神经网络

    鸢尾花分类BP网实现

    作者:杨劲松

    2013-4-24

    BP

    BP

    BBPP

    鸢尾花分类 网实现

    � 问题描述

    � 感知器网络

    � BP网

    BP

    � 用 网实现鸢尾花分类问题

    2013-4-24 2/20

    问题描述

    �鸢尾花分类问题

    有一批Iris花,已知这批Iris花可分为3个品种,现

    需要对其进行分类。不同品种的Iris花的花萼长度、花

    萼宽度、花瓣长度、花瓣宽度会有差异。

    �Fisher's Iris Data Sepal

    length Sepal width Petal length Petal width Species

    length Sepal width Petal length Petal width Species

    lleennggtthh SSeeppaall wwiiddtthh PPeettaall lleennggtthh PPeettaall wwiiddtthh SSppeecciieess

    5.1 3.5 1.4 0.2 setosa

    7.0 3.2 4.7 1.4 versicolor

    6.3 3.3 6.0 2.5 virginica

    2013-4-24 3/20

    感知器网络

    �感知器的结构

    感知器网络简化结构图

    r

    加权输入: n = ∑w p +b

    i ij j i

    j=1

    a = f(n)

    输出: i i

    2013-4-24 4/20

    感知器网络

    �感知器的学习

    ——有教师的学习

    有教师学习算法将一组训练集 送入网络,根据网络的实际

    输出与期望输出间的差别来调整连接权。

    有导师学习算法的主要步骤包括:

    1) 从样本集合中取一个样本(Ai,Bi);

    ) 计算网络的实际输出 ;

    2 O

    3) 求D=Bi-O;

    4) 根据D调整权值W和阈值b;

    5) 对每个样本重复上述过程,直到对整个样本集来说,误

    差不超过规定范围。

    2013-4-24

    展开全文
  • 此代码使用基于反向传播的 NN 学习对鸢尾花数据集进行分类
  • 神经网络实现鸢尾花分类

    千次阅读 2020-09-29 23:57:37
    神经网络实现鸢尾花分类仅需三步: √准备数据 数据集读入 数据集乱序 生成训练集、测试集 配成对(输入特征、标签),每次读入一小撮batch √搭建网络 定义神经网络中所有可训练参数 √参数优化 嵌套循环迭代,...

    课程讲解链接
    神经网络实现鸢尾花分类仅需三步:
    √准备数据
    数据集读入
    数据集乱序
    生成训练集、测试集
    配成对(输入特征、标签),每次读入一小撮batch

    √搭建网络
    	定义神经网络中所有可训练参数
    √参数优化
    	嵌套循环迭代,with结构中求得损失函数loss对每个可训练参数的偏导数,更新可训练参数,显示当前loss
    

    鸢尾花分类代码:

    准备数据

    # -*- coding: UTF-8 -*-
    # 利用鸢尾花数据集,实现前向传播、反向传播,可视化loss曲线
    
    # 导入所需模块
    import tensorflow as tf
    from sklearn import datasets
    from matplotlib import pyplot as plt
    import numpy as np
    
    # 导入数据,分别为输入特征和标签
    x_data = datasets.load_iris().data 		#引入iris鸢尾花数据,iris数据包含4个特征变量
    y_data = datasets.load_iris().target	#4个标签
    #print(x_data)
    #print(y_data)
    # 随机打乱数据(因为原始数据是顺序的,顺序不打乱会影响准确率)
    # seed: 随机数种子,是一个整数,当设置之后,每次生成的随机数都一样(为方便教学,以保每位同学结果一致)
    np.random.seed(116)  # 使用相同的seed,保证输入特征和标签一一对应
    np.random.shuffle(x_data)	#shuffle-洗牌
    np.random.seed(116)
    np.random.shuffle(y_data)
    
    
    # 将打乱后的数据集分割为训练集和测试集,训练集为前120行,测试集为后30行
    x_train = x_data[:-30]
    y_train = y_data[:-30]
    x_test = x_data[-30:]
    y_test = y_data[-30:]
    
    # 转换x的数据类型,否则后面矩阵相乘时会因数据类型不一致报错
    x_train = tf.cast(x_train, tf.float32)
    x_test = tf.cast(x_test, tf.float32)
    
    # from_tensor_slices函数使输入特征和标签值一一对应。(把数据集分批次,每个批次batch组数据)
    train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
    test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
    

    搭建网络

    # 生成神经网络的参数,4个输入特征,故输入层为4个输入节点;因为3分类,故输出层为3个神经元
    # 用tf.Variable()标记参数可训练
    # 使用seed使每次生成的随机数相同(方便教学,使大家结果都一致,在现实使用时不写seed)
    w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
    b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))
    
    lr = 0.1  # 学习率为0.1
    train_loss_results = []  # 将每轮的loss记录在此列表中,为后续画loss曲线提供数据
    test_acc = []  # 将每轮的acc记录在此列表中,为后续画acc曲线提供数据
    epoch = 500  # 循环500轮
    loss_all = 0  # 每轮分4个step,loss_all记录四个step生成的4个loss的和
    

    参数优化

    # 训练部分
    for epoch in range(epoch):  #数据集级别的循环,每个epoch循环一次数据集
        for step, (x_train, y_train) in enumerate(train_db):  #batch级别的循环 ,每个step循环一个batch
            with tf.GradientTape() as tape:  # with结构记录梯度信息
                y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算
                y = tf.nn.softmax(y)  # 使输出y符合概率分布(此操作后与独热码同量级,可相减求loss)
                y_ = tf.one_hot(y_train, depth=3)  # 将标签值转换为独热码格式,方便计算loss和accuracy
                loss = tf.reduce_mean(tf.square(y_ - y))  # 采用均方误差损失函数mse = mean(sum(y-out)^2)
                loss_all += loss.numpy()  # 将每个step计算出的loss累加,为后续求loss平均值提供数据,这样计算的loss更准确
            # 计算loss对各个参数的梯度
            grads = tape.gradient(loss, [w1, b1])
    
            # 实现梯度更新 w1 = w1 - lr * w1_grad    b = b - lr * b_grad
            w1.assign_sub(lr * grads[0])  # 参数w1自更新
            b1.assign_sub(lr * grads[1])  # 参数b自更新
    
        # 每个epoch,打印loss信息
        print("Epoch {}, loss: {}".format(epoch, loss_all/4))
        train_loss_results.append(loss_all / 4)  # 将4个step的loss求平均记录在此变量中
        loss_all = 0  # loss_all归零,为记录下一个epoch的loss做准备
    
        # 测试部分
        # total_correct为预测对的样本个数, total_number为测试的总样本数,将这两个变量都初始化为0
        total_correct, total_number = 0, 0
        for x_test, y_test in test_db:
            # 使用更新后的参数进行预测
            y = tf.matmul(x_test, w1) + b1
            y = tf.nn.softmax(y)
            pred = tf.argmax(y, axis=1)  # 返回y中最大值的索引,即预测的分类
            # 将pred转换为y_test的数据类型
            pred = tf.cast(pred, dtype=y_test.dtype)
            # 若分类正确,则correct=1,否则为0,将bool型的结果转换为int型
            correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
            # 将每个batch的correct数加起来
            correct = tf.reduce_sum(correct)
            # 将所有batch中的correct数加起来
            total_correct += int(correct)
            # total_number为测试的总样本数,也就是x_test的行数,shape[0]返回变量的行数
            total_number += x_test.shape[0]
        # 总的准确率等于total_correct/total_number
        acc = total_correct / total_number
        test_acc.append(acc)
        print("Test_acc:", acc)
        print("--------------------------")
    

    可视化

    # 绘制 loss 曲线
    plt.title('Loss Function Curve')  # 图片标题
    plt.xlabel('Epoch')  # x轴变量名称
    plt.ylabel('Loss')  # y轴变量名称
    plt.plot(train_loss_results, label="$Loss$")  # 逐点画出trian_loss_results值并连线,连线图标是Loss
    plt.legend()  # 画出曲线图标
    plt.show()  # 画出图像
    
    # 绘制 Accuracy 曲线
    plt.title('Acc Curve')  # 图片标题
    plt.xlabel('Epoch')  # x轴变量名称
    plt.ylabel('Acc')  # y轴变量名称
    plt.plot(test_acc, label="$Accuracy$")  # 逐点画出test_acc值并连线,连线图标是Accuracy
    plt.legend()
    plt.show()
    
    
    展开全文
  • MATLAB平台下实现构造前馈神经网络,实现BP算法,对鸢尾花数据集进行分类
  • 本代码(MATLAB)可直接运行,对Iris鸢尾花数据分类,准确率96%左右,随机2/3数据训练,1/3数据测试。对于新手有帮助,多为矩阵运算。
  • 深度学习入门之神经网络实现鸢尾花分类 在TF2.1环境下建立.py文件 # -*- coding: UTF-8 -*- # 利用鸢尾花数据集,实现前向传播、反向传播,可视化loss曲线 # 导入所需模块 import tensorflow as tf from sklearn ...

    深度学习入门之神经网络实现鸢尾花分类

    在TF2.1环境下建立.py文件

    # -*- coding: UTF-8 -*-
    # 利用鸢尾花数据集,实现前向传播、反向传播,可视化loss曲线
    
    # 导入所需模块
    import tensorflow as tf
    from sklearn import datasets
    from matplotlib import pyplot as plt
    import numpy as np
    
    # 导入数据,分别为输入特征和标签
    x_data = datasets.load_iris().data
    y_data = datasets.load_iris().target
    
    # 随机打乱数据(因为原始数据是顺序的,顺序不打乱会影响准确率)
    # seed: 随机数种子,是一个整数,当设置之后,每次生成的随机数都一样(为方便教学,以保每位同学结果一致)
    np.random.seed(116)  # 使用相同的seed,保证输入特征和标签一一对应
    np.random.shuffle(x_data)
    np.random.seed(116)
    np.random.shuffle(y_data)
    tf.random.set_seed(116)
    
    # 将打乱后的数据集分割为训练集和测试集,训练集为前120行,测试集为后30行
    x_train = x_data[:-30]
    y_train = y_data[:-30]
    x_test = x_data[-30:]
    y_test = y_data[-30:]
    
    # 转换x的数据类型,否则后面矩阵相乘时会因数据类型不一致报错
    x_train = tf.cast(x_train, tf.float32)
    x_test = tf.cast(x_test, tf.float32)
    
    # from_tensor_slices函数使输入特征和标签值一一对应。(把数据集分批次,每个批次batch组数据)
    train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
    test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
    
    # 生成神经网络的参数,4个输入特征故,输入层为4个输入节点;因为3分类,故输出层为3个神经元
    # 用tf.Variable()标记参数可训练
    # 使用seed使每次生成的随机数相同(方便教学,使大家结果都一致,在现实使用时不写seed)
    w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
    b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))
    
    lr = 0.1  # 学习率为0.1
    train_loss_results = []  # 将每轮的loss记录在此列表中,为后续画loss曲线提供数据
    test_acc = []  # 将每轮的acc记录在此列表中,为后续画acc曲线提供数据
    epoch = 500  # 循环500轮
    loss_all = 0  # 每轮分4个step,loss_all记录四个step生成的4个loss的和
    
    # 训练部分
    for epoch in range(epoch):  #数据集级别的循环,每个epoch循环一次数据集
        for step, (x_train, y_train) in enumerate(train_db):  #batch级别的循环 ,每个step循环一个batch
            with tf.GradientTape() as tape:  # with结构记录梯度信息
                y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算
                y = tf.nn.softmax(y)  # 使输出y符合概率分布(此操作后与独热码同量级,可相减求loss)
                y_ = tf.one_hot(y_train, depth=3)  # 将标签值转换为独热码格式,方便计算loss和accuracy
                loss = tf.reduce_mean(tf.square(y_ - y))  # 采用均方误差损失函数mse = mean(sum(y-out)^2)
                loss_all += loss.numpy()  # 将每个step计算出的loss累加,为后续求loss平均值提供数据,这样计算的loss更准确
                # 计算loss对各个参数的梯度
            grads = tape.gradient(loss, [w1, b1])
    
            # 实现梯度更新 w1 = w1 - lr * w1_grad    b = b - lr * b_grad
            w1.assign_sub(lr * grads[0])  # 参数w1自更新
            b1.assign_sub(lr * grads[1])  # 参数b自更新
    
        # 每个epoch,打印loss信息
        print("Epoch {}, loss: {}".format(epoch, loss_all/4))
        train_loss_results.append(loss_all / 4)  # 将4个step的loss求平均记录在此变量中
        loss_all = 0  # loss_all归零,为记录下一个epoch的loss做准备
    
        # 测试部分
        # total_correct为预测对的样本个数, total_number为测试的总样本数,将这两个变量都初始化为0
        total_correct, total_number = 0, 0
        for x_test, y_test in test_db:
            # 使用更新后的参数进行预测
            y = tf.matmul(x_test, w1) + b1
            y = tf.nn.softmax(y)
            pred = tf.argmax(y, axis=1)  # 返回y中最大值的索引,即预测的分类
            # 将pred转换为y_test的数据类型
            pred = tf.cast(pred, dtype=y_test.dtype)
            # 若分类正确,则correct=1,否则为0,将bool型的结果转换为int型
            correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
            # 将每个batch的correct数加起来
            correct = tf.reduce_sum(correct)
            # 将所有batch中的correct数加起来
            total_correct += int(correct)
            # total_number为测试的总样本数,也就是x_test的行数,shape[0]返回变量的行数
            total_number += x_test.shape[0]
        # 总的准确率等于total_correct/total_number
        acc = total_correct / total_number
        test_acc.append(acc)
        print("Test_acc:", acc)
        print("--------------------------")
    
    # 绘制 loss 曲线
    plt.title('Loss Function Curve')  # 图片标题
    plt.xlabel('Epoch')  # x轴变量名称
    plt.ylabel('Loss')  # y轴变量名称
    plt.plot(train_loss_results, label="$Loss$")  # 逐点画出trian_loss_results值并连线,连线图标是Loss
    plt.legend()  # 画出曲线图标
    plt.show()  # 画出图像
    
    # 绘制 Accuracy 曲线
    plt.title('Acc Curve')  # 图片标题
    plt.xlabel('Epoch')  # x轴变量名称
    plt.ylabel('Acc')  # y轴变量名称
    plt.plot(test_acc, label="$Accuracy$")  # 逐点画出test_acc值并连线,连线图标是Accuracy
    plt.legend()
    plt.show()
      
    

    运行时报错缺少matplotlib
    在terminal中安装

    pip install matplotlib
    

    请添加图片描述
    运行结果

    请添加图片描述请添加图片描述

    请添加图片描述
    请添加图片描述

    请添加图片描述
    参考内容: 神经网络实现鸢尾花分类.

    展开全文
  • 极限学习机神经网络经典案例matlab实现:鸢尾花识别问题和辛烷值预测问题
  • 有导师学习神经网络分类 ---鸢尾花种类识别的理论基础,案例背景,MATLAB程序实现
  • 利用神经网络鸢尾花数据集分类

    千次阅读 2020-07-08 11:08:50
    利用神经网络鸢尾花数据集分类 详细实现代码请见: 一.简介 一个人工神经元网络是由一个多层神经元结构组成,每一层神经元拥有输入(它的输入是前一层神经元的输出)和输出,我们把神经元和与之对应的神经元之间的...
  • BP神经网络算法(鸢尾花)附带相关训练集及测试集,Iris(鸢尾花)数据集分为训练集(Iris-train.txt)和测试集(Iris-test.txt),分别含75个样本,每个集合中每种花各有25个样本。
  • 鸢尾花分类的例子里,输入为x0,x1,x2,x3以及偏置项b。我们可以定义鸢尾花特征有四个维度,每个维度分别对应一个输入x。 简化模型可以表示为y=x0* w0+x1* w1+x2* w2+x3* w3+b。该形式是很经典的加权求和式,即每个...
  • 鸢尾花iris数据集

    2020-10-30 12:14:59
    matlab实现用Bp神经网络对iris数据集进行分类(以及影响分类性能的参数条件)这篇文章的数据集
  • 最近在学习机器学习,使用SVM算法实现了鸢尾花分类,代码每行基于自己理解,都有注释,供大家一起相互学习
  • 文章目录 一、数据集和资料 二、鸢尾花分类 三、西瓜分类 四、一些笔记 Sklearn部分资料 pandas部分函数 一、数据集和资料 数据集,提取码:zmlc 大佬笔记,提取码:ytfa 二、鸢尾花分类 # -*- coding: utf-8 -* # ...
  • 使用SVM(支持向量机)进行鸢尾花分类。能够正确地运行。
  • BP神经网络鸢尾花卉进行分类

    千次阅读 2018-03-04 20:32:29
    BP神经网络鸢尾花卉进行分类 摘要 Iris数据集是常用的分类实验数据集,由Fisher, 1936收集整理。Iris也称鸢尾花卉数据集,是一类多重变量分析的数据集。数据集包含150个数据集,分为3类,每类50个数据,每个...
  • 从头开始编写了一个名为 ... iris.xls文件随项目一起提供,并且必须在示例文件夹中,作为matlab文件“ Perceptron.m”。 选择了S形函数作为激活函数,并选择了适当的阈值。 运行感知器时会看到错误图和分类图。
  • matlab 神经网络ann用于分类方法

    千次阅读 2020-05-09 21:29:04
    matlab关于ann的分类方法讲解了一个例子,Fishr集上鸢尾花(Iris)的分类,学习了这个方法可以套用在个人项目上使用,万变不离其宗, 1、Fishr集上鸢尾花Iris数据集的分类 ①iris数据集简介 iris数据集的中文名是...
  • 利用感知器算法进行鸢尾花数据分类,还包含一个异或算法,可以解决非线性分类问题
  • 一、模式识别神经网络在matlab命令窗口输入:nnstart 或 nprtool 就可以进入matlab神经网络GUI二、鸢尾花数据集iris示例1.输入数据集,划分训练集、测试集load fisheriris;[m,n]=size(meas);data=zeros(m,n+1);data...
  • 决策树 BP神经网络(BPNN) SVM实现iris鸢尾花数据集的分类 决策树 实现流程(详见代码):: 1. 连续值处理 iris数据集是连续数据, 因为连续属性的可取值数目不再有限,因此不能像处理离散属性枚举离散属性取值来对结点...
  • 本程序主要给出神经网络算法的两个简单应用,分别是Fishr集上鸢尾花(Iris)的分类以及常见的分类问题-蠓虫分类,同时通过对两个分类程序(Code by MATLAB)进一步分析,加强对神经网络算法的理解。
  • 鸢尾花数据集bp算法matlab分类

    热门讨论 2008-03-26 23:21:52
    本程序利用matlab软件将鸢尾花数据集进行分类,利用的是bp算法
  • SVM支持向量机分类鸢尾花数据集iris及代码,数据集有Excel、data、txt文件格式,代码有data、txt格式演示

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 211
精华内容 84
关键字:

matlab神经网络分类鸢尾花

matlab 订阅