matlab-神经网络-自定义多层感知器解决异或(1)

>> net=network

net =

    Neural Network object:

    architecture:

         numInputs: 0
         numLayers: 0
       biasConnect: []
      inputConnect: []
      layerConnect: []
     outputConnect: []

        numOutputs: 0  (read-only)
    numInputDelays: 0  (read-only)
    numLayerDelays: 0  (read-only)

    subobject structures:

            inputs: {0x1 cell} of inputs
            layers: {0x1 cell} of layers
           outputs: {1x0 cell} containing no outputs
            biases: {0x1 cell} containing no biases
      inputWeights: {0x0 cell} containing no input weights
      layerWeights: {0x0 cell} containing no layer weights

    functions:

          adaptFcn: (none)
         divideFcn: (none)
       gradientFcn: (none)
           initFcn: (none)
        performFcn: (none)
          plotFcns: {}
          trainFcn: (none)

    parameters:

        adaptParam: (none)
       divideParam: (none)
     gradientParam: (none)
         initParam: (none)
      performParam: (none)
        trainParam: (none)

    weight and bias values:

                IW: {0x0 cell} containing no input weight matrices
                LW: {0x0 cell} containing no layer weight matrices
                 b: {0x1 cell} containing no bias vectors

    other:

              name: ''
          userdata: (user information)

 

====

 

net.numInputs

This property defines the number of inputs a network receives. It can be set to 0 or a positive integer.

Clarification.   The number of network inputs and the size of a network input are not the same thing. The number of inputs defines how many sets of vectors the network receives as input. The size of each input (i.e., the number of elements in each input vector) is determined by the input size (net.inputs{i}.size).

Most networks have only one input, whose size is determined by the problem.

Side Effects.   Any change to this property results in a change in the size of the matrix defining connections to layers from inputs, (net.inputConnect) and the size of the cell array of input subobjects (net.inputs).

====

 

>> net.numInputs=1

net =

    Neural Network object:

    architecture:

         numInputs: 1
         numLayers: 0
       biasConnect: []
      inputConnect: []
      layerConnect: []
     outputConnect: []

        numOutputs: 0  (read-only)
    numInputDelays: 0  (read-only)
    numLayerDelays: 0  (read-only)

    subobject structures:

            inputs: {1x1 cell} of inputs
            layers: {0x1 cell} of layers
           outputs: {1x0 cell} containing no outputs
            biases: {0x1 cell} containing no biases
      inputWeights: {0x1 cell} containing no input weights
      layerWeights: {0x0 cell} containing no layer weights

    functions:

          adaptFcn: (none)
         divideFcn: (none)
       gradientFcn: (none)
           initFcn: (none)
        performFcn: (none)
          plotFcns: {}
          trainFcn: (none)

    parameters:

        adaptParam: (none)
       divideParam: (none)
     gradientParam: (none)
         initParam: (none)
      performParam: (none)
        trainParam: (none)

    weight and bias values:

                IW: {0x1 cell} containing no input weight matrices
                LW: {0x0 cell} containing no layer weight matrices
                 b: {0x1 cell} containing no bias vectors

    other:

              name: ''
          userdata: (user information)

=====

 

net.numLayers

This property defines the number of layers a network has. It can be set to 0 or a positive integer.

Side Effects.   Any change to this property changes the size of each of these Boolean matrices that define connections to and from layers:
net.biasConnect
net.inputConnect
net.layerConnect
net.outputConnect

 

and changes the size of each cell array of subobject structures whose size depends on the number of layers:
net.biases
net.inputWeights
net.layerWeights
net.outputs

 

and also changes the size of each of the network's adjustable parameter's properties:
net.IW
net.LW
net.b

=====

>> net.numLayers=2

net =

    Neural Network object:

    architecture:

         numInputs: 1
         numLayers: 2
       biasConnect: [0; 0]
      inputConnect: [0; 0]
      layerConnect: [0 0; 0 0]
     outputConnect: [0 0]

        numOutputs: 0  (read-only)
    numInputDelays: 0  (read-only)
    numLayerDelays: 0  (read-only)

    subobject structures:

            inputs: {1x1 cell} of inputs
            layers: {2x1 cell} of layers
           outputs: {1x2 cell} containing no outputs
            biases: {2x1 cell} containing no biases
      inputWeights: {2x1 cell} containing no input weights
      layerWeights: {2x2 cell} containing no layer weights

    functions:

          adaptFcn: (none)
         divideFcn: (none)
       gradientFcn: (none)
           initFcn: (none)
        performFcn: (none)
          plotFcns: {}
          trainFcn: (none)

    parameters:

        adaptParam: (none)
       divideParam: (none)
     gradientParam: (none)
         initParam: (none)
      performParam: (none)
        trainParam: (none)

    weight and bias values:

                IW: {2x1 cell} containing no input weight matrices
                LW: {2x2 cell} containing no layer weight matrices
                 b: {2x1 cell} containing no bias vectors

    other:

              name: ''
          userdata: (user information)

>>

========

 

net.inputConnect

This property defines which layers have weights coming from inputs.

It can be set to any Nl x Ni matrix of Boolean values, where Nl is the number of network layers (net.numLayers), and Ni is the number of network inputs (net.numInputs). The presence (or absence) of a weight going to the ith layer from the jth input is indicated by a 1 (or 0) at net.inputConnect(i,j).

Side Effects.   Any change to this property alters the presence or absence of structures in the cell array of input weight subobjects (net.inputWeights) and the presence or absence of matrices in the cell array of input weight matrices (net.IW).

========

>> net.inputConnect=[1;0]

net =

    Neural Network object:

    architecture:

         numInputs: 1
         numLayers: 2
       biasConnect: [1; 1]
      inputConnect: [1; 0]
      layerConnect: [0 0; 0 0]
     outputConnect: [0 0]

        numOutputs: 0  (read-only)
    numInputDelays: 0  (read-only)
    numLayerDelays: 0  (read-only)

    subobject structures:

            inputs: {1x1 cell} of inputs
            layers: {2x1 cell} of layers
           outputs: {1x2 cell} containing no outputs
            biases: {2x1 cell} containing 2 biases
      inputWeights: {2x1 cell} containing 1 input weight
      layerWeights: {2x2 cell} containing no layer weights

    functions:

          adaptFcn: (none)
         divideFcn: (none)
       gradientFcn: (none)
           initFcn: (none)
        performFcn: (none)
          plotFcns: {}
          trainFcn: (none)

    parameters:

        adaptParam: (none)
       divideParam: (none)
     gradientParam: (none)
         initParam: (none)
      performParam: (none)
        trainParam: (none)

    weight and bias values:

                IW: {2x1 cell} containing 1 input weight matrix
                LW: {2x2 cell} containing no layer weight matrices
                 b: {2x1 cell} containing 2 bias vectors

    other:

              name: ''
          userdata: (user information)

>>

========

 

net.layerConnect

This property defines which layers have weights coming from other layers. It can be set to any Nl x Nl matrix of Boolean values, where Nl is the number of network layers (net.numLayers). The presence (or absence) of a weight going to the ith layer from the jth layer is indicated by a 1 (or 0) at
net.layerConnect(i,j)

 

Side Effects.   Any change to this property alters the presence or absence of structures in the cell array of layer weight subobjects (net.layerWeights) and the presence or absence of matrices in the cell array of layer weight matrices (net.LW).

========

>> net.layerConnect=[0 0;1 0]

net =

    Neural Network object:

    architecture:

         numInputs: 1
         numLayers: 2
       biasConnect: [1; 1]
      inputConnect: [1; 0]
      layerConnect: [0 0; 1 0]
     outputConnect: [0 0]

        numOutputs: 0  (read-only)
    numInputDelays: 0  (read-only)
    numLayerDelays: 0  (read-only)

    subobject structures:

            inputs: {1x1 cell} of inputs
            layers: {2x1 cell} of layers
           outputs: {1x2 cell} containing no outputs
            biases: {2x1 cell} containing 2 biases
      inputWeights: {2x1 cell} containing 1 input weight
      layerWeights: {2x2 cell} containing 1 layer weight

    functions:

          adaptFcn: (none)
         divideFcn: (none)
       gradientFcn: (none)
           initFcn: (none)
        performFcn: (none)
          plotFcns: {}
          trainFcn: (none)

    parameters:

        adaptParam: (none)
       divideParam: (none)
     gradientParam: (none)
         initParam: (none)
      performParam: (none)
        trainParam: (none)

    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

    other:

              name: ''
          userdata: (user information)

>>

 

========

 

net.outputConnect

This property defines which layers generate network outputs. It can be set to any 1 x Nl matrix of Boolean values, where Nl is the number of network layers (net.numLayers). The presence (or absence) of a network output from the ith layer is indicated by a 1 (or 0) at net.outputConnect(i).

Side Effects.   Any change to this property alters the number of network outputs (net.numOutputs) and the presence or absence of structures in the cell array of output subobjects (net.outputs).

========

>> net.outputConnect=[0 1]

net =

    Neural Network object:

    architecture:

         numInputs: 1
         numLayers: 2
       biasConnect: [1; 1]
      inputConnect: [1; 0]
      layerConnect: [0 0; 1 0]
     outputConnect: [0 1]

        numOutputs: 1  (read-only)
    numInputDelays: 0  (read-only)
    numLayerDelays: 0  (read-only)

    subobject structures:

            inputs: {1x1 cell} of inputs
            layers: {2x1 cell} of layers
           outputs: {1x2 cell} containing 1 output
            biases: {2x1 cell} containing 2 biases
      inputWeights: {2x1 cell} containing 1 input weight
      layerWeights: {2x2 cell} containing 1 layer weight

    functions:

          adaptFcn: (none)
         divideFcn: (none)
       gradientFcn: (none)
           initFcn: (none)
        performFcn: (none)
          plotFcns: {}
          trainFcn: (none)

    parameters:

        adaptParam: (none)
       divideParam: (none)
     gradientParam: (none)
         initParam: (none)
      performParam: (none)
        trainParam: (none)

    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

    other:

              name: ''
          userdata: (user information)

>>

 

下面是每层的定义

 

net.inputs{i}.exampleInput

This property defines an example of the kinds of values for the ith network input.

Set the value to any Ri x Q matrix, where Ri is the number of elements in the input (net.inputs{i}.size).

Side Effects.   Whenever this property is altered, the input range, size, processedRange, and processedSize are updated to match net.inputs{i}.exampleInput dimensions and the range of values in each of the rows.

net.inputs{i}.processFcns

This property defines a row cell array of processing function names to be used by ith network input. The processing functions are applied to input values before the network uses them.

Side Effects.   Whenever this property is altered, the input processParams are set to default values for the given processing functions, processSettings, processedSize, and processedRange are defined by applying the process functions and parameters to exampleInput.

net.inputs{i}.processParams

This property holds a row cell array of processing function parameters to be used by ith network input. The processing parameters are applied by the processing functions to input values before the network uses them.

For a list of functions, type
help nnprocess

 

Side Effects.   Whenever this property is altered, the input processSettings, processedSize, and processedRange are defined by applying the process functions and parameters to exampleInput.

net.inputs{i}.processSettings (read-only)

This property holds a row cell array of processing function settings to be used by ith network input. The processing settings are found by applying the processing functions and parameters to the exampleInput and then used to provide consistent results to new input values before the network uses them

 

 

net.inputs{i}.processedRange (read-only)

This property defines the range of exampleInput values after they have been processed with the processingFcns and processingParams.

net.inputs{i}.processedSize (read-only)

This property defines the number of rows in the exampleInput values after they have been processed with the processingFcns and processingParams.

net.inputs{i}.range

This property defines the range of each element of the ith network input.

It can be set to any Ri x 2 matrix, where Ri is the number of elements in the input (net.inputs{i}.size), and each element in column 1 is less than the element next to it in column 2.

Each jth row defines the minimum and maximum values of the jth input element, in that order:
net.inputs{i}(j,:)

 

Uses.   Some initialization functions use input ranges to find appropriate initial values for input weight matrices.

Side Effects.   Whenever the number of rows in this property is altered, the input size, processedSize, and processedRange change to remain consistent. The sizes of any weights coming from this input and the dimensions of the weight matrices also change.

net.inputs{i}.size

This property defines the number of elements in the ith network input. It can be set to 0 or a positive integer.

Side Effects.   Whenever this property is altered, the input range, processedRange, and processedSize are updated. Any associated input weights change size accordingly.

net.inputs{i}.userdata

This property provides a place for users to add custom information to the ith network input.

 

 

Layers

These properties define the details of each ith network layer.

net.layers{i}.dimensions

This property defines the physical dimensions of the ith layer's neurons. Being able to arrange a layer's neurons in a multidimensional manner is important for self-organizing maps.

It can be set to any row vector of 0 or positive integer elements, where the product of all the elements becomes the number of neurons in the layer (net.layers{i}.size).

Uses.   Layer dimensions are used to calculate the neuron positions within the layer (net.layers{i}.positions) using the layer's topology function (net.layers{i}.topologyFcn).

Side Effects.   Whenever this property is altered, the layer's size (net.layers{i}.size) changes to remain consistent. The layer's neuron positions (net.layers{i}.positions) and the distances between the neurons (net.layers{i}.distances) are also updated.

net.layers{i}.distanceFcn

This property defines which of the distance function is used to calculate distances between neurons in the ith layer from the neuron positions. Neuron distances are used by self-organizing maps. It can be set to the name of any distance function.

For a list of functions, type
help nndistance

 

Side Effects.   Whenever this property is altered, the distances between the layer's neurons (net.layers{i}.distances) are updated.

net.layers{i}.distances (read-only)

This property defines the distances between neurons in the ith layer. These distances are used by self-organizing maps:
net.layers{i}.distances

 

It is always set to the result of applying the layer's distance function (net.layers{i}.distanceFcn) to the positions of the layer's neurons (net.layers{i}.positions).

net.layers{i}.initFcn

This property defines which of the layer initialization functions are used to initialize the ith layer, if the network initialization function (net.initFcn) is initlay. If the network initialization is set to initlay, then the function indicated by this property is used to initialize the layer's weights and biases.

For a list of functions, type
help nninit

 

net.layers{i}.netInputFcn

This property defines which of the net input functions is used to calculate the ith layer's net input, given the layer's weighted inputs and bias during simulating and training.

For a list of functions, type
help nnnetinput

 

net.layers{i}.netInputParam

This property defines the parameters of the layer's net input function. Call help on the current net input function to get a description of each field:
help(net.layers{i}.netInputFcn)

 

net.layers{i}.positions (read-only)

This property defines the positions of neurons in the ith layer. These positions are used by self-organizing maps.

It is always set to the result of applying the layer's topology function (net.layers{i}.topologyFcn) to the positions of the layer's dimensions (net.layers{i}.dimensions).

Plotting.   Use plotsom to plot the positions of a layer's neurons.

For instance, if the first-layer neurons of a network are arranged with dimensions (net.layers{1}.dimensions) of [4 5], and the topology function (net.layers{1}.topologyFcn) is hextop, the neurons' positions can be plotted as follows:
plotsom(net.layers{1}.positions)

 

net.layers{i}.size

This property defines the number of neurons in the ith layer. It can be set to 0 or a positive integer.

Side Effects.   Whenever this property is altered, the sizes of any input weights going to the layer (net.inputWeights{i,:}.size), any layer weights going to the layer (net.layerWeights{i,:}.size) or coming from the layer (net.inputWeights{i,:}.size), and the layer's bias (net.biases{i}.size), change.

The dimensions of the corresponding weight matrices (net.IW{i,:}, net.LW{i,:}, net.LW{:,i}), and biases (net.b{i}) also change.

Changing this property also changes the size of the layer's output (net.outputs{i}.size) and target (net.targets{i}.size) if they exist.

Finally, when this property is altered, the dimensions of the layer's neurons (net.layers{i}.dimension) are set to the same value. (This results in a one-dimensional arrangement of neurons. If another arrangement is required, set the dimensions property directly instead of using size.)

net.layers{i}.topologyFcn

This property defines which of the topology functions are used to calculate the ith layer's neuron positions (net.layers{i}.positions) from the layer's dimensions (net.layers{i}.dimensions).

For a list of functions, type
help nntopology

 

Side Effects.   Whenever this property is altered, the positions of the layer's neurons (net.layers{i}.positions) are updated.

Use plotsom to plot the positions of the layer neurons. For instance, if the first-layer neurons of a network are arranged with dimensions (net.layers{1}.dimensions) of [8 10] and the topology function (net.layers{1}.topologyFcn) is randtop, the neuron positions are arranged to resemble the following plot:
plotsom(net.layers{1}.positions)

 

 

net.layers{i}.transferFcn

This function defines which of the transfer functions is used to calculate the ith layer's output, given the layer's net input, during simulation and training.

For a list of functions type: help nntransfer

net.layers{i}.transferParam

This property defines the parameters of the layer's transfer function. Call help on the current transfer function to get a description of what each field means.
help(net.layers{i}.transferFcn)

 

net.layers{i}.userdata

This property provides a place for users to add custom information to the ith network layer.

Outputs

net.outputs{i}.exampleOutput

This property defines an example of the kinds of target values to be expected by ith network output.

It can be set to any Si x Q matrix, where Si is the desired size of the output.

Side Effects.   Whenever this property is altered, the output range, size, processedRange, and processedSize are updated to match its dimensions and the range of values in each of its rows. The size of the ith layer size is also updated to match the processedSize.

net.outputs{i}.processFcns

This property defines a row cell array of processing function names to be used by the ith network output. The processing functions are applied to target values before the network uses them, and applied in reverse to layer output values before being returned as network output values.

Side Effects.   When you change this property, you also affect the following settings: the output parameters processParams are modified to the default values of the specified processing functions; processSettings, processedSize, and processedRange are defined using the results of applying the process functions and parameters to exampleOutput; the ith layer size is updated to match the processedSize.

For a list of functions, type
help nnprocess

 

net.outputs{i}.processParams

This property holds a row cell array of processing function parameters to be used by ith network output on target values. The processing parameters are applied by the processing functions to input values before the network uses them.

Side Effects.   Whenever this property is altered, the output processSettings, processedSize and processedRange are defined by applying the process functions and parameters to exampleOutput. The ith layer's size is also updated to match the processedSize.

net.outputs{i}.processSettings (read-only)

This property holds a row cell array of processing function settings to be used by ith network output. The processing settings are found by applying the processing functions and parameters to the exampleOutput and then used to provide consistent results to new target values before the network uses them. The processing settings are also applied in reverse to layer output values before being returned by the network.

net.outputs{i}.processedRange (read-only)

This property defines the range of exampleOutput values after they have been processed with the processingFcns and processingParams.

net.outputs{i}.processedSize (read-only)

This property defines the number of rows in the exampleOutput values after they have been processed with the processingFcns and processingParams.

net.outputs{i}.size (read-only)

This property defines the number of elements in the ith layer's output. It is always set to the size of the ith layer (net.layers{i}.size).

net.outputs{i}.userdata

This property provides a place for users to add custom information to the ith layer's output.

Biases

net.biases{i}.initFcn

This property defines the weight and bias initialization functions used to set the ith layer's bias vector (net.b{i}) if the network initialization function is initlay and the ith layer's initialization function is initwb.

For a list of functions, type
help nninit

 

 

net.biases{i}.learn

This property defines whether the ith bias vector is to be altered during training and adaption. It can be set to 0 or 1.

It enables or disables the bias's learning during calls to adapt and train.

net.biases{i}.learnFcn

This property defines which of the learning functions is used to update the ith layer's bias vector (net.b{i}) during training, if the network training function is trainb, trainc, or trainr, or during adaption, if the network adapt function is trains.

For a list of functions, type
help nnlearn

 

Side Effects.   Whenever this property is altered, the biases learning parameters (net.biases{i}.learnParam) are set to contain the fields and default values of the new function.

net.biases{i}.learnParam

This property defines the learning parameters and values for the current learning function of the ith layer's bias. The fields of this property depend on the current learning function. Call help on the current learning function to get a description of what each field means.

net.biases{i}.size (read-only)

This property defines the size of the ith layer's bias vector. It is always set to the size of the ith layer (net.layers{i}.size).

net.biases{i}.userdata

This property provides a place for users to add custom information to the ith layer's bias.

Input Weights

net.inputWeights{i,j}.delays

This property defines a tapped delay line between the jth input and its weight to the ith layer. It must be set to a row vector of increasing values. The elements must be either 0 or positive integers.

Side Effects.   Whenever this property is altered, the weight's size (net.inputWeights{i,j}.size) and the dimensions of its weight matrix (net.IW{i,j}) are updated.

net.inputWeights{i,j}.initFcn

This property defines which of the weight and bias initialization functions is used to initialize the weight matrix (net.IW{i,j}) going to the ith layer from the jth input, if the network initialization function is initlay, and the ith layer's initialization function is initwb. This function can be set to the name of any weight initialization function.

For a list of functions, type
help nninit

 

net.inputWeights{i,j}.learn

This property defines whether the weight matrix to the ith layer from the jth input is to be altered during training and adaption. It can be set to 0 or 1.

net.inputWeights{i,j}.learnFcn

This property defines which of the learning functions is used to update the weight matrix (net.IW{i,j}) going to the ith layer from the jth input during training, if the network training function is trainb, trainc, or trainr, or during adaption, if the network adapt function is trains. It can be set to the name of any weight learning function.

For a list of functions, type
help nnlearn

 

net.inputWeights{i,j}.learnParam

This property defines the learning parameters and values for the current learning function of the ith layer's weight coming from the jth input.

The fields of this property depend on the current learning function (net.inputWeights{i,j}.learnFcn). Evaluate the above reference to see the fields of the current learning function.

Call help on the current learning function to get a description of what each field means.

net.inputWeights{i,j}.size (read-only)

This property defines the dimensions of the ith layer's weight matrix from the jth network input. It is always set to a two-element row vector indicating the number of rows and columns of the associated weight matrix (net.IW{i,j}). The first element is equal to the size of the ith layer (net.layers{i}.size). The second element is equal to the product of the length of the weight's delay vectors and the size of the jth input:
length(net.inputWeights{i,j}.delays) * net.inputs{j}.size

 

net.inputWeights{i,j}.userdata

This property provides a place for users to add custom information to the (i,j)th input weight.

net.inputWeights{i,j}.weightFcn

This property defines which of the weight functions is used to apply the ith layer's weight from the jth input to that input. It can be set to the name of any weight function. The weight function is used to transform layer inputs during simulation and training.

For a list of functions, type
help nnweight

 

net.inputWeights{i,j}.weightParam

This property defines the parameters of the layer's net input function. Call help on the current net input function to get a description of each field