精华内容
下载资源
问答
  • 2021-05-03 02:32:06

    clc

    clear

    P= [150,150,190,150,160,172,150,183,150,150,182,148,190,192,150,159,150,150,169,150,159,199,149,179,150,150,189,150,150,198,150,181;

    150,150,160,150,191,180,150,182,151,152,185,150,191,159,150,159,149,149,170,150,196,187,148,179,150,149,188,151,151,187,150,170;

    150,150,166,150,180,185,150,177,149,150,163,149,159,185,148,169,150,150,180,149,166,167,150,159,149,150,190,149,150,177,151,180;

    150,171,188,172,170,150,150,150,150,174,167,186,182,150,150,150,150,168,190,169,179,150,150,150,149,178,160,180,150,150,149,150;

    150,160,168,190,189,150,150,150,150,180,159,192,184,147,149,150,150,169,180,189,179,150,149,150,151,190,180,180,150,150,149,150;

    150,180,185,192,160,150,150,150,150,172,158,194,154,148,148,150,150,170,188,189,199,149,149,150,150,180,170,199,150,150,150,151;

    150,150,150,188,198,150,182,188,150,150,149,158,162,150,167,169,149,150,150,196,178,149,159,199,150,150,150,156,151,150,180,188;

    150,150,150,169,180,150,182,190,150,150,150,169,174,150,170,168,150,151,150,196,196,150,178,189,150,150,150,184,149,149,172,187;

    150,150,150,174,176,150,190,177,150,150,150,196,175,150,172,179,150,150,149,186,192,150,169,189,149,151,150,191,148,150,181,174;]

    T= [1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,0;

    1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1;

    1,1,1,0,0,1,0,0,1,1,1,0,0,1,0,0,1,1,1,0,0,1,0,0,1,1,1,0,0,1,0,0;]

    P_test=[150,150,150;

    150,150,150;

    150,150,150;

    180,187,150;

    172,180,150;

    177,172,150;

    150,190,172;

    150,190,184;

    150,174,180;]

    T_test=[1,1,1;

    0,0,1;

    1,0,0;]

    %hiddennum=[5,6,7,8,9,10,11,12,13,14,15];

    [inputn,inputps]=mapminmax(P);

    [outputn,outputps]=mapminmax(T);

    %for i=1:11

    net=newff(inputn,outputn,13,{'tansig','logsig'},'trainlm');

    %网络参数配置

    net.trainParam.epochs=1000;

    net.trainParam.goal=0.1;

    LP.lr=0.01;

    %训练网络

    net=train(net,inputn,outputn);

    %%测试网络

    inputn_test=mapminmax('apply',P_test,inputps);

    %disp(['1.使用随机权值和阀值'])

    %disp('测试样本预测结果:')

    Y1=sim(net,inputn_test)

    %y1=mapminmax('reverse',Y1,outputps);

    err1=norm(Y1-T_test);

    Y2=sim(net,inputn)

    %y2=mapminmax('reverse',Y2,outputps);

    err11=norm(Y2-T);

    %Y(i)=err1;

    %end

    %figure()

    %plot(hiddennum,Y,'-');

    disp(['训练样本的仿真误差:',num2str(err11)])

    disp(['测试样本的仿真误差:',num2str(err1)])

    用于模式分类的,输入9,输出3,训练误差大,测试误差也大,调了参数也不行,还是程序有问题?

    更多相关内容
  • BP神经网络训练误差问题-新建文件夹 .zip clear all; clc; load train.mat t=zeros; for k=1:200  t)=1; end Ti=t';%期望输出 P = trainsample' size 9 200 size @ 200 % size % size %人脸类别40...
  • matlab_BP神经网络按照误差逆向传播算法训练的多前馈神经网络
  • %bp 神经网络的预测代码clcclearclose all;%载入输出和输入数据p=[4001.87 4721.77 5700.1 6168.23 7220.14 8750.95 10309.8 11720.91 12814.59 13717.88 14869.95;62.32 87.8 95.99 80.19 133.68 160.53 210.05 258...

    %bp 神经网络的预测代码

    clc

    clear

    close all;

    %载入输出和输入数据

    p=[4001.87 4721.77 5700.1 6168.23 7220.14 8750.95 10309.8 11720.91 12814.59 13717.88 14869.95;

    62.32 87.8 95.99 80.19 133.68 160.53 210.05 258.3 296.22 245.27 199.99;

    692.21 770.96 631.68 904.27 990.5 1070.11 1164.8 1271.49 1759.6 1482.45 1569.2;

    1.32 1.31 1.16 1.16 1.29 1.04 1.12 1.43 1.6 1.51 1.5;

    362.4 393.4 426.4 448.45 523.64 610.78 669.96 719.97 572.13 597.96 585.55;

    0.06 0.06 0.06 0.07 0.08 0.08 0.08 0.1 0.11 0.12 0.12;

    66.3 73.76 70.76 81.31 89.03 92.34 106.01 125.4 146.98 155.41 151.93;

    394.44 458.36 510.7 577.8 662.81 763.72 886.4 1043.37 997.94 1075.32 1199.42;

    0.77 0.9 1.03 1.2 1.38 1.63 1.96 2.4 2.81 3.23 4.25;

    4483 4514 4543 4571 4543 4631 4659 4686.6 4713.9 4741.8 4770.5];

    %输入数据,共10组,每组11个输入

    t=[179028 199990 201340 231734 243289 255395 278116 358229 386770 431387 469643];   %输出数据,共1组,每组11个输出

    %数据的归一化处理,利用mapminmax函数,使数值归一化到[-1.1]之间

    %该函数使用方法如下:[y,ps] =mapminmax(x,ymin,ymax),x需归化的数据输入,

    %ymin,ymax为需归化到的范围,不填默认为归化到[-1,1]

    %返回归化后的值y,以及参数ps,ps在结果反归一化中,需要调用

    [p1,ps]=mapminmax(p);

    [t1,ts]=mapminmax(t);

    %确定训练数据,测试数据,一般是随机的从样本中选取70%的数据作为训练数据

    %15%的数据作为测试数据,一般是使用函数dividerand,其一般的使用方法如下:

    %[trainInd,valInd,testInd] = dividerand(Q,trainRatio,valRatio,testRatio)

    [trainsample.p,valsample.p,testsample.p] =dividerand(p,0.7,0.15,0.15);

    [trainsample.t,valsample.t,testsample.t] =dividerand(t,0.7,0.15,0.15);

    %建立反向传播算法的BP神经网络,使用newff函数,其一般的使用方法如下

    %net = newff(minmax(p),[隐层的神经元的个数,输出层的神经元的个数],{隐层神经元的传输函数,输出层的传输函数},'反向传播的训练函数'),其中p为输入数据,t为输出数据

    %tf为神经网络的传输函数,默认为'tansig'函数为隐层的传输函数,

    %purelin函数为输出层的传输函数

    %一般在这里还有其他的传输的函数一般的如下,如果预测出来的效果不是很好,可以调节

    %TF1 = 'tansig';TF2 = 'logsig';

    %TF1 = 'logsig';TF2 = 'purelin';

    %TF1 = 'logsig';TF2 = 'logsig';

    %TF1 = 'purelin';TF2 = 'purelin';

    TF1='tansig';TF2='purelin';

    net=newff(minmax(p),[10,1],{TF1 TF2},'traingdm');     %网络创建

    %网络参数的设置

    net.trainParam.epochs=50000;                          %训练次数设置

    net.trainParam.goal=1e-7;                             %训练目标设置

    net.trainParam.lr=0.01;                               %学习率设置,应设置为较少值,太大虽然会在开始加快收敛速度,但临近最佳点时,会产生动荡,而致使无法收敛

    net.trainParam.mc=0.9;                                %动量因子的设置,默认为0.9

    net.trainParam.show=25;                               %显示的间隔次数

    % 指定训练参数

    % net.trainFcn = 'traingd'; % 梯度下降算法

    % net.trainFcn = 'traingdm'; % 动量梯度下降算法

    % net.trainFcn = 'traingda'; % 变学习率梯度下降算法

    % net.trainFcn = 'traingdx'; % 变学习率动量梯度下降算法

    % (大型网络的首选算法)

    % net.trainFcn = 'trainrp'; % RPROP(弹性BP)算法,内存需求最小

    % 共轭梯度算法

    % net.trainFcn = 'traincgf'; %Fletcher-Reeves修正算法

    % net.trainFcn = 'traincgp'; %Polak-Ribiere修正算法,内存需求比Fletcher-Reeves修正算法略大

    % net.trainFcn = 'traincgb'; % Powell-Beal复位算法,内存需求比Polak-Ribiere修正算法略大

    % (大型网络的首选算法)

    %net.trainFcn = 'trainscg'; % ScaledConjugate Gradient算法,内存需求与Fletcher-Reeves修正算法相同,计算量比上面三种算法都小很多

    % net.trainFcn = 'trainbfg'; %Quasi-Newton Algorithms - BFGS Algorithm,计算量和内存需求均比共轭梯度算法大,但收敛比较快

    % net.trainFcn = 'trainoss'; % OneStep Secant Algorithm,计算量和内存需求均比BFGS算法小,比共轭梯度算法略大

    % (中型网络的首选算法)

    %net.trainFcn = 'trainlm'; %Levenberg-Marquardt算法,内存需求最大,收敛速度最快

    % net.trainFcn = 'trainbr'; % 贝叶斯正则化算法

    % 有代表性的五种算法为:'traingdx','trainrp','trainscg','trainoss', 'trainlm'

    %在这里一般是选取'trainlm'函数来训练,其算对对应的是Levenberg-Marquardt算法

    net.trainFcn='trainlm';

    [net,tr]=train(net,trainsample.p,trainsample.t);

    %计算仿真,其一般用sim函数

    [normtrainoutput,trainPerf]=sim(net,trainsample.p,[],[],trainsample.t);     %训练的数据,根据BP得到的结果

    [normvalidateoutput,validatePerf]=sim(net,valsample.p,[],[],valsample.t);   %验证的数据,经BP得到的结果

    [normtestoutput,testPerf]=sim(net,testsample.p,[],[],testsample.t);         %测试数据,经BP得到的结果

    %将所得的结果进行反归一化,得到其拟合的数据

    trainoutput=mapminmax('reverse',normtrainoutput,ts);

    validateoutput=mapminmax('reverse',normvalidateoutput,ts);

    testoutput=mapminmax('reverse',normtestoutput,ts);

    %正常输入的数据的反归一化的处理,得到其正式值

    trainvalue=mapminmax('reverse',trainsample.t,ts);%正常的验证数据

    validatevalue=mapminmax('reverse',valsample.t,ts);%正常的验证的数据

    testvalue=mapminmax('reverse',testsample.t,ts);%正常的测试数据

    %做预测,输入要预测的数据pnew

    pnew=[16531.34 233.94 1798.67 1.46 596.7 0.12 153.66 1364.66 5.67 4800.5]';

    pnewn=mapminmax(pnew);

    anewn=sim(net,pnewn);

    anew=mapminmax('reverse',anewn,ts);

    %绝对误差的计算

    errors=trainvalue-trainoutput;

    figure,plotregression(trainvalue,trainoutput);    %plotregression拟合图

    figure,plot(1:length(errors),errors,'-b');        %误差图

    title('误差变化图');

    %误差值的正态性的检验

    figure,hist(errors);                              %频数直方图

    figure,normplot(errors);                          %Q-Q图

    [muhat,sigmahat,muci,sigmaci]=normfit(errors);    %参数估计 均值,方差,均值的0.95置信区间,方差的0.95置信区间

    [h1,sig,ci]= ttest(errors,muhat);                 %假设检验

    figure, ploterrcorr(errors);                      %绘制误差的自相关图

    figure, parcorr(errors);                          %绘制偏相关图

    展开全文
  • 基于BP神经网络的IRIS数据集训练和测试,有完整的数据集和实现代码,直接运行即可得到结果,并显示,正确率,误差,迭代次数等参数
  • BP网络训练误差太大,训练速度缓慢 本人小白,最近在学习神经网络,参考网上的代码用C写了个两层BP神经网络的模型,使用了两组数据,一组是用来训练的,一组用于测试。但在程序测试过程中,训练阶段误差太大且收敛...

    求助!BP网络训练速度缓慢,且误差太大。

    本人小白,最近在学习神经网络,参考网上的C代码写了个两层的BP神经网络的模型,使用了两组数据,其中一组用来训练,一组用于测试。但在测试过程中,误差太大且收敛速度非常缓慢。尝试过的结局方法有给误差乘上一个步长,但效果不明显;或增加隐层单元数目,效果也不理想。想请问大神们还有别的解决办法吗?谢谢了!!!代码贴在下方:

    #include <stdio.h>
    #include <stdlib.h>		//定义了 RAND_MAX 的值为0x7fff
    #include <math.h>
    #include <time.h>	//用到了time函数,所以要有这个头文件
    
    #define input_n 3		//网络输入个数
    #define hidden_n 6     //隐藏层单元个数
    #define output_n 2		//网络输出个数
    #define sample_n 8     //样本数量
    
    typedef struct _bpnn{       //bp神经网络结构	
    	double hid_layer[input_n][hidden_n];   //隐藏层权矩阵
    	double out_layer[hidden_n][output_n];   //输出层权矩阵
    	double study_rate;          //学习率
    	double b;					//偏置值
    } BPNN;
    double trans_func(double net)	//传输函数 
    {
    	//Sigmoid函数,神经网络激活函数
    	return 1 / (1 + exp(-net));
    }
    int BP_Init(BPNN *bp)
    { //初始化bp网络
    	printf("请输入学习率:\n");
    	scanf_s("%lf", &(*bp).study_rate);    //(*bp).a为double型数据,所以必须是lf
    	printf("请输入偏置值:\n");
    	scanf_s("%lf", &(*bp).b);
    	int i, j;
    	srand((unsigned)time(NULL));
    	for (i = 0; i < input_n; i++)
    	{
    		for (j = 0; j < hidden_n; j++)
    			//初始化所有网络权值为小的随机值,即归一化
    			(*bp).hid_layer[i][j] = rand() / (double)RAND_MAX;
    	}
    	for (i = 0; i < hidden_n; i++)
    	{
    		for (j = 0; j < output_n; j++)
    			(*bp).out_layer[i][j] = rand() / (double)RAND_MAX;
    	}
    	return 1;
    }
    int BP_Train(BPNN *bp, double x[sample_n][input_n], int t[sample_n][output_n])
    {
    	//训练bp网络,样本为x,理想输出为y
    	double f = (*bp).b;                      //偏置值
    	double a = (*bp).study_rate;                      //学习率
    	int h = hidden_n;                         //隐层节点数
    	double hid_w[input_n][hidden_n], out_w[hidden_n][output_n]; //权矩阵
    	double h_delta[hidden_n], o_delta[output_n];         //修改量矩阵
    	double hid[hidden_n], out[output_n];             //隐层和输出层输出量
    	int i, j, k, n;
    	double sum;
    	for (i = 0; i < input_n; i++)            // 复制结构体中的权矩阵 
    	{
    		for (j = 0; j < h; j++)
    			hid_w[i][j] = (*bp).hid_layer[i][j];
    	}
    	for (i = 0; i < h; i++)
    	{
    		for (j = 0; j < output_n; j++)
    			out_w[i][j] = (*bp).out_layer[i][j];
    	}
    	double e = 1,e_th=0.000001;	//输出误差????
    	for (n = 0; e > e_th; n++)//&& n < LoopCount 
    	{	 //对每个样本训练网络
    		e = 0;
    		for (i = 0; i < sample_n; i++)
    		{
    			for (k = 0; k < h; k++)
    			{          //计算隐层输出向量
    				sum = 0;
    				for (j = 0; j < input_n; j++)
    					sum = sum + x[i][j] * hid_w[j][k];
    				hid[k] = trans_func(sum + f);
    			}
    			for (k = 0; k < output_n; k++)
    			{
    				//计算输出层输出向量
    				sum = 0;
    				for (j = 0; j < h; j++)
    					sum = sum + hid[j] * out_w[j][k];
    				out[k] =  trans_func(sum + f);
    			}
    			for (j = 0; j < output_n; j++)
    			{
    				o_delta[j] = out[j] * (1 - out[j]) * (t[i][j] - out[j]);//计算输出层的权修改量  
    				e = e + (t[i][j] - out[j]) * (t[i][j] - out[j]); // * 0.0001计算输出误差
    			}
    			for (j = 0; j < h; j++)
    			{
    				//计算隐层权修改量
    				sum = 0;
    				for (k = 0; k < output_n; k++)
    					sum = sum + out_w[j][k] * o_delta[k];
    				h_delta[j] = sum *  hid[j] * (1 - hid[j]);
    			}
    			for (j = 0; j < h; j++)           //修改输出层权矩阵
    			{
    				for (k = 0; k < output_n; k++)
    					out_w[j][k] = out_w[j][k] + a *  hid[j] * o_delta[k];
    			}
    			for (j = 0; j < input_n; j++)
    			{
    				for (k = 0; k < h; k++)
    					hid_w[j][k] = hid_w[j][k] +  a * x[i][j] * h_delta[k];
    			}
    		}
    		if (n % 10 == 0)
    			printf("第%d次训练,误差为 : %.6f\n", n, e);
    	}
    	for (i = 0; i < input_n; i++)             //把结果复制回结构体 
    	{
    		for (j = 0; j < h; j++)
    			(*bp).hid_layer[i][j] = hid_w[i][j];
    	}
    	for (i = 0; i < h; i++)
    	{
    		for (j = 0; j < output_n; j++)
    			(*bp).out_layer[i][j] = out_w[i][j];
    	}
    	return 1;
    }
    int BP_Test(BPNN *bp, double tx[sample_n][input_n])//, double y[sample_n][input_n]
    {    //使用bp网络
    	double f = bp->b;
    	double Input[input_n];
    	double O1[hidden_n];
    	double O2[output_n]; //O1为隐层输出,O2为输出层输出
    	int i, j, k;
    	double temp;
    	for (k = 0; k < sample_n;k++)
    	{
    		for (i = 0; i < hidden_n; i++)
    		{
    			temp = 0;
    			for (j = 0; j < input_n; j++)
    			{
    				temp +=  tx[k][j] * (*bp).hid_layer[j][i];
    			}
    			O1[i] = trans_func(temp + f);
    		}
    		for (i = 0; i < output_n; i++)
    		{
    			temp = 0;
    			for (j = 0; j < hidden_n; j++)
    			{
    				temp += O1[j] * (*bp).out_layer[j][i];
    			}
    			O2[i] = trans_func(temp + f);
    		}
    		printf("测试结果是:");
    		for (i = 0; i < output_n; i++)
    			printf("%.3f ", O2[i]);
    		printf("********\n");
    	}
    	scanf_s("%f", &Input[0]);
    	return 1;
    }
    int main()
    {
    	double x[sample_n][input_n] = {
    		{ 0, 0,0 },
    		{ 0,0, 1 },
    		{ 0,1, 0 },
    		{ 0, 1, 1 },
    		{ 1, 0, 0 },
    		{ 1, 0, 1 },
    		{ 1, 1, 0 },
    		{ 1, 1, 1 } }; //6个训练样本
    	int y[sample_n][output_n] = {
    		{ 0,0 },
    		{ 2,4 },
    		{ 0,3 },
    		{ 2,7 },
    		{ 1,0.5 },
    		{ 3,4.5 },
    		{ 1,3.5 },
    		{ 3,7.5 } };
    	double tx[sample_n][input_n] = {
    		{ 0.5, 0.5, 0.5 },
    		{ 0, 0.5, 0.5 },
    		{ 0.3, 0, 0.5 },
    		{ 0.2, 0.1, 3 },
    		{ 0.6, 0.4, 0 },
    		{ 0.2, 0.1, 0 },
    		{ 0.9, 2, 0.5 },
    		{ 2, 0.9, 1.3 } }; //6个训练样本
    	BPNN bp;
    	BP_Init(&bp);                    //初始化bp网络结构
    	BP_Train(&bp, x, y);             //训练bp神经网络
    	int i, j;
    	printf("输入到隐含层的权值\n");
    	for (i = 0; i < hidden_n; i++)
    	{
    		for (j = 0; j < input_n; j++)
    		{
    			printf("hid_layer[%d][%d]=%.3f\n", j, i,bp.hid_layer[j][i]);
    		}
    	}
    	printf("隐含层到输出的权值\n");
    	for (i = 0; i < output_n; i++)
    	{
    		for (j = 0; j < hidden_n; j++)
    		{
    			printf("out_layer[%d][%d]=%.3f\n", j, i, bp.out_layer[j][i]);
    		}
    	}
    	BP_Test(&bp,tx);                     //测试bp神经网络
    	return 1;
    }
    

    调试结果如下:设置了学习率为0.5,偏置为0另感谢那位小伙伴提供了思路,非常感谢。

    展开全文
  • clc清除%从三类k均值聚类结果的每一个中随机选择190行,以形成一个新的570 * 3矩阵,即训练样本.load('data1.mat');load('data2.mat');load('data3.mat');data = [data1; data2; data3];%%%第一类数据是80,是随机...

    10ecfa9e27e7373569e895f6c19bed22.png

    clc

    清除

    %从三类k均值聚类结果的每一个中随机选择190行,以形成一个新的570 * 3矩阵,即训练样本.

    load('data1.mat');

    load('data2.mat');

    load('data3.mat');

    data = [data1; data2; data3];

    %%

    %第一类数据是80,是随机选择的过程

    M1 = data1;

    S1 =大小(M1,1);

    SampleRows1 = randperm(S1);

    SampleRows1 = SampleRows1(1:80);

    SampleM1 = M1(SampleRows1,: );

    %第二种数据是110,是随机选择的过程

    M2 = data2;

    S2 = size(M2,1);

    SampleRows2 = randperm(S2);

    SampleRows2 = SampleRows2(1:80);

    48fc1de6a98bd2100cb66d9c359aeb1a.png

    SampleM2 = M2(SampleRows2,: );

    %第三种数据是110,是随机选择的过程

    M3 = data3;

    S3 = size(M3,1);

    SampleRows3 = randperm(S3);

    SampleRows3 = SampleRows3(1:80);

    SampleM3 = M3(SampleRows3,: );

    SampleM = [SampleM1; SampleM2; SampleM3];

    %将重要性与前三列中的数据相匹配,并输出所需的输出.

    %首先将随机选择的训练样本分配给d,然后将d与dataa匹配. 更新后的d具有匹配的重要性,第四列.

    d = SampleM;%训练样本

    %%

    %将相应的重要性添加到训练样本中

    load('dataa.mat');

    %匹配训练样本的重要性值

    aInb = ismember(d,dataa);

    [m,n] = size(aInb);

    [mdataa,ndataa] = size(dataa);

    d = [d dataa(1: m,n + 1: ndataa)];重要的训练样本百分比

    ca0ef3739fee8ddf9c034e6571b834ef.png

    %%

    %======非时间序列BP神经网络=====

    %=======原始数据输入========

    多个备件矩阵的三个因素的百分比[年度故障次数单价购买提前期]

    p = SampleM';%训练样本,

    %===========预期输出=======

    %与多个备件对应的期望重要性输出值,即匹配重要性后训练样本的第四列值

    t = d(: ,4)';

    %===========测试数据=======

    %从原始输入数据中选择一个零件,然后添加一些其他数据作为测试数据矩阵

    %%

    此处已修改%

    %测试数据

    ptest = dataa(:神经网络预测大量数据,1: 3)';

    %test数据的预期输出

    ttest = dataa(: ,4);

    %%

    %归一化数据

    [pn,minp,maxp,tn,mint,maxt] = premnmx(p神经网络预测大量数据,t);%归一化数据

    1bad29d1c09a273280e31e032e1c8376.png

    %考虑到没有太多数据,所以设置了两个隐藏层

    NodeNum1 = 10;%隐藏层第一层中的节点数

    NodeNum2 = 10;%隐藏层第二层中的节点数

    %输出尺寸

    TypeNum = 1;

    每一层的%Transfer函数,TF3是输出层的传递函数

    TF1 ='tansig';

    TF2 ='tansig';

    TF3 ='tansig';

    %创建四层BP神经网络

    net = newff(minmax(pn),[NodeNum1,NodeNum2,TypeNum],{TF1 TF2 TF3},'traingdx');

    %网络创建人Tradingdx

    net.trainParam.show = 50;%训练显示间隔

    net.trainParam.epochs = 60000; %最大训练时间设置

    net.trainParam.goal = 1e-5; %最小均方误差,即训练所需的精度

    net.trainParam.lr = 0.01;%学习率

    net = train(net,pn,tn); %train BP网络

    %测试数据的规范化

    p2n = tramnmx(ptest,minp,maxp);

    024f40b9a7314da1ec3a9dd50601637c.png

    %BP结果输出

    an = sim(net,p2n);

    %数据的非规格化,即您想要获得的最终预测结果

    [a] = postmnmx(an,mint,maxt)

    %% ============================================= ======================

    %%

    %plot函数的输出有问题,或者矩阵尺寸设置有问题

    %aaaaaaaaaaaaaaaaaaaa ++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    %++++++++++++++++++++++++++++++++++++++++++++++++ ++ ++++++++++++++++++++++++++++

    plot(1: length(ttest),a,'o',1: length(ttest),ttest','. ');

    title('o表示预测值--- *表示实际值')

    坚持

    推迟

    m = length(a);向量a的%长度

    t1 = ttest';

    error = abs(t1-a); %错误向量

    plot(1: length(error),error,'-. ')

    title('错误更改图')

    网格

    本文来自电脑杂谈,转载请注明本文网址:

    http://www.pc-fly.com/a/jisuanjixue/article-287220-1.html

    展开全文
  • BP神经网络详解.ppt

    2020-03-14 17:15:36
    bp神经网络详解ppt BP(back propagation)神经网络是1986年由Rumelhart和McClelland为首的科学家提出的概念,是一种按照误差逆向传播算法训练的多层前馈神经网络,是应用最广泛的神经网络。 在人工神经网络的发展...
  • 运行BP神经网络预测误差

    万次阅读 2015-12-14 09:28:20
    运行下列代码后误差非常大,求大神们给减小误差的指导方向。 matlab代码如下: clc clear %load data1 input output load matlab3 input output P=input(1:60,:)'; T=output(1:60,:)'; inp
  • 各式资料中关于BP神经网络的讲解已经足够全面详尽,故不在此过多赘述。本文重点在于由一个“最简单”的神经网络练习推导其训练过程,和大家一起在练习中一起更好理解神经网络训练过程。...
  • % 隐藏层神经元的个数 %% Training Neural Network training_input=input_ANN([ff_zeros Rx_signal1],ff_TDL,tlen); % 训练输入 net = newff(minmax(training_input),[nneu 1],{'logsig','purelin'},'trainscg') ...
  • 通过分析磨削加工过程中的误差产生的原因,使用学习训练后的BP神经网络建立了双面磨床磨削加工误差补偿模型,详细阐述了网络模型的组织结构与核心算法,提出了实现磨削加工实时误差补偿技术的硬件组成方法,并通过实验...
  • 给出了使用BP神经网络实现光条中心提取的基本原理、训练网络所需的理想中心点的求取方法,以及网络权值的调整算法。研究了隐含层神经元个数m、隐含层层数h,以及训练样本对中心提取精度的影响,结果表明:当m=3,h=1,训练...
  • BP神经网络误差反向传播

    千次阅读 2018-10-18 16:36:35
    BP算法理解皮一下BP核心思想神经元激活函数:神经网络的结构 皮一下 “我是谁,我在哪,我要去那?”,自我哔哔下,项目已经开始大半年了,上级一味追求效果,怎么办呢,凉拌吧。虽然用过caffe,用过tensorflow,用...
  • 借助一个简单的BP神经网络结构,一步一步的将整个训练过程的计算过程以及公式推导过程展示一遍,内容步骤详细,没有跳步,数学基础仅需大学导数偏导数的基础。
  • GUI实现BP神经网络.zip

    2020-05-08 14:54:19
    通过GUI实现BP神经网络的设计,要求输入信号分别为随机噪声、正玄信号、方波信号,网络层数包含输入层、隐含层、输出层,训练方法有BP算法、带动量项的BP算法、Davidon最小二乘法、阻尼最小二乘法,并需要输出曲线和...
  • 声明全局变量global P_train % 训练集输入数据global T_train % 训练集输出数据global R % 输入神经元个数global S2 % 输出神经元个数global S1 % 隐层神经元个数global S % 编码长度S1 =7;%% 训练集/测试集产生...
  • BP网络实现y=1+x+x*x函数模拟,输入层一个节点,隐含层8个节点,输出层1个节点将数据分为测试集合和训练集合两部分%% BP算法模拟 y = 1 + x + x*x%作者:msl 时间:2017-10-07clc;clear;%% step0:定义TrainCount = ...
  • 我在做一个关于用BP神经网络给高光谱图像分类的算法,一个像素有220个光谱数据,每个像素对应了一类,已知的是一共有17类,现在我将每类数据都找到,并在其中选出训练集和测试集。训练集对应的输出就是类别号,如1,...
  • BP(BackPropagation)神经网络是1986年由Rumelhart和McCelland为首的科学家小组提出,是一种按误差逆传播算法训练的多层前馈...BP神经网络模型拓扑结构包括输入层(input)、隐层(hiddenlayer)和输出层(outputlayer)。
  • python实现BP神经网络的源代码,以及使用的马疝病数据集,基于BP神经网络的IRIS数据集训练和测试,有完整的数据集和实现代码,直接运行即可得到结果,并显示,正确率,误差,迭代次数等参数
  • %%BP神经网络---误差逆传播算法 %%算法流程: %(1)初始化权重、学习率、神经元个数、阈值、训练集、测试集、期望输出 %(2)神经网络的前反馈 %%该算法是处理二分类、多分类、多标签等分类算法研究
  • 使用双层BP神经网络,实现数据的读取,归一化处理,网络训练与网络预测,最后给出误差分析和结果可视化。
  • 话题:BP神经网络训练次数怎么每次运行后显示的次数不一样呢回答:额,你在编写BP神经网络程序时肯定是设定了训练次数或者结束训练条件的,BP算法的训练具有随机,所以达到结束条件的时间或训练次数一般是不同的。...
  • 预测结果表明:Adaboost的BP神经网络预测下沉值的平均绝对误差为0.585 3 mm,平均相对误差为5.82%,与BP神经网络预测相比,绝对误差降低了2.594 7 mm,相对误差降低了27.46%,由此表明Adaboost的BP神经网络适用...
  • 联想大家熟悉的回归问题,神经网络模型实际上是根据训练样本创造出一个多维输入多维输出的函数,并使用该函数进行预测, 网络的训练过程即为调节该函数参数提高预测精度的过程.神经网络要解决的问题与最小二乘法回归...
  • 本人刚入门,写了一段BP神经网络程序。用前四行预测第五行。但是误差蛮大,不知如何解决?加什么语句或更改什么语句?还望指点。。%建立一个5*85的矩阵a=zeros(5,85);%Real(S11)a(1,:)=[1.00 1.00 1.00 1.00 1.00 ...
  • 基于遗传算法的BP神经网络齿轮箱故障诊断实例 资源包含以下内容,下载即可运行 1) Sheffield的遗传算法工具箱; 2) Bpfun.m 表示BP神经网络函数 3) 遗传算法主函数.m 4) callbackfun.m 回代网格函数:将该初始权值...

空空如也

空空如也

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

bp神经网络训练误差

友情链接: regression.rar