精华内容
下载资源
问答
  • 两层隐含层BP神经网络,梯度下降法,反向权值更新
  • 基于人工蜂群算法的BP双隐含层神经网络水质模型.pdf
  • 基于BP神经网络的预测,代码已经调是成功,可直接运行。
  • MATLAB源码集锦-基于双隐含层BP神经网络的预测
  • 该文件主要包含了两个利用Matlab做的BP算法,主要用来实现预测,该文件中包含两个网络,一个是普通BP神经网络,一个为双隐含层BP神经网络
  • 基于双隐含层BP神经网络的预测
  • bp神经网络预测模型,可以很好的进行训练集和测试集建模,实用方便
  • Matlab遗传算法优化的BP神经网络(两个隐含层

    千次阅读 多人点赞 2019-05-05 19:55:16
    看了王小川的《MATLAB神经网络43个案例分析》,第三章的遗传算法优化BP神经网络,讲了只有一个隐含层神经网络如何使用遗传算法优化,这个代码网络上现在都有,我刚开始用这个代码跑了一下自己的样本,结果效果不好...

    看了王小川的《MATLAB神经网络43个案例分析》,第三章的遗传算法优化BP神经网络,讲了只有一个隐含层的神经网络如何使用遗传算法优化,这个代码网络上现在都有,我刚开始用这个代码跑了一下自己的样本,结果效果不好,除了要修改样本之外,我考虑到了是不是因为神经网络的层数较为单一了,只有一个隐含层,学习的效果不会太好,于是打算着手修改加一个 隐含层,五一之前调了一次,没改的出来,五一之后静下心重看了一遍,虽然能调试出来,但是效果还不是很好,希望大家能给些指点。

    构建的神经网络有两个隐含层,原书上只给出一个,所以原hiddennum要改为hiddennum1和hiddennum2,然后有一个newff的写法问题,说有新旧写法,这里引用一下matlab中newff新旧用法差异。

    %节点个数
    inputnum=5;
    hiddennum1=8;
    hiddennum2=8;
    outputnum=1;
    
    %构建网络
    net=newff(inputn,outputn,[hiddennum1 hiddennum2]);
    

    然后节点总数就得修改了

    %节点总数
    numsum=inputnum*hiddennum1+hiddennum1+hiddennum1*hiddennum2+hiddennum2+hiddennum2*outputnum+outputnum;
    

    fun函数也需要修改,多加一个隐含层

    function error = fun(x,inputnum,hiddennum1,hiddennum2,outputnum,net,inputn,outputn)
    

    修改权值和偏置,这边如果算的不对后面会提示出错,也就是reshape,错误RESHAPE,请勿更改元素数目,大致的意思就是w1,w2,w3里面所存的元素数量和你建立的神经网络结构不匹配,像我用的网络是5-8-8-1,

    w1的范围是x(1:40),B1的范围是x(41:48)

    w2的范围是x(49:112),B2的范围是x(113:120)

    w3的范围是x(121:128),B3的范围是x(128:136)

    这里我琢磨了挺久,不知道为什么数据的范围是这样的,其实这个和我们选择的网络有关系,输入层到隐含层1,5—8,

    w1就是5x8=40个,然后偏置b1=8,隐含层1到隐含层2,8—8,w2就是8x8=64,偏置b2依然是8,隐含层2到输出层,8—1,w3就是8,b3=8。要花点耐心查一下。

    w1=x(1:inputnum*hiddennum1);
    B1=x(inputnum*hiddennum1+1:inputnum*hiddennum1+hiddennum1);
    w2=x(inputnum*hiddennum1+hiddennum1+1:inputnum*hiddennum1+hiddennum1+hiddennum1*hiddennum2);
    B2=x(inputnum*hiddennum1+hiddennum1+hiddennum1*hiddennum2+1:inputnum*hiddennum1+hiddennum1+hiddennum1*hiddennum2+hiddennum2);
    w3=x(inputnum*hiddennum1+hiddennum1+hiddennum1*hiddennum2+hiddennum2+1:inputnum*hiddennum1+hiddennum1+hiddennum1*hiddennum2+hiddennum2+hiddennum2*outputnum);
    B3=x(inputnum*hiddennum1+hiddennum1+hiddennum1*hiddennum2+hiddennum2+hiddennum2*outputnum+1:inputnum*hiddennum1+hiddennum1+hiddennum1*hiddennum2+hiddennum2+hiddennum2*outputnum+outputnum);
    
    

    赋值问题是参见的百度的一个:

    net.IW 属性定义了从网络输入向量到网络层的权值向量(即输入层的权值向量)结构。其值为Nl*Ni的细胞矩阵,Nl为网络层数(net.numLayers),Ni为输入向量数(net.numInputs)。通过访问net.IW{i,j},可以获得第i 个网络层来自第j 个输入向量的权值向量值。 所以一般情况下net,iw{1,1}就是输入层和隐含层之间的权值。

    net.LW定义了从一个网络层到另一个网络层的权值向量结构。其值为Nl*Nl的细胞矩阵,Nl为网络层数(net.numLayers)。通过访问net.LW{i,j},可以获得第i 个网络层来自第j 个网络层的权值向量值。 因此,如果网络是单隐含层,net.lw{2,1}就是输出层和隐含层之间的权值

    %网络权值赋值
    net.iw{1,1}=reshape(w1,hiddennum1,inputnum);
    net.lw{2,1}=reshape(w2,hiddennum2,hiddennum1);
    net.lw{3,2}=reshape(w3,outputnum,hiddennum2);
    net.b{1}=reshape(B1,hiddennum1,1);
    net.b{2}=reshape(B2,hiddennum2,1);
    net.b{3}=B3;

    然后就可以看结果了,因为神经网络容易陷入局部最小,所以可能还需要对样本进行修改。

     

    展开全文
  • 这是C#包装器,可让您利用MATLAB的神经网络工具箱来创建,配置,训练和模拟两层神经网络。 需要MATLAB。 范例程式码 // Initializes the wrapper starting a MATLAB session Wrapper wrapper = new Wrapper(); // ...
  • 基于双隐含层BP神经网络的绞吸挖泥船产量预测.pdf
  • 基于Softplus函数的双隐含层BP神经网络的公路客运量预测.pdf
  • 双隐含层BP神经网络模型在老哈河水质预测中的应用.pdf
  • Matlab的双隐层的BP神经网络该如何创建-ANNBP2...两输入、双隐含层(第一隐含层神经元个数可在4-20范围内变化,第二隐含层可在5-10范围内变化) 不知道这个程序该怎样写 请高手赐教! 本人QQ :41402066
  • 基于双隐含层BP神经网络的预测源码.zip
  • 基于双隐含层BP神经网络的预测,bp神经网络隐含层层数的确定,matlab源码.zip.zip
  • 基于双隐含层BP神经网络的预测,bp神经网络隐含层层数的确定,matlab源码.rar
  • 基于双隐含层BP神经网络的预测.zip.zip
  • 基于双隐含层GA-BP神经网络的重型柴油车排放预测.pdf
  • 基于双隐含层RWPSO-BP神经网络的齿轮箱故障诊断研究.pdf
  • 运用双隐含层Elman神经网络进行一天24小时的电力负荷预测。
  • 双隐含层BP神经网络 梯度递减算法BGD.m:主程序BP.m : 使用工具箱计算的,作为对比
  • 隐含层神经网络的推导步骤非常类似于单隐含层神经网络的步骤,只不过是多重复几遍。 关于单隐含层神经网络公式的推导可以参考: http://blog.csdn.net/fengbingchun/article/details/79370310 逻辑回归是一个...

            多隐含层神经网络的推导步骤非常类似于单隐含层神经网络的步骤,只不过是多重复几遍

            关于单隐含层神经网络公式的推导可以参考: http://blog.csdn.net/fengbingchun/article/details/79370310 

            逻辑回归是一个浅层模型(shadow model),或称单层神经网络;单隐含层神经网络是一个双层神经网络。当我们数神经网络有几层的时候,我们不能把输入层数进去,只算上隐含层和输出层的数量

           符号约定:L:表示神经网络的层数;n[l]:第l层上节点(单元)的数量,如n[1]表示第一个隐含层单元数量;输入层作为第0层,即n[0]表示输入层单元数量;a[l]:表示第l层中的激活函数;a[l]=g[l](z[l]);w[l]:表示第l层中的权值,即在a[l]中计算z[l]值的权重;b[l]:表示第l层中的偏置,即计算z[l]值的偏置项;x:输入特征,x也是第0层的激活函数,即a[0]=x;最后一层的激活函数a[L]=y’(或称y hat),即a[L]等于预测输出;

            正向传播(单个样本):第1层到第L层(也就是从输入层到输出层的整个神经网络)

                    z[1]=w[1]*x+b[1];// x=a[0](输入特征向量x也是第0层的激活函数)

                    a[1]=g[1](z[1]);

                    z[2]=w[2]*a[1]+b[2];

                    a[2]=g[2](z[2]);

                    … …

                    z[L]=w[L]*a[L-1]+b[L];

                    a[L]=g[L](z[L]);

            正向传播基本规律公式

                    z[l]=w[l]*a[l-1]+b[l];

                    a[l]=g[l](z[l]);

            反向传播基本规律公式

                    dz[l]=da[l]*g[l]’(z[l]);

                    dw[l]=dz[l]*a[l-1];

                    db[l]=dz[l];

                    da[l-1]=w[l]T*dz[l];


            各层矩阵w、b维数的确定

                         w[l]的维度必须是:(n[l],n[l-1]);其中n[0]=nx,即输入特征x的长度,x的维度是(n[0],1);

                         b[l]的维度一般是:(n[l],1);

            z[l]和a[l]矩阵的维度应该是相等的(a[L]=g[L](z[L]));dz[l]和z[l]的维度是相等的;da[l]和a[l]的维度是相等的。

            在反向传播中,dw[l]的维度应该和w[l]的维度相同,即为(n[l],n[l-1]);db[l]的维度应该和b[l]的维度相同,即(n[l],1)。

            深度神经网络(deep neural network)很好用的原因

            假如你在建一个人脸识别或人脸检测系统,深度神经网络所做的事就是:当你输入一张脸部的照片,然后你可以把深度神经网络的第1层当成一个特征检测器或边缘检测器,例如在第1层创建一个大概有20个隐层单元的深度神经网络,隐层单元就是下图的这些小方块,一个小方块就是一个隐层单元,它会去找这张照片里的垂直或水平边缘的方向等,即第1层去找这张照片的各个边缘;然后它可以把检测到的边缘组合成面部的不同部分,比如说,可能有一个神经元会去找眼睛的部分,另外还有别的在找鼻子的部分,然后把这些许多的边缘结合在一起,就可以开始检测人脸的不同部分;最后再把这些部分放在一起,比如鼻子、眼睛、下巴,就是识别或检测不同的人脸。你可以直觉上把这种神经网络的前几层当做检测简单的函数,比如边缘,之后把它们跟后几层结合在一起,那么总体上就能学习更多复杂的函数。边缘(edge)检测器其实相对来说都是针对照片中非常小块的面积;面部检测器就会针对于大一些的区域。一般的概念是,一般会从比较小的细节入手,比如边缘,然后在一步步到更大更复杂的区域,比如一只眼睛或是一个鼻子;再把眼睛鼻子装一块组成更复杂的部分。这种从简单到复杂的金字塔状表示方法或者组成方法,也可以应用在图像或者人脸识别以外的其它数据上。


            参数和超参数(hyper parameters):参数包括各层的w和b。学习率α、梯度下降法中的迭代次数、隐含层数、各隐含层的单元数、激活函数的选择,这些都需要自己来设置,这些数字实际上控制了最终参数w和b的值。所以它们被称为超参数。因为这些超参数在某种程度上决定了最终得到的w和b。

            今天的深度学习应用领域,还是很经验性的过程:


            机器学习里的复杂性是来源于数据本身而不是一行行的代码

            GitHub: https://github.com/fengbingchun/NN_Test 

    展开全文
  • 程序中的最大学习次数,训练结束条件,学习率,隐含层神经元个数可以一步调整,所以读者可自行拿去测试,我下面的程序里隐含层神经元个数较多,运行时间会较长。另外,如果读者能对房价预测的精度提高给出建议,我将...

    前言

    程序中的最大学习次数,训练结束条件,学习率,隐含层神经元个数可以一步调整,所以读者可自行拿去测试,我下面的程序里隐含层神经元个数较多,运行时间会较长。另外,如果读者能对房价预测的精度提高给出建议,我将倍感荣幸,期待与你的交流。
    至于BP神经网络的原理及公式推导,此处不加阐释。数据文件可在我之前的文章中找到,链接如下:多元线性回归求解波士顿房价问题

    源程序

    #include<math.h>
    #include<stdio.h>
    #include<time.h>
    #include<stdlib.h>
    #define Data 380				//训练样本个数
    #define TestData 126			//测试样本个数
    #define In 13					//输入层神经元个数
    #define Out 1					//输出层神经元个数
    #define Neuron1 40				//隐含层1神经元个数 (程序运行需要很久)
    #define Neuron2 40				//隐含层2神经元个数 (程序运行需要很久)
    #define TrainC 100000			//训练次数
    #define WAlta 0.1			//权值w(隐含层2到输出层)学习率
    #define V1Alta 0.5				//权值v1(输入层到隐含层1)学习率
    #define V2Alta 0.5				//权值v2(隐含层1到隐含层2)学习率
    #define FeatureNumber 14		//特征个数加房价
    char FeatureName[FeatureNumber][15]; 	//存储特征名字
    double d_in[Data+TestData][In];			//存储输入数据用于乱序,并分出训练集和测试集
    double d_out[Data+TestData][Out];		//存储输出数据用于乱序,并分出训练集和测试集	
    double t_in[TestData][In];				//存储测试集输入
    double t_out[TestData][Out];			//存储测试集输出
    double pre[TestData][Out];				//存储预测样本的输出
    double v1[Neuron1][In];					//存储输入层到隐含层1的权值
    double v2[Neuron2][Neuron1];			//存储隐含层1到隐含层2的权值
    double Y1[Neuron1];						//存储隐含层1的输出
    double Y2[Neuron2];						//存储隐含层2的输出
    double w[Out][Neuron2];					//存储隐含层2到输出层的权值
    double Maxin[In], Minin[In];			//存储样本输入的最大,最小值
    double Maxout[Out], Minout[Out];		//存储样本输出的最大,最小值
    double OutputData[Out];					//存储神经网络的输出
    double dw[Out][Neuron2], dv2[Neuron2][Neuron1], dv1[Neuron1][In];//存储各权值的修正值
    double mse;								//存储均方误差
    double rmse;							//存储均方根误差
    void ReadData() {						//读取数据
    	srand((int)time(0));
    	int i, j, k;
    	FILE* fp;
    	if ((fp = fopen("housing.txt", "r")) == NULL) {		//打开数据文件
    		printf("不能打开文件!\n");
    		exit(0);
    	}
    	for (i = 0; i < FeatureNumber; ++i) {			//输入13个房价特征的名字以及房价MEDV
    		fscanf(fp, "%s", FeatureName[i]);
    	}
    	for (i = 0; i < Data+TestData; ++i) {			//文件中数据转移到数组
    		for (j = 0; j < In; ++j) {
    			fscanf(fp, "%lf", &d_in[i][j]);
    		}
    		for (k = 0; k < Out; ++k) {
    			fscanf(fp, "%lf", &d_out[i][k]);
    		}
    	}
    	for (i = 0; i < Data + TestData; ++i) {			//打乱数据集顺序
    		int k = rand() % (Data + TestData);
    		for (int l = 0; l < In; ++l) {
    			double tmp = d_in[i][l];
    			d_in[i][l] = d_in[k][l];
    			d_in[k][l] = tmp;
    		}
    		for (int l = 0; l < Out; ++l) {
    			double tmp = d_out[i][l];
    			d_out[i][l] = d_out[k][l];
    			d_out[k][l] = tmp;
    		}
    	}
    	for (i = Data; i < TestData+Data; ++i) {		//从数据集中分出训练集和测试集
    		for (j = 0; j < In; ++j) {
    			t_in[i-Data][j] = d_in[i][j];
    		}
    		for (k = 0; k < Out; ++k) {
    			t_out[i-Data][k] = d_out[i][k];
    		}
    	}
    	fclose(fp);
    }
    void InitBPNetwork() {									//初始化
    	int i, j;	
    	srand((int)time(0));
    	for (i = 0; i < In; ++i) {							//寻找训练集各输入(各特征)最大最小值
    		Minin[i] = Maxin[i] = d_in[0][i];
    		for (j = 0; j < Data; ++j) {
    			Maxin[i] = Maxin[i] > d_in[j][i] ? Maxin[i] : d_in[j][i];
    			Minin[i] = Minin[i] < d_in[j][i] ? Minin[i] : d_in[j][i];
    		}
    	}				
    	for (i = 0; i < Out; ++i) {							//寻找训练集输出(房价)最大最小值
    		Minout[i] = Maxout[i] = d_out[0][i];
    		for (j = 0; j < Data; ++j) {
    			Maxout[i] = Maxout[i] > d_out[j][i] ? Maxout[i] : d_out[j][i];
    			Minout[i] = Minout[i] < d_out[j][i] ? Minout[i] : d_out[j][i];
    		}
    	}
    	for (i = 0; i < In; ++i) {							//训练集输入数据归一化
    		for (j = 0; j < Data; ++j) {
    			d_in[j][i] = (d_in[j][i] - Minin[i]) / (Maxin[i] - Minin[i]);
    		}
    	}
    	for (i = 0; i < Out; ++i) {							//训练集输出数据归一化
    		for (j = 0; j < Data; ++j) {
    			d_out[j][i] = (d_out[j][i] - Minout[i]) / (Maxout[i] - Minout[i]);
    		}
    	}
    	for (i = 0; i < Neuron1; ++i) {						//初始化输入层到隐含层1的权值与修正值
    		for (j = 0; j < In; ++j) {
    			v1[i][j] = rand() * 2.0 / RAND_MAX - 1;
    			dv1[i][j] = 0;
    		}
    	}
    	for (i = 0; i < Neuron2; ++i) {						//初始化隐含层1到隐含层2的权值与修正值
    		for (j = 0; j < Neuron1; ++j) {
    			v2[i][j] = rand() * 2.0 / RAND_MAX - 1;
    			dv2[i][j] = 0;
    		}
    	}
    	for (i = 0; i< Out; ++i) {							//初始化隐含层2到输出层的权值与修正值
    		for (j = 0; j < Neuron2; ++j) {
    			w[i][j] = rand() * 2.0 / RAND_MAX - 1;
    			dw[i][j] = 0;
    		}
    	}
    }
    void ComputO(int var) {								//前向传播
    	int i, j;
    	double sum;
    	for (i = 0; i < Neuron1; ++i) {					//计算隐含层1的输出
    		sum = 0;
    		for (j = 0; j < In; ++j) {
    			sum += d_in[var][j] * v1[i][j];
    		}
    		Y1[i] = 1 / (1 + exp(-1 * sum));
    	}
    	for (i = 0; i < Neuron2; ++i) {					//计算隐含层2的输出
    		sum = 0;
    		for (j = 0; j < Neuron1; ++j) {
    			sum += Y1[j] * v2[i][j];
    		}
    		Y2[i] = 1 / (1 + exp(-1 * sum));
    	}
    	for (i = 0; i < Out; ++i) {						//计算输出层的输出
    		sum = 0;
    		for (j = 0; j < Neuron2; ++j) {
    			sum += Y2[j] * w[i][j];
    		}
    		OutputData[i] = 1 / (1 + exp(-1 * sum));	//神经网络的输出
    	}
    }
    void BackUpdata(int var) {							//反向传播的权值修正
    	int i, j, k;
    	double s;
    	double t = 0;
    	for (k = 0; k < Neuron1; ++k) {
    		s = 0;
    		for (i = 0; i < Neuron2; ++i) {
    			t = 0;
    			for (j = 0; j < Out; ++j) {
    				dw[j][i] = WAlta * (d_out[var][j] - OutputData[j]) * OutputData[j] * (1 - OutputData[j]) * Y2[i];//计算权值w的修正值
    				t += (d_out[var][j] - OutputData[j]) * OutputData[j] * (1 - OutputData[j]) * w[j][i];
    			}
    			for (j = 0; j < Neuron1; ++j) {
    				dv2[i][j] = V2Alta * t * Y2[i] * (1 - Y2[i]) * Y1[j];//计算权值v2的修正值
    			}
    			s += t * Y2[i] * (1 - Y2[i]) * v2[i][k];
    		}
    		for (i = 0; i < In; ++i) {
    			dv1[k][i] = V1Alta * s * Y1[k] * (1 - Y1[k]) * d_in[var][i];//计算权值v1的修正值
    		}
    	}
    	for (i = 0; i < In; ++i) {						//修正各权值
    		for (j = 0; j < Neuron1; ++j) {
    			v1[j][i] += dv1[j][i];
    		}
    	}
    	for (i = 0; i < Neuron1; ++i) {
    		for (j = 0; j < Neuron2; ++j) {
    			v2[j][i] += dv2[j][i];
    		}
    	}
    	for (i = 0; i < Neuron2; ++i) {
    		for (j = 0; j < Out; ++j) {
    			w[j][i] += dw[j][i];
    		}
    	}
    }
    void TrainNetwork() {							//神经网络的训练
    	int count = 1;
    	int i, j;
    	do {
    		mse = 0;
    		for (i = 0; i < Data; ++i) {
    			ComputO(i);
    			BackUpdata(i);
    			for (j = 0; j < Out; ++j) {
    				double tmp1 = OutputData[j] * (Maxout[j] - Minout[j]) + Minout[j];
    				double tmp2 = d_out[i][j] * (Maxout[j] - Minout[j]) + Minout[j];
    				mse += (tmp1 - tmp2) * (tmp1 - tmp2);	//累计均方误差
    			}
    		}
    		mse /= (double)Data * Out;				//计算均方误差
    		if (count % 1000 == 0) {					//观测
    			printf("训练次数:%d\t均方误差:%lf\n", count, mse);
    		}
    		count++;
    	} while (count <= TrainC && mse >= 1);
    	printf("\n训练结束\n\n");
    }
    void TestNetwork() {							//测试
    	int i, j, k;
    	double sum;
    	for (i = 0; i < In; ++i) {					//测试集输入数据归一化
    		for (j = 0; j < TestData; ++j) {
    			t_in[j][i] = (t_in[j][i] - Minin[i]) / (Maxin[i] - Minin[i]);
    		}
    	}
    	for (k = 0; k< TestData; ++k) {				//计算神经网络的输出
    		for (i = 0; i < Neuron1; ++i) {
    			sum = 0;
    			for (j = 0; j < In; ++j) {
    				sum += t_in[k][j] * v1[i][j];
    			}
    			Y1[i] = 1 / (1 + exp(-1 * sum));
    		}
    		for (i = 0; i < Neuron2; ++i) {
    			sum = 0;
    			for (j = 0; j < Neuron1; ++j) {
    				sum += Y1[j] * v2[i][j];
    			}
    			Y2[i] = 1 / (1 + exp(-1 * sum));
    		}
    		for (i = 0; i < Out; ++i) {
    			sum = 0;
    			for (j = 0; j < Neuron2; ++j) {
    				sum += Y2[j] * w[i][j];
    			}
    			pre[k][i] = (double)1 / (1 + exp(-1 * sum)) * (Maxout[i] - Minout[i]) + Minout[i];	//计算预测值
    			printf("编号:%d  \t预测值:%lf   实际值:%lf\n", k + 1, pre[k][i], t_out[k][i]);		//预测值与实际值比较
    		}
    	}
    	rmse = 0.0;
    	for (k = 0; k < TestData; ++k) {
    		for (i = 0; i < Out; ++i) {
    			rmse += (pre[k][i] - t_out[k][i]) * (pre[k][i] - t_out[k][i]);
    		}
    	}
    	rmse = sqrt(rmse / TestData / Out);		//均方根误差
    	printf("\nrmse: %.4lf\n", rmse);
    }
    int main() {
    	ReadData();
    	InitBPNetwork();
    	TrainNetwork();
    	TestNetwork();
    	return 0;
    }
    

    运行截图

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    由于最后得到的均方误差过大,怀疑可能是过度拟合的情况,把训练结束的条件改为mse>10,得到结果如下,进一步证明。
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 基于Matlab技术的双隐含层BP神经网络煤炭需求预测研究——以福建省煤炭需求为例.pdf
  • #结构化代码 把2中的全连接神经网络放入函数中 import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data # MNIST 数据集相关的常数 # 输入的几点疏对于MNIST来说就是是图片展...

    单隐层的全连接神经网络识别MNIST手写数字

    神经网络模型如图所示:

    (发现一个画图软件Graphviz 但好像渲染效果一般)

    代码如下:

    #结构化代码 把2中的双隐层全连接神经网络放入函数中
    import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    
    # MNIST 数据集相关的常数
    # 输入层的几点疏对于MNIST来说就是是图片展平之后的像素数量
    INPUT_NODE = 784
    # 输出层的节点数量 等分类类别的数量 需要进行区分的是10个数字 所以输出节点数目是10
    OUTPUT_NODE = 10
    
    # 配置神经网络的参数
    # 隐藏层的结点数 建立的模型只有一个隐藏层结构
    LAYER1_NODE = 500  # 这个隐藏层有500个节点
    # 一个训练的batch中训练数据个数 数字越小 训练过程越接近随机梯度下降(SGD)
    # 数字越大,训练越接近梯度下降
    BATCH_SIZE = 100
    
    # 基础的学习率
    LEARNING_RATE_BASE = 0.8
    # 学习率的衰减率
    LEARNING_RATE_DECAY = 0.99
    # 正则化项在损失函数中的系数
    REGULARIZATION_RATE = 0.0001
    # 训练的轮数
    TRAINING_STEPS = 30000
    # 滑动平均衰减率
    MOVING_AVERAGE_DECAY = 0.99
    
    # 使用的激活函数是 ReLU 激活函数
    
    def inference(input_tensor, avg_class, weights1, biases1, weights2, biases2):
        # 如果没有提供滑动平均类 直接使用当前的参数取值
        if avg_class is None:
            # 计算隐藏层的前向传播结果 使用ReLU哈数进行激活
            layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)
            return tf.matmul(layer1, weights2) + biases2
        else:
            # 首先使用avg_class.average 计算变量的滑动平均值
            # 然后计算相应的神经网络的前向传播结果
            layer1 = tf.nn.relu(tf.matmul(input_tensor, avg_class.average(weights1))+
                                avg_class.average(biases1))
            return tf.matmul(layer1, avg_class.average(weights2)) + avg_class.average(biases2)
    
    
    # 定义模型的训练过程
    def train(mnist):
        x = tf.placeholder(tf.float32, [None, INPUT_NODE], name='x-input')
        y_ = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name='y-input')
    
        # 生成 隐藏层的参数
        weights1 = tf.Variable(
            tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev=0.1)
        )
        biases1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))
        # 生成 输出层参数
        weights2 = tf.Variable(
            tf.truncated_normal([LAYER1_NODE, OUTPUT_NODE], stddev=0.1)
        )
        biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))
    
    
        # 计算当前参数下神经网络前向传播的结果  指定计算滑动平均的类为 None
        # 也就是函数不会使用参数的滑动平均值
        y = inference(x, None, weights1, biases1, weights2, biases2)
        # 定义存储训练额轮数的变量 此处的这个变量不需要计算滑动平均值
        # 所以设定为  不可训练  (trainable = False)
        global_step = tf.Variable(0, trainable=False)
    
        # 初始化 滑动平均类
        variable_averages = tf.train.ExponentialMovingAverage(
            MOVING_AVERAGE_DECAY, global_step
        )
        # 计算所有可训练的变量的滑动平均
        # tf.trainable_variables() 是所有的 可以训练的变量(参数)
        variable_averages_op = variable_averages.apply(tf.trainable_variables())
    
        # 计算使用了滑动平均之后的前向传播结果 指定了 variable_average
        average_y = inference(
            x, variable_averages, weights1, biases1, weights2, biases2
        )
    
        # 使用的损失函数是交叉熵 这里的交叉熵与之前的调用不太一样
        # 简单来说 就是将softmax回归 与 交叉熵 合并在一起  目的是为了加速计算 后面会具体介绍
        cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
            logits=y, labels=tf.argmax(y_, 1)
        )
        # 计算所有batch中所有样例的交叉熵平均值
        cross_entropy_mean = tf.reduce_mean(cross_entropy)
    
        # 为损失函数添加 l2 正则化项
        regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
        # 注意一般只会计算权重的正则化损失 不加入偏置
        regularization = regularizer(weights1) + regularizer(weights2)
        # 完整的损失函数
        loss = cross_entropy_mean + regularization
    
        # 指定指数衰减的学习率
        learning_rate = tf.train.exponential_decay(
            LEARNING_RATE_BASE,                  # 基础的学习率
            global_step,                         # 指定迭代的轮数
            mnist.train.num_examples / BATCH_SIZE,  # 过完所有的训练数据需要的迭代轮数
            LEARNING_RATE_DECAY                     # 学习率衰减速度
        )
    
        # 使用梯度下降法来优化
        train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
    
        # 在训练模型的过程中 需要反向传播来更新参数 也需要更新参数的滑动平均值
        # 使用这种方式可以同时运行这两个操作
        train_op = tf.group(train_step, variable_averages_op)
    
        # 检验使用了滑动平均模型的神经网络前向传播结果是否正确 #
        # average_y是模型的输出结果  y_ 是输入正确的标签集合
        corrext_prediction = tf.equal(tf.argmax(average_y, 1), tf.argmax(y_, 1))
    
        # 这个与之前的程序一样 都是计算一组数据上的准确率
        accuracy = tf.reduce_mean(tf.cast(corrext_prediction, tf.float32))
    
        with tf.Session() as sess:
            init_op = tf.global_variables_initializer()
            sess.run(init_op)
    
            # 准备训练数据集 和 测试数据集
            validate_feed = {x: mnist.validation.images,
                             y_: mnist.validation.labels}
    
            test_feed = {x: mnist.test.images,
                         y_: mnist.test.labels}
    
            for i in range(TRAINING_STEPS):
                if i % 1000 == 0:        # 1000轮输出一次结果
                    validate_acc = sess.run(accuracy, feed_dict=validate_feed)
                    print("After %d training steps, validation accuracy using average model is %g " %(i, validate_acc))
    
                xs, ys = mnist.train.next_batch(BATCH_SIZE)
                sess.run(train_op, feed_dict={x: xs, y_: ys})
    
            test_acc = sess.run(accuracy, feed_dict=test_feed)
            print("After %d training step, test accuracy using average model is %g" % (TRAINING_STEPS, test_acc))
    
    # 主程序入口
    def main(argv=None):
        mnist = input_data.read_data_sets("location", one_hot=True)
        train(mnist)
    
    # TensorFlow 定义的主程序入口 tf.app.run() 方法会调用main函数
    if __name__ == '__main__':
        tf.app.run()
    

     

     

    展开全文
  • 基于遗传算法的BP神经网络MATLAB程序
  • 理解人工神经网络,感知机模型、多层前馈神经网络、BP算法(反向传播算法)、输出层和隐含层梯度下降更新权值推导过程。(西瓜书笔记) (一)神经元模型 神经网络(neural networks): 神经网络是由具有适应性的...
  • ​ 如果不使用激活函数,每一输出都是上一输入的线性运算,无论神经网络有多少,最终的输出只是输入的线性组合,相当于感知机。如果使用了激活函数,将非线性因素引入到网络中,使得神经网络可以任意逼近任何...
  • 双层神经网络反向传播有部分和逻辑回归相似,可以直接使用其结论 d z [ 2 ] = a [ 2 ] − y (1) dz^{[2]} = a^{[2]} - y \tag1 d W [ 2 ] = d z [ 2 ] a [ 1 ] T (2) dW^{[2]} = dz^{[2]}a^{[1]^{T}} \tag2 ...

空空如也

空空如也

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

双隐含层神经网络