narx神经网络（narx神经网络预测代码）

本篇文章给大家谈谈narx神经网络，以及narx神经网络预测代码对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、matlabR2013b中神经网络训练好后，如何进行预测
• 2、【神经网络时间序列】请教NAR网络预测问题，谢谢
• 3、matlab BP神经网络的训练算法中训练函数（traingdm 、trainlm、trainbr）的实现过程及相应的VC源代码
• 4、汽车发动机开环和闭环的区别？
• 5、循环神经网络

matlabR2013b中神经网络训练好后，如何进行预测

预测的时候还是将需要的参数作为输入返春。训练的时候不是有15组样本吗（4*15和6*15的），说明输入节点漏裤耐数为4，输出节点数为6。因此预测时，将用于预测的4个参数作为输入，神经网络的6个输出即为预测结果。

神经网络因其很好的函数逼近能力而被广泛应用于非线性系统建模、辨识和控制中。根据应用场合的不同,神经网络可分为静态和动态神经网络两类。静态(或前馈)神经网络没有反馈成分,也不包含输人延时,输出直接由输人通过前纯樱向网络算出;动态神经网络的输出不仅依赖当前的输人,还与当前和过去的输入、输出有关。

[img]

【神经网络时间序列】请教NAR网络预测问题，谢谢

NAR网戚握络是只有y(t),NARX网络是有x(t)和y(t).

对于NAR网络来说，其只能够输出相对于延迟向量的下一个值。故需要用循环不断更新集合，把时间步往前推进。

T=tonndata(force,false,false); %输入和输出矩阵须为cell类型的矩阵，且不能用num2cell来转换，如果使用二维cell矩阵，将会被认为是两个输入从春塌而不能训练.假设force数据集只有50个（一行）。

force_raw=T(1:30); %创造一个1*30的Xi，与延迟向量1:30对应起来。为已知矩阵。

for j=1:50 %y1的前20个是对照高森庆着force里面第31个到50个，加上可以预测后面30个数据。

y1(j)=net(T(10),force_raw); %这里还需要大神指教，T（10）里面是当前矩阵，数字可以任意取，结果都一样。只是为了输出一维矩阵

force_raw=[force_raw(2:end),y1(j)]; %更新得到新的已知矩阵，为2,3~,30,31，下一步第一行应该是得到第43个。 不断更新即可得到预测值。

matlab BP神经网络的训练算法中训练函数（traingdm 、trainlm、trainbr）的实现过程及相应的VC源代码

VC源代码？你很局裂卖搞笑嘛源塌。。

给你trainlm的m码

function [out1,out2] = trainlm(varargin)

%TRAINLM Levenberg-Marquardt backpropagation.

%

% a href="matlab:doc trainlm"trainlm/a is a network training function that updates weight and

% bias states according to Levenberg-Marquardt optimization.

%

% a href="matlab:doc trainlm"trainlm/a is often the fastest backpropagation algorithm in the toolbox,

% and is highly recommended as a first choice supervised algorithm,

% although it does require more memory than other algorithms.

%

% [NET,TR] = a href="桐逗matlab:doc trainlm"trainlm/a(NET,X,T) takes a network NET, input data X

% and target data T and returns the network after training it, and a

% a training record TR.

%

% [NET,TR] = a href="matlab:doc trainlm"trainlm/a(NET,X,T,Xi,Ai,EW) takes additional optional

% arguments suitable for training dynamic networks and training with

% error weights. Xi and Ai are the initial input and layer delays states

% respectively and EW defines error weights used to indicate

% the relative importance of each target value.

%

% Training occurs according to training parameters, with default values.

% Any or all of these can be overridden with parameter name/value argument

% pairs appended to the input argument list, or by appending a structure

% argument with fields having one or more of these names.

% show 25 Epochs between displays

% showCommandLine 0 generate command line output

% showWindow 1 show training GUI

% epochs 100 Maximum number of epochs to train

% goal 0 Performance goal

% max_fail 5 Maximum validation failures

% min_grad 1e-10 Minimum performance gradient

% mu 0.001 Initial Mu

% mu_dec 0.1 Mu decrease factor

% mu_inc 10 Mu increase factor

% mu_max 1e10 Maximum Mu

% time inf Maximum time to train in seconds

%

% To make this the default training function for a network, and view

% and/or change parameter settings, use these two properties:

%

% net.a href="matlab:doc nnproperty.net_trainFcn"trainFcn/a = 'trainlm';

% net.a href="matlab:doc nnproperty.net_trainParam"trainParam/a

%

% See also trainscg, feedforwardnet, narxnet.

% Mark Beale, 11-31-97, ODJ 11/20/98

% Updated by Orlando De Jes鷖, Martin Hagan, Dynamic Training 7-20-05

% Copyright 1992-2010 The MathWorks, Inc.

% $Revision: 1.1.6.11.2.2 $ $Date: 2010/07/23 15:40:16 $

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

% BOILERPLATE_START

% This code is the same for all Training Functions.

persistent INFO;

if isempty(INFO), INFO = get_info; end

nnassert.minargs(nargin,1);

in1 = varargin{1};

if ischar(in1)

switch (in1)

case 'info'

out1 = INFO;

case 'check_param'

nnassert.minargs(nargin,2);

param = varargin{2};

err = nntest.param(INFO.parameters,param);

if isempty(err)

err = check_param(param);

end

if nargout 0

out1 = err;

elseif ~isempty(err)

nnerr.throw('Type',err);

end

otherwise,

try

out1 = eval(['INFO.' in1]);

catch me, nnerr.throw(['Unrecognized first argument: ''' in1 ''''])

end

end

return

end

nnassert.minargs(nargin,2);

net = nn.hints(nntype.network('format',in1,'NET'));

oldTrainFcn = net.trainFcn;

oldTrainParam = net.trainParam;

if ~strcmp(net.trainFcn,mfilename)

net.trainFcn = mfilename;

net.trainParam = INFO.defaultParam;

end

[args,param] = nnparam.extract_param(varargin(2:end),net.trainParam);

err = nntest.param(INFO.parameters,param);

if ~isempty(err), nnerr.throw(nnerr.value(err,'NET.trainParam')); end

if INFO.isSupervised isempty(net.performFcn) % TODO - fill in MSE

nnerr.throw('Training function is supervised but NET.performFcn is undefined.');

end

if INFO.usesGradient isempty(net.derivFcn) % TODO - fill in

nnerr.throw('Training function uses derivatives but NET.derivFcn is undefined.');

end

if net.hint.zeroDelay, nnerr.throw('NET contains a zero-delay loop.'); end

[X,T,Xi,Ai,EW] = nnmisc.defaults(args,{},{},{},{},{1});

X = nntype.data('format',X,'Inputs X');

T = nntype.data('format',T,'Targets T');

Xi = nntype.data('format',Xi,'Input states Xi');

Ai = nntype.data('format',Ai,'Layer states Ai');

EW = nntype.nndata_pos('format',EW,'Error weights EW');

% Prepare Data

[net,data,tr,~,err] = nntraining.setup(net,mfilename,X,Xi,Ai,T,EW);

if ~isempty(err), nnerr.throw('Args',err), end

% Train

net = struct(net);

fcns = nn.subfcns(net);

[net,tr] = train_network(net,tr,data,fcns,param);

tr = nntraining.tr_clip(tr);

if isfield(tr,'perf')

tr.best_perf = tr.perf(tr.best_epoch+1);

end

if isfield(tr,'vperf')

tr.best_vperf = tr.vperf(tr.best_epoch+1);

end

if isfield(tr,'tperf')

tr.best_tperf = tr.tperf(tr.best_epoch+1);

end

net.trainFcn = oldTrainFcn;

net.trainParam = oldTrainParam;

out1 = network(net);

out2 = tr;

end

% BOILERPLATE_END

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

% TODO - MU = MU_START

% TODO - alternate parameter names (i.e. MU for MU_START)

function info = get_info()

info = nnfcnTraining(mfilename,'Levenberg-Marquardt',7.0,true,true,...

[ ...

nnetParamInfo('showWindow','Show Training Window Feedback','nntype.bool_scalar',true,...

'Display training window during training.'), ...

nnetParamInfo('showCommandLine','Show Command Line Feedback','nntype.bool_scalar',false,...

'Generate command line output during training.'), ...

nnetParamInfo('show','Command Line Frequency','nntype.strict_pos_int_inf_scalar',25,...

'Frequency to update command line.'), ...

...

nnetParamInfo('epochs','Maximum Epochs','nntype.pos_int_scalar',1000,...

'Maximum number of training iterations before training is stopped.'), ...

nnetParamInfo('time','Maximum Training Time','nntype.pos_inf_scalar',inf,...

'Maximum time in seconds before training is stopped.'), ...

...

nnetParamInfo('goal','Performance Goal','nntype.pos_scalar',0,...

'Performance goal.'), ...

nnetParamInfo('min_grad','Minimum Gradient','nntype.pos_scalar',1e-5,...

'Minimum performance gradient before training is stopped.'), ...

nnetParamInfo('max_fail','Maximum Validation Checks','nntype.strict_pos_int_scalar',6,...

'Maximum number of validation checks before training is stopped.'), ...

...

nnetParamInfo('mu','Mu','nntype.pos_scalar',0.001,...

'Mu.'), ...

nnetParamInfo('mu_dec','Mu Decrease Ratio','nntype.real_0_to_1',0.1,...

'Ratio to decrease mu.'), ...

nnetParamInfo('mu_inc','Mu Increase Ratio','nntype.over1',10,...

'Ratio to increase mu.'), ...

nnetParamInfo('mu_max','Maximum mu','nntype.strict_pos_scalar',1e10,...

'Maximum mu before training is stopped.'), ...

], ...

[ ...

nntraining.state_info('gradient','Gradient','continuous','log') ...

nntraining.state_info('mu','Mu','continuous','log') ...

nntraining.state_info('val_fail','Validation Checks','discrete','linear') ...

]);

end

function err = check_param(param)

err = '';

end

function [net,tr] = train_network(net,tr,data,fcns,param)

% Checks

if isempty(net.performFcn)

warning('nnet:trainlm:Performance',nnwarning.empty_performfcn_corrected);

net.performFcn = 'mse';

net.performParam = mse('defaultParam');

tr.performFcn = net.performFcn;

tr.performParam = net.performParam;

end

if isempty(strmatch(net.performFcn,{'sse','mse'},'exact'))

warning('nnet:trainlm:Performance',nnwarning.nonjacobian_performfcn_replaced);

net.performFcn = 'mse';

net.performParam = mse('defaultParam');

tr.performFcn = net.performFcn;

tr.performParam = net.performParam;

end

% Initialize

startTime = clock;

original_net = net;

[perf,vperf,tperf,je,jj,gradient] = nntraining.perfs_jejj(net,data,fcns);

[best,val_fail] = nntraining.validation_start(net,perf,vperf);

WB = getwb(net);

lengthWB = length(WB);

ii = sparse(1:lengthWB,1:lengthWB,ones(1,lengthWB));

mu = param.mu;

% Training Record

tr.best_epoch = 0;

tr.goal = param.goal;

tr.states = {'epoch','time','perf','vperf','tperf','mu','gradient','val_fail'};

% Status

status = ...

[ ...

nntraining.status('Epoch','iterations','linear','discrete',0,param.epochs,0), ...

nntraining.status('Time','seconds','linear','discrete',0,param.time,0), ...

nntraining.status('Performance','','log','continuous',perf,param.goal,perf) ...

nntraining.status('Gradient','','log','continuous',gradient,param.min_grad,gradient) ...

nntraining.status('Mu','','log','continuous',mu,param.mu_max,mu) ...

nntraining.status('Validation Checks','','linear','discrete',0,param.max_fail,0) ...

];

nn_train_feedback('start',net,status);

% Train

for epoch = 0:param.epochs

% Stopping Criteria

current_time = etime(clock,startTime);

[userStop,userCancel] = nntraintool('check');

if userStop, tr.stop = 'User stop.'; net = best.net;

elseif userCancel, tr.stop = 'User cancel.'; net = original_net;

elseif (perf = param.goal), tr.stop = 'Performance goal met.'; net = best.net;

elseif (epoch == param.epochs), tr.stop = 'Maximum epoch reached.'; net = best.net;

elseif (current_time = param.time), tr.stop = 'Maximum time elapsed.'; net = best.net;

elseif (gradient = param.min_grad), tr.stop = 'Minimum gradient reached.'; net = best.net;

elseif (mu = param.mu_max), tr.stop = 'Maximum MU reached.'; net = best.net;

elseif (val_fail = param.max_fail), tr.stop = 'Validation stop.'; net = best.net;

end

% Feedback

tr = nntraining.tr_update(tr,[epoch current_time perf vperf tperf mu gradient val_fail]);

nn_train_feedback('update',net,status,tr,data, ...

[epoch,current_time,best.perf,gradient,mu,val_fail]);

% Stop

if ~isempty(tr.stop), break, end

% Levenberg Marquardt

while (mu = param.mu_max)

% CHECK FOR SINGULAR MATRIX

[msgstr,msgid] = lastwarn;

lastwarn('MATLAB:nothing','MATLAB:nothing')

warnstate = warning('off','all');

dWB = -(jj+ii*mu) \ je;

[~,msgid1] = lastwarn;

flag_inv = isequal(msgid1,'MATLAB:nothing');

if flag_inv, lastwarn(msgstr,msgid); end;

warning(warnstate)

WB2 = WB + dWB;

net2 = setwb(net,WB2);

perf2 = nntraining.train_perf(net2,data,fcns);

% TODO - possible speed enhancement

% - retain intermediate variables for Memory Reduction = 1

if (perf2 perf) flag_inv

WB = WB2; net = net2;

mu = max(mu*param.mu_dec,1e-20);

break

end

mu = mu * param.mu_inc;

end

% Validation

[perf,vperf,tperf,je,jj,gradient] = nntraining.perfs_jejj(net,data,fcns);

[best,tr,val_fail] = nntraining.validation(best,tr,val_fail,net,perf,vperf,epoch);

end

end

汽车发动机开环和闭环的区别？

开环控制和闭环控制的区别：

一、开环控制：控制器与被控对象间只有顺序作用而无反向联系且控袭坦制单方向进行。若组成系统的元件特性和参数值比较稳定，且外界干扰较小，开环控制能 够保持一定的精度。 缺点：精度通常较低、无自动纠偏能力。

二、闭环控制：闭环控制系统在输出端和输入端之间存在反馈回路，输出量对控制过程有直接影响。

开环2113控制系统是指汽车发动机只能5261根4102据预先设置的数据对喷油量进1653行控版制，而不能根据实际情况变化权进行油量控制的系统，一般有化油器车、不带三元净化器和养传感器的电喷汽油车及普通柴油车。闭环控制系统是指汽车发动机通过氧传感器能根据尾气排放中的氧含量数据对喷油量进行控制的系统，有目前市场上大多数销售的电喷汽油车和部分高档电喷柴油车。较直白的说一般带三元净化器和养传感器的电喷汽油车，都是闭环控段锋制系统电喷车，反之却不一定。

由化油器到开环电喷控制系统至闭环控制系统的设计改进目的是节能与环保，带有三元净化器和养传感器的闭环控制系统电喷车才能达到国际环保验车标准。目前汽车制造商已停止了开环控制系统车辆的生产，北京、上海等许多城市也已不允许开环控制系统车辆上路，因其燃油的不完全燃烧会造成大气的污染。从生产成本而论，闭环控制系统车辆造价要比开环控制系统车辆高出5%以上握禅晌。

循环神经网络

花书中关于RNN的内容记录于 。

在前馈神经网络中，信息的传递是单向的，这种限制虽然使得网络变得更容易学习，但在一定程度上也减弱了神经网络模型的能力。在生物神经网络中，神经元之间的连接关系要复杂的多。 前馈神经网络可以看作是一个复杂的函数，每次输入都是独立的，即网络的输出只依赖于当前的输入。但是在很多现实任务中，网络的输入不仅和当前时刻的输入相关，也和其过去一段时间的输出相关 。因此，前馈网络难以处理时序数据，比如视频、语音、文本等。时序数据的长度一般是不固定的，而前馈神经网络要求输入和输出的维数都是固定的，不能任意改变。因此，当处理这一类和时序相关的问题时，就需要一种能力更强的模型。

循环神经网络（Recurrent Neural Network，RNN）是一类具有短期记忆能力的神经网络。在循环神经网络中，神经元不但可以接受其它神经元的信息，也可以接受自身的信息，形成具有环路的网络结构。 和前馈神经网络相比，循环神经网络更加符合生物神经网络的结构。循环神经网络已经被广泛应用在语音识别、语言模型以及自然语言生成等任务上。循环神经网络的参数学习可以通过 随时间反向传播算法 来学习。

为了处理这些时序数据并利用其历史信息，我们需要让网络具有短期记忆能力。而前馈网络是一个静态网络，不具备这种记忆能力。

一种简单的利用历史信息的方法是建立一个额外的延时单元，用来存储网络的历史信息（可以包括输入、输出、隐状态等）。比较有代表性的模型是延时神经网络。

延时神经网络是在前馈网络中的非输出层都添加一个延时器，记录最近几次神经元的输出。在第 个时刻，第 层神经元和第 层神经元的最近 次输出相关，即：

延时神经网络在时间维度上共享权值，以降低参数数量。因此对于序列输入来讲，延时神经网络就相当于卷积神经网络 。

自回归模型（Autoregressive Model，AR） 是统计学上常用的一类时间序列模型，用一个变量 的历史信息来预测自己：

其中 为超参数， 为参数， 为第 个时刻的噪声，方差 和时间无关。

有外部输入的非线性自回归模型（Nonlinear Autoregressive with ExogenousInputs Model，NARX） 是自回归模型的扩展，在每个时刻 都有一个外部输入 ，产生一个输出 。NARX通过一个延时器记录最近几次的外部输入和输出，第 个时刻的输出 为：

其中 表示非线性函数，可以是一个前馈网络， 和 为超参芹察让数。

循环神经网络通过使用带自反馈的神经元，能够处理任意长度的时序数据。

给定一个输入序列 ，循环神经网络通过下面

公式更新带反馈边的隐藏层的活性值 ：

其中 ， 为一个非线性函数，也可以是一个前馈网络。

从数学上讲，上式可以看成一个动力系统。动力系统（Dynamical System）是一个数学上的概念，指 系统状态按照一定的规律随时间变化的系统 。具体地讲，动力系统是使用一个函数来描述一个给定空间（如某个物理系统的状态空间）中所有点随时间的变化情况。因此， 隐藏层的活性值 在很多文献上也称为状态（State）或隐状态（Hidden States） 。理论上，循环神经网络可以近似任意的非线性动力系统。

简单循环网络（Simple Recurrent Network，SRN）是一个非常简单的循环神经网络没逗，只有一个隐藏层的神经网络。

在一个两层的前馈神经网络中，连接存在相邻的层与层之间，隐藏层的节点之间是无连接的。而 简单循环网络增加了从隐藏层到隐藏层的反馈连接 。

假设在时刻 时，网络的输入为 ，隐藏层状态（即隐藏层神经元活性值） 不仅和当前时刻嫌局的输入 相关，也和上一个时刻的隐藏层状态 相关：

其中 为隐藏层的净输入， 是非线性激活函数，通常为Logistic函数或Tanh函数， 为状态-状态权重矩阵， 为状态-输入权重矩阵， 为偏置。上面两式也经常直接写为：

如果我们把每个时刻的状态都看作是前馈神经网络的一层的话，循环神经网络可以看作是在时间维度上权值共享的神经网络 。下图给出了按时间展开的循环神经网络。

由于循环神经网络具有短期记忆能力，相当于存储装置，因此其计算能力十分强大。 前馈神经网络可以模拟任何连续函数，而循环神经网络可以模拟任何程序。

定义一个完全连接的循环神经网络，其输入为 ，输出为 ：

其中 为隐状态， 为非线性激活函数， 和 为网络参数。

这样一个完全连接的循环神经网络可以近似解决所有的可计算问题 。

循环神经网络可以应用到很多不同类型的机器学习任务。根据这些任务的特点可以分为以下几种模式： 序列到类别模式、同步的序列到序列模式、异步的序列到序列模式 。

序列到类别模式主要用于序列数据的分类问题：输入为序列，输出为类别。比如在文本分类中，输入数据为单词的序列，输出为该文本的类别。

假设一个样本 为一个长度为 的序列，输出为一个类别 。我们可以将样本 按不同时刻输入到循环神经网络中，并得到不同时刻的隐藏状态 。我们可以将 看作整个序列的最终表示（或特征），并输入给分类器 进行分类：

其中 可以是简单的线性分类器（比如Logistic 回归）或复杂的分类器（比如多层前馈神经网络）

除了将最后时刻的状态作为序列表示之外，我们还可以对整个序列的所有状态进行平均，并用这个平均状态来作为整个序列的表示：

同步的序列到序列模式 主要用于序列标注（Sequence Labeling）任务，即每一时刻都有输入和输出，输入序列和输出序列的长度相同 。比如词性标注（Partof-Speech Tagging）中，每一个单词都需要标注其对应的词性标签。

输入为序列 ，输出为序列 。样本 按不同时刻输入到循环神经网络中，并得到不同时刻的隐状态 。每个时刻的隐状态 代表当前和历史的信息，并输入给分类器 得到当前时刻的标签 。

异步的序列到序列模式也称为 编码器-解码器（Encoder-Decoder）模型，即输入序列和输出序列不需要有严格的对应关系，也不需要保持相同的长度。 比如在机器翻译中，输入为源语言的单词序列，输出为目标语言的单词序列。

在异步的序列到序列模式中，输入为长度为 的序列 ，输出为长度为 的序列 。经常通过 先编码后解码 的方式来实现。先将样本 按不同时刻输入到一个循环神经网络（编码器）中，并得到其编码 。然后再使用另一个循环神经网络（解码器）中，得到输出序列 。为了建立输出序列之间的依赖关系，在解码器中通常使用非线性的自回归模型。

其中 分别为用作编码器和解码器的循环神经网络， 为分类器， 为预测输出 的向量表示。

循环神经网络的参数可以通过梯度下降方法来进行学习。给定一个训练样本 ，其中 为长度是 的输入序列， 是长度为 的标签序列。即在每个时刻 ，都有一个监督信息 ，我们定义时刻 的损失函数为：

其中 为第 时刻的输出， 为可微分的损失函数，比如交叉熵。那么整个序列上损失函数为：

整个序列的损失函数 关于参数 的梯度为：

即每个时刻损失 对参数 的偏导数之和。

循环神经网络中存在一个递归调用的函数 ，因此其计算参数梯度的方式和前馈神经网络不太相同。在循环神经网络中主要有两种计算梯度的方式： 随时间反向传播（BPTT）和实时循环学习（RTRL）算法。

随时间反向传播（Backpropagation Through Time，BPTT） 算法的主要思想是通过类似前馈神经网络的错误反向传播算法来进行计算梯度。

BPTT算法将循环神经网络看作是一个展开的多层前馈网络，其中“每一层”对应循环网络中的“每个时刻”。在“展开”的前馈网络中，所有层的参数是共享的，因此参数的真实梯度是将所有“展开层”的参数梯度之和 。

因为参数 和隐藏层在每个时刻 的净输入 有关，因此第 时刻的损失函数 关于参数 的梯度为：

其中 表示“直接”偏导数，即公式 中保持 不变，对 求偏导数，得到：

其中 为第 时刻隐状态的第 维； 除了第 个值为 外，其余都为 的行向量。

定义误差项 为第 时刻的损失对第 时刻隐藏神经层的净输入 的导数，则：

从而：

写成矩阵形式为：

由此得到整个序列的损失函数 关于参数 的梯度：

同理可得， 关于权重 和偏置 的梯度为：

在BPTT算法中，参数的梯度需要在一个完整的“前向”计算和“反向”计算后才能得到并进行参数更新。如下图所示。

与反向传播的BPTT算法不同的是，实时循环学习（Real-Time Recurrent Learning）是通过前向传播的方式来计算梯度。

假设循环神经网络中第 时刻的状态 为：

其关于参数 的偏导数为：

RTRL算法从第1 个时刻开始，除了计算循环神经网络的隐状态之外，还依次前向计算偏导数 。

两种学习算法比较：

RTRL算法和BPTT算法都是基于梯度下降的算法，分别通过前向模式和反向模式应用链式法则来计算梯度。 在循环神经网络中，一般网络输出维度远低于输入维度，因此BPTT算法的计算量会更小，但BPTT算法需要保存所有时刻的中间梯度，空间复杂度较高。RTRL算法不需要梯度回传，因此非常适合于需要在线学习或无限序列的任务中 。

循环神经网络在学习过程中的主要问题是由于 梯度消失或爆炸问题 ，很难建模长时间间隔（Long Range）的状态之间的依赖关系。

在BPTT算法中，我们有：

如果定义 ，则：

若 ，当 时， ，会造成系统不稳定，称为梯度爆炸问题；相反，若 ，当 时， ，会出现和深度前馈神经网络类似的梯度消失问题。

虽然简单循环网络理论上可以建立长时间间隔的状态之间的依赖关系，但是由于梯度爆炸或消失问题，实际上只能学习到短期的依赖关系。这样，如果t时刻的输出 依赖于 时刻的输入 ，当间隔 比较大时，简单神经网络很难建模这种长距离的依赖关系，称为 长程依赖问题（Long-Term dependencies Problem） 。

一般而言，循环网络的梯度爆炸问题比较容易解决，一般 通过权重衰减或梯度截断来避免。 权重衰减是通过给参数增加 或 范数的正则化项来限制参数的取值范围，从而使得 。梯度截断是另一种有效的启发式方法，当梯度的模大于一定阈值时，就将它截断成为一个较小的数。

梯度消失是循环网络的主要问题。除了使用一些优化技巧外，更有效的方式就是改变模型，比如让 ，同时使用 ，即：

其中 是一个非线性函数， 为参数。

上式中， 和 之间为线性依赖关系，且权重系数为1，这样就不存在梯度爆炸或消失问题。但是，这种改变也丢失了神经元在反馈边上的非线性激活的性质，因此也降低了模型的表示能力。

为了避免这个缺点，我们可以采用一种更加有效的改进策略：

这样 和 之间为既有线性关系，也有非线性关系，并且可以缓解梯度消失问题。但这种改进依然存在两个问题：

为了解决这两个问题，可以通过引入 门控机制 来进一步改进模型。

为了改善循环神经网络的长程依赖问题，一种非常好的解决方案是引入门控机制来控制信息的累积速度，包括 有选择地加入新的信息，并有选择地遗忘之前累积的信息 。这一类网络可以称为基于门控的循环神经网络（Gated RNN）。本节中，主要介绍两种基于门控的循环神经网络： 长短期记忆网络和门控循环单元网络。

长短期记忆（Long Short-Term Memory，LSTM）网络 是循环神经网络的一个变体，可以有效地解决简单循环神经网络的梯度爆炸或消失问题。

在 基础上，LSTM网络主要改进在以下两个方面：

其中 和 三个门（gate）来控制信息传递的路径； 为向量元素乘积； 为上一时刻的记忆单元； 是通过非线性函数得到的候选状态：

在每个时刻 ，LSTM网络的内部状态 记录了到当前时刻为止的历史信息。

在数字电路中，门（Gate）为一个二值变量{0, 1}，0代表关闭状态，不许任何信息通过；1代表开放状态，允许所有信息通过。LSTM网络中的“门”是一种“软”门，取值在(0, 1) 之间，表示 以一定的比例运行信息通过 。LSTM网络中三个门的作用为：

（1）遗忘门 控制上一个时刻的内部状态 需要遗忘多少信息。

（2）输入门 控制当前时刻的候选状态 有多少信息需要保存。

（3）输出门

关于narx神经网络和narx神经网络预测代码的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。