卷积神经网络全面解析之代码详解
卷积神经网络全面解析之代码详解
本文介绍多层感知机算法，特别是详细解读其代码实现，基于python theano，代码来自：Convolutional Neural Networks (LeNet)。
一、CNN卷积神经网络原理简介
要讲明白卷积神经网络，估计得长篇大论，网上有很多博文已经写得很好了，所以本文就不重复了，如果你了解CNN，那可以往下看，本文主要是详细地解读CNN的实现代码。
CNN的最大特点就是稀疏连接（局部感受）和权值共享，如下面两图所示，左为稀疏连接，右为权值共享。稀疏连接和权值共享可以减少所要训练的参数，减少计算复杂度。
至于CNN的结构，以经典的LeNet5来说明：
这个图真是无处不在，一谈CNN，必说LeNet5，这图来自于这篇论文：Gradient-Based Learning Applied to Document Recognition，论文很长，第7页那里开始讲LeNet5这个结构，建议看看那部分。
我这里简单说一下，LeNet5这张图从左到右，先是input，这是输入层，即输入的图片。input-layer到C1这部分就是一个卷积层（convolution运算），C1到S2是一个子采样层（pooling运算），关于卷积和子采样的具体过程可以参考下图：
然后，S2到C3又是卷积，C3到S4又是子采样，可以发现，卷积和子采样都是成对出现的，卷积后面一般跟着子采样。S4到C5之间是全连接的，这就相当于一个MLP的隐含层了（如果你不清楚MLP，参考《DeepLearning tutorial（3）MLP多层感知机原理简介+代码详解》）。C5到F6同样是全连接，也是相当于一个MLP的隐含层。最后从F6到输出output，其实就是一个分类器，这一层就叫分类层。ok，CNN的基本结构大概就是这样，由输入、卷积层、子采样层、全连接层、分类层、输出这些基本“构件”组成，一般根据具体的应用或
者问题，去确定要多少卷积层和子采样层、采用什么分类器。当确定好了结构以后，如何求解层与层之间的连接参数？一般采用向前传播（FP）+向后传播（BP）的方法来训练。具体可参考上面给出的链接。
二、CNN卷积神经网络代码详细解读（基于python+theano）
代码来自于深度学习教程：Convolutional Neural Networks (LeNet)，这个代码实现的是一个简化了的LeNet5，具体如下：
?没有实现location-specific gain and bias parameters
?用的是maxpooling，而不是average_pooling
?分类器用的是softmax，LeNet5用的是rbf
?LeNet5第二层并不是全连接的，本程序实现的是全连接另外，代码里将卷积层和子采用层合在一起，定义为
“LeNetConvPoolLayer“（卷积采样层），这好理解，因为它们总是成对出现。但是有个地方需要注意，代码中将卷积后的输出直接作为子采样层的输入，而没有加偏置b再通过sigmoid函数进行映射，即没有了下图中fx后面的bx以及sigmoid映射，也即直接由fx得到Cx。
最后，代码中第一个卷积层用的卷积核有20个，第二个卷积层用50个，而不是上面那张LeNet5图中所示的6个和16个。
了解了这些，下面看代码：
（1）导入必要的模块
（2）定义CNN的基本"构件"
CNN的基本构件包括卷积采样层、隐含层、分类器，如下?定义LeNetConvPoolLayer（卷积+采样层）见代码注释：
image_shape:(batch size, num input feature maps,image height, image width)
poolsize: (#rows, #cols)
"""
class LeNetConvPoolLayer(object):
def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):
#assert condition，condition为True，则继续往下执行，condition为False，中断程序
#image_shape[1]和filter_shape[1]都是num input feature maps，它们必须是一样的。
assert image_shape[1] == filter_shape[1]
self.input = input
#每个隐层神经元（即像素）与上一层的连接数为num input feature maps * filter height * filter width。
#可以用numpy.prod(filter_shape[1:])来求得
fan_in = numpy.prod(filter_shape[1:])
#lower layer上每个神经元获得的梯度来自于："num output feature maps * filter height * filter width" /pooling size
fan_out = (filter_shape[0] * numpy.prod(filter_shape[2:]) / numpy.prod(poolsize))
#以上求得fan_in、fan_out ，将它们代入公式，以此来随机初始化W,W就是线性卷积核
W_bound = numpy.sqrt(6. / (fan_in + fan_out))
self.W = theano.shared(
numpy.asarray(
rng.uniform(low=-W_bound, high=W_bound,
size=filter_shape),
dtype=theano.config.floatX
),
borrow=True
)
# the bias is a 1D tensor -- one bias per output feature map
#偏置b是一维向量，每个输出图的特征图都对应一个偏置，
#而输出的特征图的个数由filter个数决定，因此用filter_shape[0]即number of filters来初始化
b_values = numpy.zeros((filter_shape[0],),
dtype=theano.config.floatX)
self.b = theano.shared(value=b_values, borrow=True)
#将输入图像与filter卷积，conv.conv2d函数
#卷积完没有加b再通过sigmoid，这里是一处简化。
conv_out = conv.conv2d(
input=input,
filters=self.W,
filter_shape=filter_shape,
image_shape=image_shape
)
#maxpooling，最大子采样过程
?定义隐含层HiddenLayer
b是偏置，隐藏层有n_out个神经元，故b时n_out维向量。
rng即随机数生成器，numpy.random.RandomState，用于初始化W。
input训练模型所用到的所有输入，并不是MLP的输入层，MLP的输入层的神经元个数时n_in，而这里的参数input大小是（n_example,n_in）,每一行一个样本，即每一行作为MLP的输入层。
activation:激活函数,这里定义为函数tanh
"""
class HiddenLayer(object):
def __init__(self, rng, input, n_in, n_out, W=None, b=None,
activation=T.tanh):
self.input = input #类HiddenLayer的input即所传递进来的input
"""
注释：
代码要兼容GPU，则必须使用 dtype=theano.config.floatX,并且定义为theano.shared
另外，W的初始化有个规则：如果使用tanh函数，则在-
sqrt(6./(n_in+n_hidden))到sqrt(6./(n_in+n_hidden))之间均匀
抽取数值来初始化W，若时sigmoid函数，则以上再乘4倍。
"""
#如果W未初始化，则根据上述方法初始化。
#加入这个判断的原因是：有时候我们可以用训练好的参数来初始化W，见我的上一篇文章。
if W is None:
W_values = numpy.asarray(
rng.uniform(
low=-numpy.sqrt(6. / (n_in + n_out)),
high=numpy.sqrt(6. / (n_in + n_out)),
size=(n_in, n_out)
),
dtype=theano.config.floatX
)
if activation == theano.tensor.nnet.sigmoid:
W_values *= 4
W = theano.shared(value=W_values, name='W', borrow=True)
if b is None:
b_values = numpy.zeros((n_out,),
dtype=theano.config.floatX)
b = theano.shared(value=b_values, name='b', borrow=True)
#用上面定义的W、b来初始化类HiddenLayer的W、b
self.W = W
self.b = b
#隐含层的输出
lin_output = T.dot(input, self.W) + self.b
self.output = (
lin_output if activation is None
else activation(lin_output)
)
#隐含层的参数
?定义分类器（Softmax回归）
"""
定义分类层LogisticRegression，也即Softmax回归
在deeplearning tutorial中，直接将LogisticRegression视为Softmax，
而我们所认识的二类别的逻辑回归就是当n_out=2时的LogisticRegression
"""
#参数说明：
#input，大小就是(n_example,n_in)，其中n_example是一个batch的大小，
#因为我们训练时用的是Minibatch SGD，因此input这样定义
#n_in,即上一层(隐含层)的输出
#n_out,输出的类别数
class LogisticRegression(object):
def __init__(self, input, n_in, n_out):
#W大小是n_in行n_out列，b为n_out维向量。即：每个输出对应W的一列以及b的一个元素。
self.W = theano.shared(
value=numpy.zeros(
(n_in, n_out),
dtype=theano.config.floatX
),
name='W',
borrow=True
)
self.b = theano.shared(
value=numpy.zeros(
(n_out,),
dtype=theano.config.floatX
),
name='b',
borrow=True
)
#input是(n_example,n_in)，W是（n_in,n_out）,点乘得到
(n_example,n_out)，加上偏置b，
#再作为T.nnet.softmax的输入，得到p_y_given_x
#故p_y_given_x每一行代表每一个样本被估计为各类别的概率
#PS：b是n_out维向量，与(n_example,n_out)矩阵相加，内部其实是先复制n_example个b，
#然后(n_example,n_out)矩阵的每一行都加b
self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)
#argmax返回最大值下标，因为本例数据集是MNIST，下标刚好就是类别。axis=1表示按行操作。
self.y_pred = T.argmax(self.p_y_given_x, axis=1)
到这里，CNN的基本”构件“都有了，下面要用这些”构件“组装成LeNet5（当然，是简化的，上面已经说了），具体来说，就是组装成：
LeNet5=input+LeNetConvPoolLayer_1+LeNetConvPoolLayer _2+HiddenLayer+LogisticRegression+output。
然后将其应用于MNIST数据集，用BP算法去解这个模型，得到最优的参数。
（3）加载MNIST数据集（mnist.pkl.gz）
"data",
dataset
)
if os.path.isfile(new_path) or data_file == 'mnist.pkl.gz': dataset = new_path
if (not os.path.isfile(dataset)) and data_file == 'mnist.pkl.gz': import urllib
origin = (
'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz'
)
print 'Downloading data from %s' % origin
urllib.urlretrieve(origin, dataset)
print '... loading data'
#以上是检测并下载数据集mnist.pkl.gz，不是本文重点。下面才是load_data 的开始
#从"mnist.pkl.gz"里加载train_set, valid_set, test_set，它们都是包括label的
#主要用到python里的gzip.open()函数,以及 cPickle.load()。
#‘rb’表示以二进制可读的方式打开文件
f = gzip.open(dataset, 'rb')
train_set, valid_set, test_set = cPickle.load(f)
f.close()
#将数据设置成shared variables，主要时为了GPU加速，只有shared variables才能存到GPU memory中
#GPU里数据类型只能是float。而data_y是类别，所以最后又转换为int返回
def shared_dataset(data_xy, borrow=True):
data_x, data_y = data_xy
shared_x = theano.shared(numpy.asarray(data_x,
dtype=theano.config.floatX),
borrow=borrow)
shared_y = theano.shared(numpy.asarray(data_y,
dtype=theano.config.floatX),
borrow=borrow)
return shared_x, T.cast(shared_y, 'int32')
test_set_x, test_set_y = shared_dataset(test_set)
valid_set_x, valid_set_y = shared_dataset(valid_set)
train_set_x, train_set_y = shared_dataset(train_set)
rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y), (test_set_x, test_set_y)]
return rval
（4）实现LeNet5并测试
dataset='mnist.pkl.gz',
nkerns=[20, 50], batch_size=500):
"""
learning_rate:学习速率，随机梯度前的系数。
n_epochs训练步数，每一步都会遍历所有batch，即所有样本
batch_size,这里设置为500，即每遍历完500个样本，才计算梯度并更新参数
nkerns=[20, 50],每一个LeNetConvPoolLayer卷积核的个数，第一个LeNetConvPoolLayer有
20个卷积核，第二个有50个
"""
rng = numpy.random.RandomState(23455)
#加载数据
datasets = load_data(dataset)
train_set_x, train_set_y = datasets[0]
valid_set_x, valid_set_y = datasets[1]
test_set_x, test_set_y = datasets[2]
# 计算batch的个数
n_train_batches = train_set_x.get_value(borrow=True).shape[0]
n_valid_batches = valid_set_x.get_value(borrow=True).shape[0]
n_test_batches = test_set_x.get_value(borrow=True).shape[0]
n_train_batches /= batch_size
n_valid_batches /= batch_size
n_test_batches /= batch_size
#定义几个变量，index表示batch下标，x表示输入的训练数据，y对应其标签
index = T.lscalar()
x = T.matrix('x')
y = T.ivector('y')
######################
# BUILD ACTUAL MODEL #
######################
print '... building the model'
#我们加载进来的batch大小的数据是(batch_size, 28 * 28)，但是LeNetConvPoolLayer的输入是四维的，所以要reshape
layer0_input = x.reshape((batch_size, 1, 28, 28))
# layer0即第一个LeNetConvPoolLayer层
#输入的单张图片(28,28)，经过conv得到(28-5+1 , 28-5+1) = (24, 24)，
#经过maxpooling得到(24/2, 24/2) = (12, 12)
#因为每个batch有batch_size张图，第一个LeNetConvPoolLayer层有nkerns[0]个卷积核，
#故layer0输出为(batch_size, nkerns[0], 12, 12)
layer0 = LeNetConvPoolLayer(
rng,
input=layer0_input,
image_shape=(batch_size, 1, 28, 28),
filter_shape=(nkerns[0], 1, 5, 5),
poolsize=(2, 2)
)
#layer1即第二个LeNetConvPoolLayer层
#输入是layer0的输出，每张特征图为(12,12),经过conv得到(12-5+1, 12-5+1) = (8, 8),
#经过maxpooling得到(8/2, 8/2) = (4, 4)
#因为每个batch有batch_size张图（特征图），第二个LeNetConvPoolLayer 层有nkerns[1]个卷积核
#，故layer1输出为(batch_size, nkerns[1], 4, 4)
layer1 = LeNetConvPoolLayer(
rng,
input=layer0.output,
image_shape=(batch_size, nkerns[0], 12, 12),#输入nkerns[0]张特征图，即layer0输出nkerns[0]张特征图
filter_shape=(nkerns[1], nkerns[0], 5, 5),
poolsize=(2, 2)
)
#前面定义好了两个LeNetConvPoolLayer（layer0和layer1），layer1后面接layer2，这是一个全连接层，相当于MLP里面的隐含层
#故可以用MLP中定义的HiddenLayer来初始化layer2，layer2的输入是二维的(batch_size, num_pixels) ，
#故要将上层中同一张图经不同卷积核卷积出来的特征图合并为一维向量，
#也就是将layer1的输出(batch_size, nkerns[1], 4, 4)flatten为
(batch_size, nkerns[1]*4*4)=(500，800),作为layer2的输入。
#(500，800)表示有500个样本，每一行代表一个样本。layer2的输出大小是(batch_size,n_out)=(500,500)
layer2_input = layer1.output.flatten(2)
layer2 = HiddenLayer(
rng,
input=layer2_input,
n_in=nkerns[1] * 4 * 4,
n_out=500,
activation=T.tanh
)
#最后一层layer3是分类层，用的是逻辑回归中定义的LogisticRegression，
#layer3的输入是layer2的输出(500,500)，layer3的输出就是
(batch_size,n_out)=(500,10)
layer3 = LogisticRegression(input=layer2.output, n_in=500,
n_out=10)
#代价函数NLL
cost = layer3.negative_log_likelihood(y)
# test_model计算测试误差，x、y根据给定的index具体化，然后调用
layer3，
#layer3又会逐层地调用layer2、layer1、layer0，故test_model其实就是整个CNN结构，
#test_model的输入是x、y，输出是layer3.errors(y)的输出，即误差。
test_model = theano.function(
[index],
layer3.errors(y),
givens={
x: test_set_x[index * batch_size: (index + 1) * batch_size],
y: test_set_y[index * batch_size: (index + 1) * batch_size]
}
)
#validate_model，验证模型，分析同上。
validate_model = theano.function(
[index],
layer3.errors(y),
givens={
x: valid_set_x[index * batch_size: (index + 1) * batch_size],
y: valid_set_y[index * batch_size: (index + 1) * batch_size]
}
)
#下面是train_model，涉及到优化算法即SGD，需要计算梯度、更新参数
#参数集
params = layer3.params + layer2.params + layer1.params + layer0.params
#对各个参数的梯度
grads = T.grad(cost, params)
%%%清除空间 clc clear all ; close all ; %%%训练数据预测数据提取以及归一化 %%%下载四类数据 load data1 c1 load data2 c2 load data3 c3 load data4 c4 %%%%四个特征信号矩阵合成一个矩阵data ( 1:500 , : ) = data1 ( 1:500 , :) ; data ( 501:1000 , : ) = data2 ( 1:500 , : ) ; data ( 1001:1500 , : ) = data3 ( 1:500 , : ) ; data ( 1501:2000 , : ) = data4 ( 1:500 , : ) ; %%%%%%从1到2000间的随机排序 k = rand ( 1 , 2000 ) ; [ m , n ] = sort ( k ) ; %%m为数值，n为标号
%%%%%%%%%%%输入输出数据 input = data ( : , 2:25 ) ; output1 = data ( : , 1) ; %%%%%%把输出从1维变到4维 for i = 1 : 1 :2000 switch output1( i ) case 1 output( i , :) = [ 1 0 0 0 ] ; case 2 output( i , :) = [ 0 1 0 0 ] ; case 3 output( i , :) = [ 0 0 1 0 ] ; case 4 output( i , :) = [ 0 0 0 1 ] ; end end %%%%随机抽取1500个样本作为训练样本，500个样本作为预测样本 input_train = input ( n( 1:1500 , : ) )’ ; output_train = output ( n( 1:1500 , : ) )’ ; input_test = input ( n( 1501:2000 , : ) )’ ;
MATLAB程序代码--BP神经网络的设计实例 例1 采用动量梯度下降算法训练 BP 网络。 训练样本定义如下： 输入矢量为 p =[-1 -2 3 1 -1 1 5 -3] 目标矢量为 t = [-1 -1 1 1] 解：本例的 MATLAB 程序如下： close all clear echo on clc % NEWFF——生成一个新的前向神经网络 % TRAIN——对 BP 神经网络进行训练 % SIM——对 BP 神经网络进行仿真 pause % 敲任意键开始 clc % 定义训练样本 % P 为输入矢量 P=[-1, -2, 3, 1; -1, 1, 5, -3]; % T 为目标矢量 T=[-1, -1, 1, 1]; pause; clc % 创建一个新的前向神经网络 net=newff(minmax(P),[3,1],{'tansig','purelin'},'traingdm') % 当前输入层权值和阈值 inputWeights=net.IW{1,1} inputbias=net.b{1} % 当前网络层权值和阈值 layerWeights=net.LW{2,1} layerbias=net.b{2} pause clc % 设置训练参数 net.trainParam.show = 50; net.trainParam.lr = 0.05; net.trainParam.mc = 0.9;
net.trainParam.epochs = 1000; net.trainParam.goal = 1e-3; pause clc % 调用 TRAINGDM 算法训练 BP 网络 [net,tr]=train(net,P,T); pause clc % 对 BP 网络进行仿真 A = sim(net,P) % 计算仿真误差 E = T - A MSE=mse(E) pause clc echo off 例2 采用贝叶斯正则化算法提高 BP 网络的推广能力。在本例中，我们采用两种训练方法，即 L-M 优化算法（trainlm）和贝叶斯正则化算法（trainbr），用以训练 BP 网络，使其能够拟合某一附加有白噪声的正弦样本数据。其中，样本数据可以采用如下MATLAB 语句生成：输入矢量：P = [-1:0.05:1]； 目标矢量：randn(’seed’,78341223)； T = sin(2*pi*P)+0.1*randn(size(P))； 解：本例的 MATLAB 程序如下： close all clear echo on
一、简介 卷积神经网络（Convolutional Neural Networks，简称CNN）是近年发展起来，并引起广泛重视的一种高效的识别方法。 1962年，Hubel和Wiesel在研究猫脑皮层中用于局部敏感和方向选择的神经元时发现其独特的局部互连网络结构可以有效地降低反馈神经网络的复杂性，继而提出了卷积神经网络[1]（Convolutional Neural Networks-简称CNN）7863。现在，CNN已经成为众多科学领域的研究热点之一，特别是在模式分类领域，由于该网络避免了对图像的复杂前期预处理，可以直接输入原始图像，因而得到了更为广泛的应用。 Fukushima在1980年基于神经元间的局部连通性和图像的层次组织转换，为解决模式识别问题，提出的新识别机（Neocognitron）是卷积神经网络的第一个实现网络[2]。他指出，当在不同位置应用具有相同参数的神经元作为前一层的patches时，能够实现平移不变性1296。随着1986年BP算法以及T-C问题[3]（即权值共享和池化）9508的提出，LeCun和其合作者遵循这一想法，使用误差梯度（the error gradient）设计和训练卷积神经网络，在一些模式识别任务中获得了最先进的性能[4][5]。在1998年，他们建立了一个多层人工神经网络，被称为LeNet-5[5]，用于手写数字分类,这是第一个正式的卷积神经网络模型3579。类似于一般的神经网络，LeNet-5有多层，利用BP算法来训练参数。它可以获得原始图像的有效表示，使得直接从原始像素（几乎不经过预处理）中识别视觉模式成为可能。然而，由于当时大型训练数据和计算能力的缺乏，使得LeNet-5在面对更复杂的问题时，如大规模图像和视频分类，不能表现出良好的性能。 因此，在接下来近十年的时间里，卷积神经网络的相关研究趋于停滞，原因有两个：一是研究人员意识到多层神经网络在进行BP训练时的计算量极其之大，当时的硬件计算能力完全不可能实现；二是包括SVM在内的浅层机器学习算法也渐渐开始暂露头脚。直到2006年，Hinton终于一鸣惊人，在《科学》上发表文章，使得CNN再度觉醒，并取得长足发展。随后，更多的科研工作者对该网络进行了改进。其中，值得注意的是Krizhevsky等人提出的一个经典的CNN架构，相对于图像分类任务之前的方法，在性能方面表现出了显著的改善2674。他们方法的整体架构，即AlexNet[9]（也叫ImageNet），与LeNet-5相似，但具有更深的结构。它包括8个学习层（5个卷积与池化层和3个全连接层），前边的几层划分到2个GPU上，（和ImageNet是同一个）并且它在卷积层使用ReLU作为非线性激活函数，在全连接层使用Dropout减少过拟合。该深度网络在ImageNet 大赛上夺冠，进一步掀起了CNN学习热潮。 一般地，CNN包括两种基本的计算，其一为特征提取，每个神经元的输入与前一层的局部接受域相连，并提取该局部的特征。一旦该局部特征被提取后，它与其它特征间的位置关系也随之确定下来；其二是特征映射，网络的每个计算层由多个特征映射组成，每个特征映射是一个平面，平面上所有神经元的权值相等。特征映射结构采用影响函数核小的sigmoid函数作为卷积网络的激活函数，使得特征映射具有位移不变性。此外，由于一个映射面上的神经元共享权值，因而减少了网络自由参数的个数。这两种操作形成了CNN的卷积层。此外，卷积神经网络中的每一个卷积层都紧跟着一个用来求局部平均与二次提取的计算层，即池化层，这种特有的两次特征提取结构减小了特征分辨率。
BP神经网络实现（Java代码） 神经网络的原理虽然理解起来不难，但是要是想实现它，还是需要做一些工作的，并且有很多细节性的东西需要注意。通过参阅各种相关资料，以及参考网络上已有的资源，自己写了一个含有一个隐含层，且只能有一个输出单元的简单的BP网络，经过测试，达到了预期的效果。 需要说明的是，神经网络的每个输入都在[0,1]中，输出也在[0,1]中，在使用神经网络解决实际问题的时候，还需要对实际问题的输入输出进行归一化处理。另外，尽量不要使得神经网络的输入或输出接近于0或1，这样会影响拟合效果。 我用正弦函数进行了一次测试，效果如图所示： 以下是相关的代码： 1.神经网络代码 [java]view plaincopy 1.package pkg1; 2. 3.import java.util.Scanner; 4. 5./* 6.* 7.*/ 8.public class TestNeuro{
9. 10.private int INPUT_DIM=1; 11.private int HIDDEN_DIM=20; 12.private double LEARNING_RATE=0.05; 13.double[][]input_hidden_weights=new double[INPUT_DIM][HIDDEN_DIM]; 14.double[]hidden_output_weights=new double[HIDDEN_DIM]; 15.double[]hidden_thresholds=new double[HIDDEN_DIM]; 16.double output_threshold; 17. 18.public static void main(String[]args){ 19.Scanner in=new Scanner(System.in); 20.TestNeuro neuro=new TestNeuro(1,5); 21.neuro.initialize(); 22.for(int i=0;i<10000;i++){ 23.double[]input=new double[1]; 24.input[0]=Math.random(); 25.double expectedOutput=input[0]*input[0]; 26.//System.out.println("input:"+input[0]+"\t\texpectedOutput: "+expectedOutput); 27.//System.out.println("predict before training:"+neuro.predict (input)); 28.neuro.trainOnce(input,expectedOutput); 29.//System.out.println("predict after training:"+neuro.predict( input)); 30.//in.next(); 31.} 32.while(true){ 33.//neuro.printLinks(); 34.double[]input=new double[1]; 35.input[0]=in.nextDouble(); 36.double expectedOutput=in.nextDouble(); 37.System.out.println("predict before training:"+neuro.predict(i nput)); 38.neuro.trainOnce(input,expectedOutput); 39.System.out.println("predict after training:"+neuro.predict(in put)); 40. 41.} 42.} 43. 44.public TestNeuro(int input_dimension,int hidden_dimension){ 45.this.INPUT_DIM=input_dimension; 46.this.HIDDEN_DIM=hidden_dimension; 47.this.initialize();
用遗传算法优化BP神经网络的Matlab编程实例（转） 由于BP网络的权值优化是一个无约束优化问题，而且权值要采用实数编码，所以直接利用Matlab遗传算法工具箱。以下贴出的代码是为一个19输入变量，1个输出变量情况下的非线性回归而设计的，如果要应用于其它情况，只需改动编解码函数即可。 程序一：GA训练BP权值的主函数 function net=GABPNET(XX,YY) %-------------------------------------------------------------------------- % GABPNET.m % 使用遗传算法对BP网络权值阈值进行优化，再用BP算法训练网络 %-------------------------------------------------------------------------- %数据归一化预处理 nntwarn off XX=[1:19;2:20;3:21;4:22]'; YY=[1:4]; XX=premnmx(XX); YY=premnmx(YY); YY %创建网络 net=newff(minmax(XX),[19,25,1],{'tansig','tansig','purelin'},'tra inlm'); %下面使用遗传算法对网络进行优化 P=XX; T=YY; R=size(P,1); S2=size(T,1); S1=25;%隐含层节点数 S=R*S1+S1*S2+S1+S2;%遗传算法编码长度 aa=ones(S,1)*[-1,1]; popu=50;%种群规模 save data2 XX YY % 是将 xx,yy 二个变数的数值存入 data2 这个MAT-file，initPpp=initializega(popu,aa,'gabpEval');%初始化种群 gen=100;%遗传代数
close all clear echo on clc % NEWFF——生成一个新的前向神经网络 % TRAIN——对 BP 神经网络进行训练 % SIM——对 BP 神经网络进行仿真 % 定义训练样本 % P为输入矢量 P=[0.7317 0.6790 0.5710 0.5673 0.5948;0.6790 0.5710 0.5673 0.5948 0.6292; ... 0.5710 0.5673 0.5948 0.6292 0.6488;0.5673 0.5948 0.6292 0.6488 0.6130; ... 0.5948 0.6292 0.6488 0.6130 0.5654; 0.6292 0.6488 0.6130 0.5654 0.5567; ... 0.6488 0.6130 0.5654 0.5567 0.5673;0.6130 0.5654 0.5567 0.5673 0.5976; ... 0.5654 0.5567 0.5673 0.5976 0.6269;0.5567 0.5673 0.5976 0.6269 0.6274; ... 0.5673 0.5976 0.6269 0.6274 0.6301;0.5976 0.6269 0.6274 0.6301 0.5803; ... 0.6269 0.6274 0.6301 0.5803 0.6668;0.6274 0.6301 0.5803 0.6668 0.6896; ... 0.6301 0.5803 0.6668 0.6896 0.7497]; % T为目标矢量 T=[0.6292 0.6488 0.6130 0.5654 0.5567 0.5673 0.5976 ... 0.6269 0.6274 0.6301 0.5803 0.6668 0.6896 0.7497 0.8094]; % Ptest为测试输入矢量 Ptest=[0.5803 0.6668 0.6896 0.7497 0.8094;0.6668 0.6896 0.7497 0.8094 0.8722; ... 0.6896 0.7497 0.8094 0.8722 0.9096]; % Ttest为测试目标矢量 Ttest=[0.8722 0.9096 1.0000]; % 创建一个新的前向神经网络 net=newff(minmax(P'),[12,1],{'logsig','purelin'},'traingdm'); % 设置训练参数 net.trainParam.show = 50; net.trainParam.lr = 0.05; net.trainParam.mc = 0.9; net.trainParam.epochs = 5000; net.trainParam.goal = 0.001; % 调用TRAINGDM算法训练 BP 网络 [net,tr]=train(net,P',T); % 对BP网络进行仿真 A=sim(net,P'); figure; plot((1993:2007),T,'-*',(1993:2007),A,'-o'); title('网络的实际输出和仿真输出结果，*为真实值，o为预测值'); xlabel('年份'); ylabel('客运量'); % 对BP网络进行测试 A1=sim(net,Ptest');
一文读懂卷积神经网络 自今年七月份以来，一直在实验室负责卷积神经网络（Convolutional Neural Network，CNN），期间配置和使用过theano和cuda-convnet、 cuda-convnet2。为了增进CNN的理解和使用，特写此博文，以其与人交流，互有增益。正文之前，先说几点自己对于CNN的感触。先明确一点就是，Deep Learning是全部深度学习算法的总称，CNN是深度学习算法在图像处理领域的一个应用。 第一点，在学习Deep learning和CNN之前，总以为它们是很了不得的知识，总以为它们能解决很多问题，学习了之后，才知道它们不过与其他机器学习算法如svm等相似，仍然可以把它当做一个分类器，仍然可以像使用一个黑盒子那样使用它。 第二点，Deep Learning强大的地方就是可以利用网络中间某一层的输出当做是数据的另一种表达，从而可以将其认为是经过网络学习到的特征。基于该特征，可以进行进一步的相似度比较等。 第三点，Deep Learning算法能够有效的关键其实是大规模的数据，这一点原因在于每个DL都有众多的参数，少量数据无法将参数训练充分。 接下来话不多说，直接奔入主题开始CNN之旅。 卷积神经网络简介（Convolutional Neural Networks，简称CNN） 卷积神经网络是近年发展起来，并引起广泛重视的一种高效识别方法。20世纪60年代，Hubel和Wiesel在研究猫脑皮层中用于局部敏感和方向选择的神经元时发现其独特的网络结构可以有效地降低反馈神经网络的复杂性，继而提出了卷积神经网络（Convolutional Neural Networks-简称CNN）。现在，CNN已经成为众多科学领域的研究热点之一，特别是在模式分类领域，由于该网络避免了对图像的复杂前期预处理，可以直接输入原始图像，因而得到了更为广泛的应用。K.Fukushima在1980年提出的新识别机是卷积神经网络的第一个实现网络。随后，更多的科研工作者对该网络进行了改进。其中，具有代表性的研究成果是Alexander和Taylor提出的“改进认知机”，该方法综合了各种改进方法的优点并避免了耗时的误差反向传播。 一般地，CNN的基本结构包括两层，其一为特征提取层，每个神经元的输入与前一层的局部接受域相连，并提取该局部的特征。一旦该局部特征被提取后，它与其它特征间的位置关系也随之确定下来；其二是特征映射层，网络的每个计算层由多个特征映射组成，每个特征映射是一个平面，平面上所有神经元的权值相等。特征映射结构采用影响函数核小的sigmoid函数作为卷积网络的激活函数，使得特征映射具有位移不变性。此外，由于一个映射面上的神经元共享权值，因而减少了网络自由参数的个数。卷积神经网络中的每一个卷积层都紧跟着一个
BP神经网络matlab代码 p=[284528334488;283344884554;448845542928;455429283497;29283497 2261;... 349722616921;226169211391;692113913580;139135804451;35804451 2636;... 445126363471;263634713854;347138543556;385435562659;35562659 4335;... 265943352882;433528824084;433528821999;288219992889;19992889 2175;... 288921752510;217525103409;251034093729;340937293489;37293489 3172;... 348931724568;317245684015;]'; %====期望输出======= t=[4554292834972261692113913580445126363471385435562659... 4335288240841999288921752510340937293489317245684015... 3666]; ptest=[284528334488;283344884554;448845542928;455429283497;29283497 2261;... 349722616921;226169211391;692113913580;139135804451;35804451 2636;... 445126363471;263634713854;347138543556;385435562659;35562659 4335;... 265943352882;433528824084;433528821999;288219992889;19992889 2175;... 288921752510;217525103409;251034093729;340937293489;37293489 3172;... 348931724568;317245684015;456840153666]'; [pn,minp,maxp,tn,mint,maxt]=premnmx(p,t);%将数据归一化 NodeNum1=20;%隐层第一层节点数 NodeNum2=40;%隐层第二层节点数 TypeNum=1;%输出维数 TF1='tansig'; TF2='tansig'; TF3='tansig'; net=newff(minmax(pn),[NodeNum1,NodeNum2,TypeNum],{TF1TF2 TF3},'traingdx');
一文读懂卷积神经网络CNN ★据说阿尔法狗战胜李世乭靠的是卷积神经网络算法，所以小编找到了一篇介绍该算法的文章，大家可以看一看。★ 自去年七月份以来，一直在实验室负责卷积神经网络（Convolutional Neural Network，CNN），期间配置和使用过theano和cuda-convnet、cuda-convnet2。为了增进CNN的理解和使用，特写此博文，以其与人交流，互有增益。正文之前，先说几点自己对于CNN的感触。先明确一点就是，Deep Learning是全部深度学习算法的总称，CNN是深度学习算法在图像处理领域的一个应用。第一点，在学习Deep learning 和CNN之前，总以为它们是很了不得的知识，总以为它们能解决很多问题，学习了之后，才知道它们不过与其他机器学习算法如svm等相似，仍然可以把它当做一个分类器，仍然可以像使用一个黑盒子那样使用它。第二点，Deep Learning强大的地方就是可以利用网络中间某一层的输出当做是数据的另一种表达，从而可以将其认为是经过网络学习到的特征。基于该特征，可以进行进一步的相似度比较等。第三点，Deep Learning算法能够有效的关键其实是大规模的数据，这一点原因在于每个DL都有众多的参数，少量数据无法将参数训练充分。接下来话不多说，直接奔入主题开始
CNN之旅。卷积神经网络简介（Convolutional Neural Networks，简称CNN）卷积神经网络是近年发展起来，并引起广泛重视的一种高效识别方法。20世纪60年代，Hubel 和Wiesel在研究猫脑皮层中用于局部敏感和方向选择的神经元时发现其独特的网络结构可以有效地降低反馈神经网 络的复杂性，继而提出了卷积神经网络（Convolutional Neural Networks-简称CNN）。现在，CNN已经成为众多科学领域的研究热点之一，特别是在模式分类领域，由于该网络避免了对图像的复杂前期预处理，可以直接输入原始图像，因而得到了更为广泛的应用。K.Fukushima在1980年提出的新识别机是卷积神经网络的第一个实现网络。随后，更多的科研工作者对该网络进行了改进。其中，具有代表性的研究成果是Alexander和Taylor提出的“改进认知机”，该方法综合了各种改进方法的优点并避免了耗时的误差反向传播。一般地，CNN的基本结构包括两层，其一为特征提取层，每个神经元的输入与前一层的局部接受域相连，并提取该局部的特征。一旦该局部特征被提取后，它与其它特征间的位置关系也随之确定下来；其二是特征映射层，网络的每个计算层由多个特征映射组成，每个特征映射是一个平面，平面上所有神经元的权值相等。特征映射结构采用影响函数核小的sigmoid 函数作为卷积网络的激活函数，使得特征映射具有位移不变性。此外，由于一个映射面上的神经元共享权值，因而减少
deepLearnToolbox-master是一个深度学习matlab包，里面含有很多机器学习算法，如卷积神经网络CNN，深度信念网络DBN，自动编码AutoEncoder（堆栈SAE，卷积CAE）的作者是Rasmus Berg Palm)代码下载：rasmusbergpalm/DeepLearnToolbox 这里我们介绍deepLearnToolbox-master中的CNN部分。 DeepLearnToolbox-master中CNN内的函数： 调用关系为： 该模型使用了mnist的数字作为训练样本，作为cnn的一个使用样例， 每个样本特征为一个28*28=的向量。 网络结构为： 让我们来看看各个函数： 一、Test_example_CNN: (1) 三、 (2) 四、 (2) 五、 (2) 五、 (2) 六、 (3) 一、Test_example_CNN: Test_example_CNN: 1设置CNN的基本参数规格，如卷积、降采样层的数量，卷积核的大小、降采样的降幅 2cnnsetup函数初始化卷积核、偏置等
3cnntrain函数训练cnn，把训练数据分成batch，然后调用 cnnff完成训练的前向过程， cnnbp计算并传递神经网络的error，并计算梯度（权重的修改量） cnnapplygrads把计算出来的梯度加到原始模型上去 4cnntest函数，测试当前模型的准确率 该模型采用的数据为， 含有70000个手写数字样本其中60000作为训练样本，10000作为测试样本。 把数据转成相应的格式，并归一化。 设置网络结构及训练参数 初始化网络，对数据进行批训练，验证模型准确率 绘制均方误差曲线 二、 该函数你用于初始化CNN的参数。 设置各层的mapsize大小， 初始化卷积层的卷积核、bias 尾部单层感知机的参数设置 * bias统一设置为0 权重设置为：-1~1之间的随机数/sqrt（6/（输入神经元数量+输出神经元数量））
BP神经网络matlab源程序代码） %******************************% 学习程序 %******************************% %======原始数据输入======== p=[2845 2833 4488;2833 4488 4554;4488 4554 2928;4554 2928 3497;2928 3497 2261;... 3497 2261 6921;2261 6921 1391;6921 1391 3580;1391 3580 4451;3580 4451 2636;... 4451 2636 3471;2636 3471 3854;3471 3854 3556;3854 3556 2659;3556 2659 4335;... 2659 4335 2882;4335 2882 4084;4335 2882 1999;2882 1999 2889;1999 2889 2175;... 2889 2175 2510;2175 2510 3409;2510 3409 3729;3409 3729 3489;3729 3489 3172;... 3489 3172 4568;3172 4568 4015;]'; %===========期望输出======= t=[4554 2928 3497 2261 6921 1391 3580 4451 2636 3471 3854 3556 2659 ... 4335 2882 4084 1999 2889 2175 2510 3409 3729 3489 3172 4568 4015 ... 3666]; ptest=[2845 2833 4488;2833 4488 4554;4488 4554 2928;4554 2928 3497;2928 3497 2261;... 3497 2261 6921;2261 6921 1391;6921 1391 3580;1391 3580 4451;3580 4451 2636;... 4451 2636 3471;2636 3471 3854;3471 3854 3556;3854 3556 2659;3556 2659 4335;... 2659 4335 2882;4335 2882 4084;4335 2882 1999;2882 1999 2889;1999 2889 2175;... 2889 2175 2510;2175 2510 3409;2510 3409 3729;3409 3729 3489;3729 3489 3172;... 3489 3172 4568;3172 4568 4015;4568 4015 3666]'; [pn,minp,maxp,tn,mint,maxt]=premnmx(p,t); %将数据归一化 NodeNum1 =20; % 隐层第一层节点数 NodeNum2=40; % 隐层第二层节点数 TypeNum = 1; % 输出维数 TF1 = 'tansig';
BP神经网络实例含源码 BP神经网络算法实现 一:关于BP网络 BP (Back Propagation)神经网络，即误差反传误差反向传播算法的学习过程，由信息的正向传播和误差的反向传播两个过程组成。输入层各神经元负责接收来自外界的输入信息，并传递给中间层各神经元;中间层是内部信息处理层，负责信息变换，根据信息变化能力的需求，中间层可以设计为单隐层或者多隐层结构;最后一个隐层传递到输出层各神经元的信息，经进一步处理后，完成一次学习的正向传播处理过程，由输出层向外界输出信息处理结果。 当实际输出与期望输出不符时，进入误差的反向传播阶段。误差通过输出层，按误差梯度下降的方式修正各层权值，向隐层、输入层逐层反传。周而复始的信息正向传播和误差反向传播过程，是各层权值不断调整的过程，也是神经网络学习训练的过程，此过程一直进行到网络输出的误差减少到可以接受的程度，或者预先设定的学习次数为止。 BP网络主要应用于以下方面:函数逼近、模式识别和分类、数据压缩。BP神经网络有较强的泛化性能，使网络平滑的逼近函数，能合理的响应被训练以外的输入。 同时，BP网络又有自己的限制与不足，主要表现在:需要较长的训练时间、网络训练的结果可能使得权值逼近局部最优、训练数据范围外的数据泛化能力较差。 为了避免训练陷入局部最优解，本程序采用改进的BP网络训练，既加入动量因子，使得网络在最优解附近有一定的震荡，跳出局部最优的范围。 BP网络训练中学习速率与动量因子的选择很重要，在后面的内容中将进行详细的讨论。
二:训练的函数 程序中训练的函数为一个三输入一输出的非线性函数，如下所示: x3xR,yxxe,，，，2sin()，，，12 网络结构为:3—5—1 三:程序及相关界面(VB) 1 主界面 1 代码: Private Sub Command1_Click() form2.Visible = False Form3.Visible = True End Sub Private Sub Command2_Click() form2.Visible = False Form1.Visible = True End Sub Private Sub Command3_Click() form2.Visible = False Form4.Visible = True End Sub Private Sub Command4_Click() form2.Visible = False
深度神经网络全面概述从基本概念到实际模型和硬件基础 深度神经网络(DNN)所代表的人工智能技术被认为是这一次技术变革的基石(之一)。近日，由 IEEE Fellow Joel Emer 领导的一个团队发布了一篇题为《深度神经网络的有效处理：教程和调研(Efficient Processing of Deep Neural Networks: A Tutorial and Survey)》的综述论文，从算法、模型、硬件和架构等多个角度对深度神经网络进行了较为全面的梳理和总结。鉴于该论文的篇幅较长，机器之心在此文中提炼了原论文的主干和部分重要内容。 目前，包括计算机视觉、语音识别和机器人在内的诸多人工智能应用已广泛使用了深度神经网络(deep neural networks，DNN)。DNN 在很多人工智能任务之中表现出了当前最佳的准确度，但同时也存在着计算复杂度高的问题。因此，那些能帮助 DNN 高效处理并提升效率和吞吐量，同时又无损于表现准确度或不会增加硬件成本的技术是在人工智能系统之中广泛部署 DNN 的关键。 论文地址： 本文旨在提供一个关于实现 DNN 的有效处理(efficient processing)的目标的最新进展的全面性教程和调查。特别地，本文还给出了一个 DNN 综述——讨论了支持 DNN 的多种平台和架构，并强调了最新的有效处理的技术的关键趋势，这些技术或者只是通过改善硬件设计或者同时改善硬件设计和网络算法以降低 DNN 计算成本。本文也会对帮助研究者和从业者快速上手 DNN 设计的开发资源做一个总结，并凸显重要的基准指标和设计考量以评估数量快速增长的 DNN 硬件设计，还包括学界和产业界共同推荐的算法联合设计。 读者将从本文中了解到以下概念：理解 DNN 的关键设计考量;通过基准和对比指标评估不同的 DNN 硬件实现;理解不同架构和平台之间的权衡;评估不同 DNN 有效处理技术的设计有效性;理解最新的实现趋势和机遇。 一、导语 深度神经网络(DNN)目前是许多人工智能应用的基础 [1]。由于 DNN 在语音识别 [2] 和图像识别 [3] 上的突破性应用，使用DNN 的应用量有了爆炸性的增长。这些 DNN 被部署到了从自动驾驶汽车 [4]、癌症检测 [5] 到复杂游戏 [6] 等各种应用中。在这许多领域中，DNN 能够超越人类的准确率。而 DNN 的出众表现源于它能使用统计学习方法从原始感官数据中提取高层特征，在大量的数据中获得输入空间的有效表征。这与之前使用手动提取特征或专家设计规则的方法不同。 然而 DNN 获得出众准确率的代价是高计算复杂性成本。虽然通用计算引擎(尤其是 GPU)，已经成为许多 DNN 处理的砥柱，但提供对 DNN 计算更专门化的加速方法也越来越热门。本文的目标是提供对 DNN、理解 DNN 行为的各种工具、有效加速计算的各项技术的概述。 该论文的结构如下： Section II 给出了 DNN 为什么很重要的背景、历史和应用。 Section III 给出了 DNN 基础组件的概述，还有目前流行使用的 DNN 模型。 Section IV 描述了 DNN 研发所能用到的各种资源。 Section V 描述了处理 DNN 用到的各种硬件平台，以及在不影响准确率的情况下改进吞吐量(thoughtput)和能量的各种优化方法(即产生 bit-wise identical 结果)。 Section VI 讨论了混合信号回路和新的存储技术如何被用于近数据处理(near-data processing)，从而解决 DNN 中数据流通时面临的吞吐量和能量消耗难题。 Section VII 描述了各种用来改进 DNN 吞吐量和能耗的联合算法和硬件优化，同时最小化对准确率的影响。 Section VIII 描述了对比 DNN 设计时应该考虑的关键标准。
卷积神经网络全面解析之代码注释 自己平时看了一些论文，但老感觉看完过后就会慢慢的淡忘，某一天重新拾起来的时候又好像没有看过一样。所以想习惯地把一些感觉有用的论文中的知识点总结整理一下，一方面在整理过程中，自己的理解也会更深，另一方面也方便未来自己的勘察。更好的还可以放到博客上面与大家交流。因为基础有限，所以对论文的一些理解可能不太正确，还望大家不吝指正交流. 下面是自己对代码的注释： cnnexamples.m [plain]view plain copy 1.clear all; close all; clc; 2.addpath('../data'); 3.addpath('../util'); 4.load mnist_uint8; 5. 6.train_x = double(reshape(train_x',28,28,60000))/255; 7.test_x = double(reshape(test_x',28,28,10000))/255; 8.train_y = double(train_y'); 9.test_y = double(test_y'); 10. 11.%% ex1 12.%will run 1 epoch in about 200 second and get around 11% error. 13.%With 100 epochs you'll get around 1.2% error 14. 15.c https://www.doczj.com/doc/ae10922064.html,yers = { 16. struct('type', 'i') %input layer 17. struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convol ution layer 18. struct('type', 's', 'scale', 2) %sub sampling layer
卷积神经网络全面解析之算法实现 前言 从理解卷积神经到实现它，前后花了一个月时间，现在也还有一些地方没有理解透彻，CNN还是有一定难度的，不是看哪个的博客和一两篇论文就明白了，主要还是靠自己去专研，阅读推荐列表在末尾的参考文献。目前实现的CNN在MINIT数据集上效果还不错，但是还有一些bug，因为最近比较忙，先把之前做的总结一下，以后再继续优化。 卷积神经网络CNN是Deep Learning的一个重要算法，在很多应用上表现出卓越的效果，[1]中对比多重算法在文档字符识别的效果，结论是CNN优于其他所有的算法。CNN 在手写体识别取得最好的效果，[2]将CNN应用在基于人脸的性别识别，效果也非常不错。前段时间我用BP神经网络对手机拍照图片的数字进行识别，效果还算不错，接近98%，但在汉字识别上表现不佳，于是想试试卷积神经网络。 1、CNN的整体网络结构 卷积神经网络是在BP神经网络的改进，与BP类似，都采用了前向传播计算输出值，反向传播调整权重和偏置；CNN与标准的BP最大的不同是：CNN中相邻层之间的神经单元并不是全连接，而是部分连接，也就是某个神经单元的感知区域来自于上层的部分神经单元，而不是像BP那样与所有的神经单元相连接。CNN的有三个重要的思想架构： ?局部区域感知 ?权重共享 ?空间或时间上的采样 局部区域感知能够发现数据的一些局部特征，比如图片上的一个角，一段弧，这些基本特征是构成动物视觉的基础[3]；而BP中，所有的像素点是一堆混乱的点，相互之间的关系没有被挖掘。 CNN中每一层的由多个map组成，每个map由多个神经单元组成，同一个map的所有神经单元共用一个卷积核（即权重），卷积核往往代表一个特征，比如某个卷积和代表一段弧，那么把这个卷积核在整个图片上滚一下，卷积值较大的区域就很有可能是一段弧。注意卷积核其实就是权重，我们并不需要单独去计算一个卷积，而是一个固定大小的权重矩阵去图像上匹配时，这个操作与卷积类似，因此我们称为卷积神经网络，实际上，BP也可以看做一种特殊的卷积神经网络，只是这个卷积核就是某层的所有权重，即感知区域是整个图像。权重共享策略减少了需要训练的参数，使得训练出来的模型的泛华能力更强。 采样的目的主要是混淆特征的具体位置，因为某个特征找出来后，它的具体位置已经不重要了，我们只需要这个特征与其他的相对位置，比如一个“8”，当我们得到了上面一个"o"时，我们不需要知道它在图像的具体位置，只需要知道它下面又是一个“o”我们就可以知道是一个'8'了，因为图片中"8"在图片中偏左或者偏右都不影响我们认识它，这种混淆具体位置的策略能对变形和扭曲的图片进行识别。 CNN的这三个特点是其对输入数据在空间（主要针对图像数据）上和时间（主要针对时间序列数据，参考TDNN）上的扭曲有很强的鲁棒性。CNN一般采用卷积层与采样层交
p=p1';t=t1'; [pn,minp,maxp,tn,mint,maxt]=premnmx(p,t); %原始数据归一化 net=newff(minmax(pn),[5,1],{'tansig','purelin'},'traingdx');%设置网络,建立相应的BP网络net.trainParam.show=2000; % 训练网络 net.trainParam.lr=0.01; net.trainParam.epochs=100000; net.trainParam.goal=1e-5; [net,tr]=train(net ,pn,tn); %调用TRAINGDM算法训练BP 网络 pnew=pnew1'; pnewn=tramnmx(pnew,minp,maxp); anewn=sim(net,pnewn); %对BP网络进行仿真 anew=postmnmx(anewn,mint,maxt); %还原数据 y=anew'; 1、BP网络构建 （1）生成BP网络 = net newff PR S S SNl TF TF TFNl BTF BLF PF (,[1 2...],{ 1 2...},,,) PR：由R维的输入样本最小最大值构成的2 R?维矩阵。 S S SNl：各层的神经元个数。 [ 1 2...] { 1 2...} TF TF TFNl：各层的神经元传递函数。 BTF：训练用函数的名称。 （2）网络训练 [,,,,,] (,,,,,,) = net tr Y E Pf Af train net P T Pi Ai VV TV （3）网络仿真 = [,,,,] (,,,,) Y Pf Af E perf sim net P Pi Ai T {'tansig','purelin'},'trainrp'