55、定义浅层神经网络架构和算法(matlab)

1、定义浅层神经网络架构和算法简介

浅层神经网络是一种简单的神经网络结构，通常只包含一个输入层、一个或多个隐藏层和一个输出层。在训练时，通过反向传播算法来不断调整神经元之间的连接权重，从而实现对输入数据的分类、回归等任务。

一个简单的浅层神经网络可以使用MATLAB实现，可以使用MATLAB中的神经网络工具箱来构建神经网络模型，并用反向传播算法来训练模型。下面是一个简单的浅层神经网络的MATLAB代码示例：

% 创建一个2-3-1的浅层神经网络 
net = feedforwardnet([3]); % 设置训练参数 
net.trainParam.epochs = 1000; % 训练次数 
net.trainParam.lr = 0.01; % 学习率

 % 生成训练数据 
X = rand(2, 100); % 输入数据 
Y = X(1, :) + 2*X(2, :); % 输出数据 % 开始训练神经网络 
net = train(net, X, Y); % 使用训练后的神经网络进行预测 
output = net(X); % 显示预测结果 disp(output);

在这个示例中，我们创建了一个2-3-1的神经网络结构，其中输入层有两个神经元，隐藏层有3个神经元，输出层有一个神经元。然后我们使用随机生成的训练数据来训练神经网络，并使用训练后的神经网络进行预测。

通过简单的神经网络模型和MATLAB代码，我们可以很容易地实现浅层神经网络的训练和预测任务。

2、创建神经网络对象

1）说明

使用网络创建函数：使用命令 feedforwardnet 创建一个简单的两层前馈网络

简要说明了网络对象，它用于存储定义神经网络的所有信息。

网络对象的关键子对象包括 inputs、layers、outputs、biases、inputWeights 和 layerWeights。

2）创建网络代码

net = feedforwardnet

net =

    Neural Network
 
              name: 'Feed-Forward Neural Network'
          userdata: (your custom info)
 
    dimensions:
 
         numInputs: 1
         numLayers: 2
        numOutputs: 1
    numInputDelays: 0
    numLayerDelays: 0
 numFeedbackDelays: 0
 numWeightElements: 10
        sampleTime: 1
 
    connections:
 
       biasConnect: [1; 1]
      inputConnect: [1; 0]
      layerConnect: [0 0; 1 0]
     outputConnect: [0 1]
 
    subobjects:
 
             input: Equivalent to inputs{1}
            output: Equivalent to outputs{2}
 
            inputs: {1x1 cell array of 1 input}
            layers: {2x1 cell array of 2 layers}
           outputs: {1x2 cell array of 1 output}
            biases: {2x1 cell array of 2 biases}
      inputWeights: {2x1 cell array of 1 weight}
      layerWeights: {2x2 cell array of 1 weight}
 
    functions:
 
          adaptFcn: 'adaptwb'
        adaptParam: (none)
          derivFcn: 'defaultderiv'
         divideFcn: 'dividerand'
       divideParam: .trainRatio, .valRatio, .testRatio
        divideMode: 'sample'
           initFcn: 'initlay'
        performFcn: 'mse'
      performParam: .regularization, .normalization
          plotFcns: {'plotperform', plottrainstate, ploterrhist,
                    plotregression}
        plotParams: {1x4 cell array of 4 params}
          trainFcn: 'trainlm'
        trainParam: .showWindow, .showCommandLine, .show, .epochs,
                    .time, .goal, .min_grad, .max_fail, .mu, .mu_dec,
                    .mu_inc, .mu_max
 
    weight and bias values:
 
                IW: {2x1 cell} containing 1 input weight matrix
                LW: {2x2 cell} containing 1 layer weight matrix
                 b: {2x1 cell} containing 2 bias vectors
 
    methods:
 
             adapt: Learn while in continuous use
         configure: Configure inputs & outputs
            gensim: Generate Simulink model
              init: Initialize weights & biases
           perform: Calculate performance
               sim: Evaluate network outputs given inputs
             train: Train network with examples
              view: View diagram
       unconfigure: Unconfigure inputs & outputs
 
    evaluate:       outputs = net(inputs)

3） 查看第一层的 layers 子对象

说明： 一个层中神经元的数量由其 size 属性给出

该层有 10 个神经元，这是 feedforwardnet 命令的默认大小。net 输入函数是 netsum（求和），传递函数是 tansig。

代码

net.layers{1}

ans = 

    Neural Network Layer
 
              name: 'Hidden'
        dimensions: 10
       distanceFcn: (none)
     distanceParam: (none)
         distances: []
           initFcn: 'initnw'
       netInputFcn: 'netsum'
     netInputParam: (none)
         positions: []
             range: [10x2 double]
              size: 10
       topologyFcn: (none)
       transferFcn: 'tansig'
     transferParam: (none)
          userdata: (your custom info)

4）查看 layerWeights 子对象以了解层 1 和层 2 之间的权重

代码

net.layerWeights{2,1}

ans = 

    Neural Network Weight

            delays: 0
           initFcn: (none)
      initSettings: .range
             learn: true
          learnFcn: 'learngdm'
        learnParam: .lr, .mc
              size: [0 10]
         weightFcn: 'dotprod'
       weightParam: (none)
          userdata: (your custom info)

3、配置浅层神经网络输入和输出

1）说明

在创建神经网络后，必须对其进行配置。配置步骤包括检查输入和目标数据，设置网络的输入和输出大小以匹配数据，以及选择能够实现最佳网络性能的输入和输出处理设置。配置步骤通常在调用训练函数时自动完成。但也可以使用配置函数手动完成配置步骤之前创建的网络配置为逼近一个正弦函数

2）configure 函数可以设置网络输入和输出大小以匹配数据。

代码

p = -2:.1:2;
t = sin(pi*p/2);
net1 = configure(net,p,t);

3） 再次查看层 1 和层 2 之间的权重，可以看到权重的维度是 1×20。

代码

net1.layerWeights{2,1}

ans = 

    Neural Network Weight

            delays: 0
           initFcn: (none)
      initSettings: .range
             learn: true
          learnFcn: 'learngdm'
        learnParam: .lr, .mc
              size: [1 10]
         weightFcn: 'dotprod'
       weightParam: (none)
          userdata: (your custom info)

4、理解浅层网络数据结构

1）说明

输入数据结构的格式影响网络模拟，它从静态网络开始，然后继续到动态网络。

有两种基本类型的输入向量:并发发生的(在同一时间，或没有特定的时间顺序)和按时间顺序发生的输入向量。对于并发向量，顺序并不重要，如果有多个网络并行运行，您可以为每个网络提供一个输入向量。对于顺序向量，向量出现的顺序很重要。

2）静态网络中并发输入的仿真

**说明：**模拟网络最简单的情况是，要模拟的网络是静态的(没有反馈或延迟)。在这种情况下，不需要关心输入向量是否以特定的时间序列出现，因此可以将输入视为并发的。此外，如果假设网络只有一个输入向量，问题会变得更加简单。

设置一个线性前馈网络代码

net = linearlayer;
net.inputs{1}.size = 2;
net.layers{1}.dimensions = 1;

权重矩阵和偏置设为W = [1 2]， b =[0]代码

net.IW{1,1} = [1 2];
net.b{1} = 0;

假设网络仿真数据集由Q = 4个并发向量组成代码

P = [1 2 2 3; 2 1 3 1];

模拟网络代码

**说明：**将单个并发向量矩阵提供给网络，网络产生单个并发向量矩阵作为输出。如果有四个网络并行运行，每个网络接收一个输入向量并产生一个输出，结果将是相同的。输入向量的顺序并不重要，因为它们不相互作用。

A = net(P)
A =

     5     4     8     5

5、动态网络中时序输入的仿真

1）说明

当网络包含延迟时，网络的输入通常是按一定时间顺序出现的一系列输入向量

2）创建该网络代码

net = linearlayer([0 1]);
net.inputs{1}.size = 1;
net.layers{1}.dimensions = 1;
net.biasConnect = 0;

3）赋权矩阵代码

net.IW{1,1} = [1 2];

4）输入序列代码

P = {1 2 3 4};

5）模拟网络代码

**说明：**输入一个包含输入序列的单元格数组，网络产生一个包含输出序列的单元格数组

A = net(P)

6、动态网络中并发输入的仿真

**说明：**将相同的输入作为一组并发输入而不是输入序列应用，将获得完全不同的响应。就好像每个输入都被并发地应用到一个单独的并行网络中。对于前面的示例，在动态网络中使用顺序输入进行仿真

1）代码

P = [1 2 3 4];

2）模拟网络代码

A = net(P)
A =
     1     2     3     4

3）网络提供一组并发序列代码

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

4）模拟网络代码

A = net(P)
A = {[1 4] [4 11] [7 8] [10 5]}

7、总结

浅层神经网络是一种简单的神经网络结构，通常只包含一个输入层、一个或多个隐藏层和一个输出层。在MATLAB中，可以使用神经网络工具箱来构建和训练浅层神经网络模型。

在MATLAB中，可以使用以下步骤来构建和训练浅层神经网络模型：

1. **创建神经网络对象：**使用feedforwardnet函数创建一个浅层神经网络对象，指定每个隐藏层中神经元的数量。

2. **设置训练参数：**通过修改神经网络对象的trainParam属性设置训练参数，如训练次数、学习率等。

3. **准备训练数据：**准备输入数据和对应的输出数据，用于训练神经网络模型。

4. **训练神经网络：**调用train函数，传入训练数据进行神经网络的训练，调整连接权重。

5. **使用神经网络进行预测：**训练完成后，可以使用训练好的神经网络对象对新的输入数据进行预测。

通过以上步骤，我们可以在MATLAB中构建和训练简单的浅层神经网络模型，用于解决分类、回归等问题。神经网络工具箱提供了丰富的函数和工具，使得构建和训练神经网络变得简单而有效。

8、源代码

代码

%% 定义浅层神经网络架构和算法
%% 自定义神经网络
%% 1）创建神经网络对象
%使用网络创建函数//使用命令 feedforwardnet 创建一个简单的两层前馈网络
%简要说明了网络对象，它用于存储定义神经网络的所有信息。
%网络对象的关键子对象包括 inputs、layers、outputs、biases、inputWeights 和 layerWeights。

net = feedforwardnet
%查看第一层的 layers 子对象
%一个层中神经元的数量由其 size 属性给出
%该层有 10 个神经元，这是 feedforwardnet 命令的默认大小。net 输入函数是 netsum（求和），传递函数是 tansig。例如，如果您要将传递函数更改为 logsig，可以执行以下命令：
%net.layers{1}.transferFcn = 'logsig';
net.layers{1}
%查看 layerWeights 子对象以了解层 1 和层 2 之间的权重
net.layerWeights{2,1}

%% 2） 配置浅层神经网络输入和输出
%在创建神经网络后，必须对其进行配置。配置步骤包括检查输入和目标数据，设置网络的输入和输出大小以匹配数据，以及选择能够实现最佳网络性能的输入和输出处理设置。配置步骤通常在调用训练函数时自动完成。但也可以使用配置函数手动完成配置步骤
%之前创建的网络配置为逼近一个正弦函数
%configure 函数可以设置网络输入和输出大小以匹配数据。
p = -2:.1:2;
t = sin(pi*p/2);
net1 = configure(net,p,t);
%再次查看层 1 和层 2 之间的权重，可以看到权重的维度是 1×20。
net1.layerWeights{2,1}
%输入设置
net1.inputs{1}

%% 3）理解浅层网络数据结构
%输入数据结构的格式影响网络模拟，它从静态网络开始，然后继续到动态网络。
%有两种基本类型的输入向量:并发发生的(在同一时间，或没有特定的时间顺序)和按时间顺序发生的输入向量。对于并发向量，顺序并不重要，如果有多个网络并行运行，您可以为每个网络提供一个输入向量。对于顺序向量，向量出现的顺序很重要。
%%   静态网络中并发输入的仿真
%模拟网络最简单的情况是，要模拟的网络是静态的(没有反馈或延迟)。在这种情况下，不需要关心输入向量是否以特定的时间序列出现，因此可以将输入视为并发的。此外，如果假设网络只有一个输入向量，问题会变得更加简单。
%设置一个线性前馈网络
net = linearlayer;
net.inputs{1}.size = 2;
net.layers{1}.dimensions = 1;
%权重矩阵和偏置设为W = [1 2]， b =[0]。
net.IW{1,1} = [1 2];
net.b{1} = 0;
%假设网络仿真数据集由Q = 4个并发向量组成
P = [1 2 2 3; 2 1 3 1];
%模拟网络
%将单个并发向量矩阵提供给网络，网络产生单个并发向量矩阵作为输出。如果有四个网络并行运行，每个网络接收一个输入向量并产生一个输出，结果将是相同的。输入向量的顺序并不重要，因为它们不相互作用。
A = net(P)
%%  动态网络中时序输入的仿真
%当网络包含延迟时，网络的输入通常是按一定时间顺序出现的一系列输入向量
%创建该网络
net = linearlayer([0 1]);
net.inputs{1}.size = 1;
net.layers{1}.dimensions = 1;
net.biasConnect = 0;
%赋权矩阵
net.IW{1,1} = [1 2];
%输入序列
P = {1 2 3 4};
%模拟网络
%输入一个包含输入序列的单元格数组，网络产生一个包含输出序列的单元格数组
A = net(P)
%% 动态网络中并发输入的仿真
%将相同的输入作为一组并发输入而不是输入序列应用，将获得完全不同的响应。就好像每个输入都被并发地应用到一个单独的并行网络中。对于前面的示例，在动态网络中使用顺序输入进行仿真
P = [1 2 3 4];
%模拟网络
A = net(P)
%网络提供一组并发序列
P = {[1 4] [2 3] [3 2] [4 1]};
%模拟网络
A = net(P)