## Documentation Center |

These properties define the details of a network's inputs, layers, outputs, targets, biases, and weights.

On this page… |
---|

These properties define the details of each *i*th
network input.

This property consists of a string defining the input name.
Network creation functions, such as `feedforwardnet`,
define this appropriately. But it can be set to any string as desired.

If this network is associated with an open-loop feedback output, then this property will indicate the index of that output. Otherwise it will be an empty matrix.

This property defines a row cell array of processing function
names to be used by *i*th 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`.

For a list of processing functions, type `help nnprocess`.

This property holds a row cell array of processing function
parameters to be used by *i*th network input. 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 input `processSettings`, `processedSize`,
and `processedRange` are defined by applying the
process functions and parameters to `exampleInput`.

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

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

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

This property defines the range of each element of the *i*th
network input.

It can be set to any *R _{i}* ×
2 matrix, where

Each *j*th row defines the minimum and maximum
values of the *j*th 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.

This property defines the number of elements in the *i*th
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.

This property provides a place for users to add custom information
to the *i*th network input.

These properties define the details of each *i*th
network layer.

This property consists of a string defining the layer name.
Network creation functions, such as `feedforwardnet`,
define this appropriately. But it can be set to any string as desired.

This property defines the *physical* dimensions
of the *i*th 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.

This property defines which of the
distance functions is used to calculate `distances` between
neurons in the *i*th 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.

This property defines the distances between neurons in the *i*th
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`).

This property defines which of the layer initialization functions
are used to initialize the *i*th 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.

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

For a list of functions, type `help nnnetinput`.

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)

This property defines the positions of neurons in the *i*th
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)

This property defines the output range of each neuron of the *i*th
layer.

It is set to an *S _{i}* ×
2 matrix, where

Each *j*th row defines the minimum and maximum
output values of the layer's transfer function `net.layers{i}.transferFcn`.

This property defines the number of neurons in the *i*th
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`.)

This property defines which of the topology functions are used
to calculate the *i*th 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)

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

For a list of functions, type `help nntransfer`.

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)

This property provides a place for users to add custom information
to the *i*th network layer.

This property consists of a string defining the output name.
Network creation functions, such as `feedforwardnet`,
define this appropriately. But it can be set to any string as desired.

If the output implements open-loop feedback (`net.outputs{i}.feedbackMode
= 'open'`), then this property indicates the index of the
associated feedback input, otherwise it will be an empty matrix.

This property defines the timestep difference between this output
and network inputs. Input-to-output network delays can be removed
and added with `removedelay` and `adddelay` functions resulting in this property
being incremented or decremented respectively. The difference in timing
between inputs and outputs is used by `preparets` to
properly format simulation and training data, and used by `closeloop` to add the correct number of
delays when closing an open-loop output, and `openloop` to
remove delays when opening a closed loop.

This property is set to the string `'none'` for
non-feedback outputs. For feedback outputs it can either be set to `'open'` or `'closed'`.
If it is set to `'open'`, then the output will be
associated with a feedback input, with the property `feedbackInput` indicating
the input's index.

This property defines a row cell array of processing function
names to be used by the *i*th 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 *i*th layer size is updated to match the `processedSize`.

For a list of functions, type `help nnprocess`.

This property holds a row cell array of processing function
parameters to be used by *i*th 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 *i*th layer's size is also updated to match `processedSize`.

This property holds a row cell array of processing function
settings to be used by *i*th network output. The
processing settings are found by applying the processing functions
and parameters to `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.

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

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

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

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

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

This property defines whether the *i*th 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`.

This property defines which of the learning functions is used
to update the *i*th 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.

This property defines the learning parameters and values for
the current learning function of the *i*th 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.

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

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

This property defines a tapped delay line between the *j*th
input and its weight to the *i*th 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.

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 *i*th layer from the *j*th
input, if the network initialization function is `initlay`, and the *i*th
layer's initialization function is `initwb`.
This function can be set to the name of any weight initialization
function.

This property is set to values useful for initializing the weight
as part of the configuration process that occurs automatically the
first time a network is trained, or when the function `configure` is called on a network directly.

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

This property defines which of the learning functions is used
to update the weight matrix (`net.IW{i,j}`) going
to the *i*th layer from the *j*th
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`.

This property defines the learning parameters and values for
the current learning function of the *i*th layer's
weight coming from the *j*th 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.

This property defines the dimensions of the *i*th
layer's weight matrix from the *j*th 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 *i*th
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 *j*th input:

length(net.inputWeights{i,j}.delays) * net.inputs{j}.size

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

This property defines which of the weight functions is used
to apply the *i*th layer's weight from the *j*th
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`.

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.

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

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

This property is set to values useful for initializing the weight
as part of the configuration process that occurs automatically the
first time a network is trained, or when the function `configure` is called on a network directly.

This property defines whether the weight matrix to the *i*th
layer from the *j*th layer is to be altered during
training and adaption. It can be set to 0 or 1.

This property defines which of the learning functions is used
to update the weight matrix (`net.LW{i,j}`) going
to the *i*th layer from the *j*th
layer 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`.

This property defines the learning parameters fields and values
for the current learning function of the *i*th layer's
weight coming from the *j*th layer. The fields of
this property depend on the current learning function. Call `help` on
the current net input function to get a description of each field.

This property defines the dimensions of the *i*th
layer's weight matrix from the *j*th layer. It is
always set to a two-element row vector indicating the number of rows
and columns of the associated weight matrix (`net.LW{i,j}`).
The first element is equal to the size of the *i*th
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 *j*th layer.

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

This property defines which of the weight functions is used
to apply the *i*th layer's weight from the *j*th
layer to that layer's output. It can be set to the name of any weight
function. The weight function is used to transform layer inputs when
the network is simulated.

For a list of functions, type `help nnweight`.

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.

Was this topic helpful?