MATLAB神经网络入门：实战设计与应用

需积分: 9 89 浏览量更新于2024-07-19 收藏 2.05MB PDF 举报

《使用MATLAB构建神经网络：Marvin L.的全面指南》是一本专为熟悉MATLAB编程的初学者准备的神经网络入门教材。该书循序渐进地讲解了神经网络的基础概念，特别强调了如何利用MATLAB这一强大的工具进行实际操作。作者Marvin L.引导读者从机器学习基础知识入手，逐步过渡到神经网络设计、配置、权重和偏置初始化、训练以及网络的应用。书中核心内容包括神经网络设计过程中的四个关键步骤：数据收集、创建网络、配置网络和使用网络。作者特别关注了第2步（创建网络）、第3步（配置网络）、第5步（训练网络）和第7步（使用网络），因为这些步骤涉及到了神经网络的基本原理。第1步（数据收集）虽然重要，但通常在神经网络工具箱软件框架之外讨论，会在后续章节“多层网络和反向传播训练”中展开。神经网络设计过程中，MATLAB的神经网络工具箱通过网络对象来存储网络的所有定义信息。本书详细介绍了神经网络的基本组成部分，如输入层、隐藏层和输出层，以及它们如何在网络对象中被创建和组织。此外，还包括了如何根据问题类型调整网络结构，即配置网络，使之适应所面临的实际问题。在创建好网络后，下一步是对其进行配置，这涉及到调整网络参数以适应训练数据，如设定学习率、激活函数等。接着，第5步训练网络则涉及使用反向传播算法来优化权重和偏置，以减小预测误差。最后，完成训练的网络可以用于处理新数据，这就是第7步网络的使用。通过阅读本书，读者不仅能掌握神经网络的基础知识，还能了解如何在MATLAB环境中高效地实现和应用这些技术，解决实际中的大数据分析、智能机器人和其他复杂问题。书中对机器学习的深入探讨和智能数据分析方面的实践，有助于读者理解这个领域更为复杂的方面，并在实际项目中展现出更高的智能水平。《使用MATLAB构建神经网络》是一本实用且深入的教程，对于希望在这个领域进一步发展的学习者来说，是一份不可或缺的参考资料。

delays, they were assumed to be 0. For this case the output is simply 1 times the input, because the

weight that multiplies the current input is 1.

In certain special cases, you might want to simulate the network response to several different sequences

at the same time. In this case, you would want to present the network with a concurrent set of sequences.

For example, suppose you wanted to present the following two sequences to the network:

p ppp

[]

1 111

[]

=[]() ,() , () ,()1 1 22 33 4 4=[]

pp()14 23=[],,() , ()32 4 1

22 22

[]

The input Pshould be a cell array, where each element of the array contains the two elements of the two

sequences that occur at the same time:

P = {[1 4] [2 3] [3 2] [4 1]};

You can now simulate the network:

A = net(P);

The resulting network output would be

A = {[1 4] [4 11] [7 8] [10 5]}

As you can see, the first column of each matrix makes up the output sequence produced by the first input

sequence, which was the one used in an earlier example. The second column of each matrix makes up

the output sequence produced by the second input sequence. There is no interaction between the two

concurrent sequences. It is as if they were each applied to separate networks running in parallel.

The following diagram shows the general format for the network input P when there are Q concurrent

sequences of TS time steps. It covers all cases where there is a single input vector. Each element of the

cell array is a matrix of concurrent vectors that correspond to the same point in time for each sequence.

If there are multiple input vectors, there will be multiple rows of matrices in the cell array.

In this section, you apply sequential and concurrent inputs to dynamic networks. In “Simulation with

Concurrent Inputs in a Static Network” on page 1-24, you applied concurrent inputs to static networks. It

is also possible to apply sequential inputs to static networks. It does not change the simulated response

of the network, but it can affect the way in which the network is trained. This will become clear in

“Training Styles (Adapt and Train)” on page 1-30.

Training Styles (Adapt and Train)

This section describes two different styles of training. In incremental training the weights and biases of

the network are updated each time an input is presented to the network. In batch training the weights and

biases are only updated after all the inputs are presented. The batch training methods are generally more

efficient in the MATLAB environment, and they are emphasized in the Neural Network Toolbox

software, but there some applications where incremental training can be useful, so that paradigm is

implemented as well.

Incremental Training with adapt

Incremental training can be applied to both static and dynamic networks, although it is more commonly

used with dynamic networks, such as adaptive filters. This section illustrates how incremental training is

performed on both static and dynamic networks.

Incremental Training of Static Networks

Consider again the static network used for the first example. You want to train it incrementally, so that

the weights and biases are updated after each input is presented. In this case you use the function adapt,

and the inputs and targets are presented as sequences.

Suppose you want to train the network to create the linear function:

tp p

Then for the previous inputs,

= ?1?

= ?

2? = ?2?

= ?

?1??2?

,,,

?3?

p ppp

12 3 4

? ?

? ? ? ? ? the targets would be

t ttt=[],,,

12 3 4

[]

For incremental training, you present the inputs and targets as sequences:

P = {[1;2] [2;1] [2;3] [3;1]}; T={4 577};

First, set up the network with zero initial weights and biases. Also, set the initial learning rate to zero to

show the effect of incremental training.

net = linearlayer(0,0); net = configure(net,P,T); net.IW{1,1} = [0 0];

net.b{1} = 0;

Recall from “Simulation with Concurrent Inputs in a Static Network” on page 1-24 that, for a static

network, the simulation of the network produces the same outputs whether the inputs are presented as a

matrix of concurrent vectors or as a cell array of sequential vectors. However, this is not true when

training the network. When you use the adaptfunction, if the inputs are presented as a cell array of

sequential vectors, then the weights are updated as each input is presented (incremental mode). As

shown in the next section, if the inputs are presented as a matrix of concurrent vectors, then the weights

are updated only after all inputs are presented (batch mode).

You are now ready to train the network incrementally.

[net,a,e,pf] = adapt(net,P,T);

The network outputs remain zero, because the learning rate is zero, and the weights are not updated. The

errors are equal to the targets:

a = [0] [0] [0] [0] e = [4] [5] [7] [7]

If you now set the learning rate to 0.1 you can see how the network is adjusted as each input is

presented:

net.inputWeights{1,1}.learnParam.lr = 0.1; net.biases{1,1}.learnParam.lr = 0.1; [net,a,e,pf] =

adapt(net,P,T);

a = [0] [2] [6] [5.8]

e = [4] [3] [1] [1.2]

The first output is the same as it was with zero learning rate, because no update is made until the first

input is presented. The second output is different, because the weights have been updated. The weights

continue to be modified as each error is computed. If the network is capable and the learning rate is set

correctly, the error is eventually driven to zero.

Incremental Training with Dynamic Networks

You can also train dynamic networks incrementally. In fact, this would be the most common situation.

To train the network incrementally, present the inputs and targets as elements of cell arrays. Here are the

initial input Piand the inputs Pand targets Tas elements of cell arrays.

Pi = {1};

P={2 3 4}; T={3 5 7};

Take the linear network with one delay at the input, as used in a previous example. Initialize the weights

to zero and set the learning rate to 0.1.

net = linearlayer([0 1],0.1); net = configure(net,P,T); net.IW{1,1} = [0 0];

net.biasConnect = 0;

You want to train the network to create the current output by summing the current and the previous

inputs. This is the same input sequence you used in the previous example with the exception that you

assign the first term in the sequence as the initial condition for the delay. You can now sequentially train

the network using adapt.

[net,a,e,pf] = adapt(net,P,T,Pi); a = [0] [2.4] [7.98]

e = [3] [2.6] [-0.98]

The first output is zero, because the weights have not yet been updated. The weights change at each

subsequent time step.

Batch Training

Batch training,in which weights and biases are only updated after all the inputs and targets are presented,

can be applied to both static and dynamic networks. Bothtypes of networks are discussed in this section.

Batch Training with Static Networks

Batch training can be done using either adaptor train, although trainis generally the best option, because

it typically has access to more efficient training algorithms. Incremental training is usually done with

adapt; batch training is usually done with train.

For batch training of a static network with adapt, the input vectors must be placed in one matrix of

concurrent vectors.

P= [1 22 3; 21 31]; T=[4 577];

Begin with the static network used in previous examples. The learning rate is set to 0.01.

net = linearlayer(0,0.01); net = configure(net,P,T); net.IW{1,1} = [0 0];

net.b{1} = 0;

When you call adapt, it invokes trains(the default adaption function for the linear network) and

learnwh(the default learning function for the weights and biases). trainsuses Widrow-Hoff learning.

[net,a,e,pf] = adapt(net,P,T); a=0 00 0

e=4 57 7

Note that the outputs of the network are all zero, because the weights are not updated until all the

training set has been presented. If you display the weights, you find

net.IW{1,1}

ans = 0.4900 0.4100

net.b{1}

ans =

0.2300

This is different from the result after one pass of adaptwith incremental updating.

Now perform the same batch training using train. Because the Widrow-Hoff rule can be used in

incremental or batch mode, it can be invoked by adaptor train. (There are several algorithms that can

only be used in batch mode (e.g., Levenberg-Marquardt), so these algorithms can only be invoked by

train.)

For this case, the input vectors can be in a matrix of concurrent vectors or in a cell array of sequential

vectors. Because the network is static and because trainalways operates in batch mode, trainconverts any

cell array of sequential vectors to a matrix of concurrent vectors. Concurrent mode operation is used

whenever possible because it has a more efficient implementation in MATLAB code:

P= [1 22 3; 21 31]; T=[4 577];

The network is set up in the same way.

net = linearlayer(0,0.01); net = configure(net,P,T); net.IW{1,1} = [0 0];

net.b{1} = 0;

Now you are ready to train the network. Train it for only one epoch, because you used only one pass of

adapt. The default training function for the linear network is trainb, and the default learning function for

the weights and biases is learnwh, so you should get the same results obtained using adaptin the previous

example, where the default adaption function was trains.

net.trainParam.epochs = 1; net = train(net,P,T);

If you display the weights after one epoch of training, you find

net.IW{1,1}

ans = 0.4900 0.4100 net.b{1}

ans =

0.2300

This is the same result as the batch mode training in adapt. With static networks, the adaptfunction can

implement incremental or batch training, depending on the format of the input data. If the data is

presented as a matrix of concurrent vectors, batch training occurs. If the data is presented as a sequence,

incremental training occurs. This is not true for train,which always performs batch training, regardless of

the format of the input.

Batch Training with Dynamic Networks

Training static networks is relatively straightforward. If you use train the network is trained in batch

mode and the inputs are converted to concurrent vectors (columns of a matrix), even if they are

originally passed as a sequence (elements of a cell array). If you use adapt, the format of the input

determines the method of training. If the inputs are passed as a sequence, then the network is trained in

incremental mode. If the inputs are passed as concurrent vectors, then batch mode training is used.

With dynamic networks, batch mode training is typically done with train only, especially if only one

training sequence exists. To illustrate this, consider again the linear network with a delay. Use a learning

rate of 0.02 for the training. (When using a gradient descent algorithm, you typically use a smaller

learning rate for batch mode training than incremental training, because all the individual gradients are

summed before determining the step change to the weights.)

net = linearlayer([0 1],0.02); net.inputs{1}.size = 1;

net.layers{1}.dimensions = 1; net.IW{1,1} = [0 0];

net.biasConnect = 0;

net.trainParam.epochs = 1; Pi = {1};

P={2 3 4};

T={3 5 6};

Youwanttotrainthenetworkwiththesamesequenceusedforthe incremental training earlier, but this time you

want to update the weights only after all the inputs are applied (batch mode). The network is simulated

in sequential mode, because the input is a sequence, but the weights are updated in batch mode.

net = train(net,P,T,Pi);

The weights after one epoch of training are

剩余230页未读，继续阅读

ghy2014

粉丝: 0
资源: 26

MATLAB神经网络入门：实战设计与应用

neuro-networks-MATLAB：在MATLAB中实现人工神经网络

MATLAB Deep Learning: With Machine Learning, Neural Networks and AI

Neural.Networks.with.R.epub

Building Neural Networks with MATLAB 使用 MATLAB 构建神经网络.pdf

模型压缩论文解读1：（MobileNets解读）Efficient Convolutional Neural Networks for Mobile ...-附件资源

Pattern Recognition and Neural Networks (B.D.Ripley).pdf

神经网络Artificial Neural Networks（资料完整）.rar

imagenet-classification-with-deep-convolutional-neural-networks原版和翻译..rar

《TF-GNN：Graph Neural Networks》附录《A.2.2 Creating GraphTensors》例程

C++.Neural.Networks.and.Fuzzy.Logic

最新资源