Layer (deeplearning4j-nn 1.0.0-beta API)

All Superinterfaces:

Cloneable, Model, Serializable

All Known Subinterfaces:

IOutputLayer, RecurrentLayer

All Known Implementing Classes:

AbstractLayer, ActivationLayer, AutoEncoder, BaseLayer, BaseOutputLayer, BasePretrainNetwork, BaseRecurrentLayer, BaseWrapperLayer, BatchNormalization, BidirectionalLayer, CenterLossOutputLayer, CnnLossLayer, Convolution1DLayer, Convolution3DLayer, ConvolutionLayer, Cropping1DLayer, Cropping2DLayer, Cropping3DLayer, Deconvolution2DLayer, DenseLayer, DepthwiseConvolution2DLayer, DropoutLayer, ElementWiseMultiplicationLayer, EmbeddingLayer, EmbeddingSequenceLayer, FrozenLayer, FrozenLayerWithBackprop, GlobalPoolingLayer, GravesBidirectionalLSTM, GravesLSTM, LastTimeStepLayer, LocalResponseNormalization, LossLayer, LSTM, MaskLayer, MaskZeroLayer, MultiLayerNetwork, OCNNOutputLayer, OutputLayer, RnnLossLayer, RnnOutputLayer, SameDiffLayer, SeparableConvolution2DLayer, SimpleRnn, SpaceToBatch, SpaceToDepth, Subsampling1DLayer, Subsampling3DLayer, SubsamplingLayer, Upsampling1D, Upsampling2D, Upsampling3D, VariationalAutoencoder, Yolo2OutputLayer, ZeroPadding1DLayer, ZeroPadding3DLayer, ZeroPaddingLayer
```
public interface Layer
extends Serializable, Cloneable, Model
```
Interface for a layer of a neural network. This has an activation function, an input and output size, weights, and a bias

Author:

Adam Gibson

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Layer.TrainingMode

static class Layer.Type

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Layer.TrainingMode`
`static class`	`Layer.Type`

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(boolean training, LayerWorkspaceMgr workspaceMgr)` Perform forward pass and return the activations array with the last set input
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(org.nd4j.linalg.api.ndarray.INDArray input, boolean training, LayerWorkspaceMgr mgr)` Perform forward pass and return the activations array with the specified input
`org.nd4j.linalg.primitives.Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray>`	`backpropGradient(org.nd4j.linalg.api.ndarray.INDArray epsilon, LayerWorkspaceMgr workspaceMgr)` Calculate the gradient relative to the error in the next layer
`double`	`calcL1(boolean backpropOnlyParams)` Calculate the l1 regularization term 0.0 if regularization is not used.
`double`	`calcL2(boolean backpropOnlyParams)` Calculate the l2 regularization term 0.0 if regularization is not used.
`void`	`clearNoiseWeightParams()`
`Layer`	`clone()` Deprecated.
`org.nd4j.linalg.primitives.Pair<org.nd4j.linalg.api.ndarray.INDArray,MaskState>`	`feedForwardMaskArray(org.nd4j.linalg.api.ndarray.INDArray maskArray, MaskState currentMaskState, int minibatchSize)` Feed forward the input mask array, setting in in the layer as appropriate.
`int`	`getEpochCount()`
`int`	`getIndex()` Get the layer index.
`int`	`getInputMiniBatchSize()` Get current/last input mini-batch size, as set by setInputMiniBatchSize(int)
`int`	`getIterationCount()`
`Collection<TrainingListener>`	`getListeners()` Get the iteration listeners for this layer.
`org.nd4j.linalg.api.ndarray.INDArray`	`getMaskArray()`
`boolean`	`isPretrainLayer()` Returns true if the layer can be trained in an unsupervised/pretrain manner (AE, VAE, etc)
`void`	`setCacheMode(CacheMode mode)` This method sets given CacheMode for current layer
`void`	`setEpochCount(int epochCount)` Set the current epoch count (number of epochs passed ) for the layer/network
`void`	`setIndex(int index)` Set the layer index.
`void`	`setInput(org.nd4j.linalg.api.ndarray.INDArray input, LayerWorkspaceMgr workspaceMgr)` Set the layer input.
`void`	`setInputMiniBatchSize(int size)` Set current/last input mini-batch size. Used for score and gradient calculations.
`void`	`setIterationCount(int iterationCount)` Set the current iteration count (number of parameter updates) for the layer/network
`void`	`setListeners(Collection<TrainingListener> listeners)` Set the iteration listeners for this layer.
`void`	`setListeners(TrainingListener... listeners)` Set the iteration listeners for this layer.
`void`	`setMaskArray(org.nd4j.linalg.api.ndarray.INDArray maskArray)` Set the mask array.
`Layer`	`transpose()` Deprecated.
`Layer.Type`	`type()` Returns the layer type

Methods inherited from interface org.deeplearning4j.nn.api.Model
accumulateScore, addListeners, applyConstraints, batchSize, clear, computeGradientAndScore, conf, fit, fit, getGradientsViewArray, getOptimizer, getParam, gradient, gradientAndScore, init, initParams, input, numParams, numParams, params, paramTable, paramTable, score, setBackpropGradientsViewArray, setConf, setParam, setParams, setParamsViewArray, setParamTable, update, update, validateInput

- Method Detail
  - setCacheMode
```
void setCacheMode(CacheMode mode)
```
    This method sets given CacheMode for current layer
    
    Parameters:
    
    mode -
  - calcL2
```
double calcL2(boolean backpropOnlyParams)
```
    Calculate the l2 regularization term
    0.0 if regularization is not used. Or 0.5 * l2Coeff * l2Magnitude otherwise.
    Note that this does not divide by mini-batch size
    
    Parameters:
    
    backpropOnlyParams - If true: calculate L2 based on backprop params only. If false: calculate based on all params (including pretrain params, if any)
    
    Returns:
    
    the l2 regularization term for this layer.
  - calcL1
```
double calcL1(boolean backpropOnlyParams)
```
    Calculate the l1 regularization term
    0.0 if regularization is not used. Or l1Coeff * l1Magnitude otherwise.
    Note that this does not divide by mini-batch size
    
    Parameters:
    
    backpropOnlyParams - If true: calculate L1 based on backprop params only. If false: calculate based on all params (including pretrain params, if any)
    
    Returns:
    
    the l1 regularization term for this layer.
  - type
```
Layer.Type type()
```
    Returns the layer type
    
    Returns:
  - backpropGradient
```
org.nd4j.linalg.primitives.Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray> backpropGradient(org.nd4j.linalg.api.ndarray.INDArray epsilon,
                                                                                                LayerWorkspaceMgr workspaceMgr)
```
    Calculate the gradient relative to the error in the next layer
    
    Parameters:
    
    epsilon - w^(L+1)*delta^(L+1). Or, equiv: dC/da, i.e., (dC/dz)*(dz/da) = dC/da, where C is cost function a=sigma(z) is activation.
    
    workspaceMgr - Workspace manager
    
    Returns:
    
    Pair where Gradient is gradient for this layer, INDArray is epsilon (activation gradient) needed by next layer, but before element-wise multiply by sigmaPrime(z). So for standard feed-forward layer, if this layer is L, then return.getSecond() == dL/dIn = (w^(L)*(delta^(L))^T)^T. Note that the returned array should be placed in the ArrayType.ACTIVATION_GRAD workspace via the workspace manager
  - activate
```
org.nd4j.linalg.api.ndarray.INDArray activate(boolean training,
                                              LayerWorkspaceMgr workspaceMgr)
```
    Perform forward pass and return the activations array with the last set input
    
    Parameters:
    
    training - training or test mode
    
    workspaceMgr - Workspace manager
    
    Returns:
    
    the activation (layer output) of the last specified input. Note that the returned array should be placed in the ArrayType.ACTIVATIONS workspace via the workspace manager
  - activate
```
org.nd4j.linalg.api.ndarray.INDArray activate(org.nd4j.linalg.api.ndarray.INDArray input,
                                              boolean training,
                                              LayerWorkspaceMgr mgr)
```
    Perform forward pass and return the activations array with the specified input
    
    Parameters:
    
    input - the input to use
    
    training - train or test mode
    
    mgr - Workspace manager.
    
    Returns:
    
    Activations array. Note that the returned array should be placed in the ArrayType.ACTIVATIONS workspace via the workspace manager
  - transpose
```
@Deprecated
Layer transpose()
```
    Deprecated.
    
    Return a transposed copy of the weights/bias (this means reverse the number of inputs and outputs on the weights)
    
    Returns:
    
    the transposed layer
  - clone
```
@Deprecated
Layer clone()
```
    Deprecated.
    
    Clone the layer
    
    Returns:
  - getListeners
```
Collection<TrainingListener> getListeners()
```
    Get the iteration listeners for this layer.
  - setListeners
```
void setListeners(TrainingListener... listeners)
```
    Set the iteration listeners for this layer.
    
    Specified by:
    
    setListeners in interface Model
  - setListeners
```
void setListeners(Collection<TrainingListener> listeners)
```
    Set the iteration listeners for this layer.
    
    Specified by:
    
    setListeners in interface Model
  - setIndex
```
void setIndex(int index)
```
    Set the layer index.
  - getIndex
```
int getIndex()
```
    Get the layer index.
  - getIterationCount
```
int getIterationCount()
```
    Returns:
    
    The current iteration count (number of parameter updates) for the layer/network
  - getEpochCount
```
int getEpochCount()
```
    Returns:
    
    The current epoch count (number of training epochs passed) for the layer/network
  - setIterationCount
```
void setIterationCount(int iterationCount)
```
    Set the current iteration count (number of parameter updates) for the layer/network
  - setEpochCount
```
void setEpochCount(int epochCount)
```
    Set the current epoch count (number of epochs passed ) for the layer/network
  - setInput
```
void setInput(org.nd4j.linalg.api.ndarray.INDArray input,
              LayerWorkspaceMgr workspaceMgr)
```
    Set the layer input.
  - setInputMiniBatchSize
```
void setInputMiniBatchSize(int size)
```
    Set current/last input mini-batch size.
    Used for score and gradient calculations. Mini batch size may be different from getInput().size(0) due to reshaping operations - for example, when using RNNs with DenseLayer and OutputLayer. Called automatically during forward pass.
  - getInputMiniBatchSize
```
int getInputMiniBatchSize()
```
    Get current/last input mini-batch size, as set by setInputMiniBatchSize(int)
    
    See Also:
    
    setInputMiniBatchSize(int)
  - setMaskArray
```
void setMaskArray(org.nd4j.linalg.api.ndarray.INDArray maskArray)
```
    Set the mask array. Note: In general, feedForwardMaskArray(INDArray, MaskState, int) should be used in preference to this.
    
    Parameters:
    
    maskArray - Mask array to set
  - getMaskArray
```
org.nd4j.linalg.api.ndarray.INDArray getMaskArray()
```
  - isPretrainLayer
```
boolean isPretrainLayer()
```
    Returns true if the layer can be trained in an unsupervised/pretrain manner (AE, VAE, etc)
    
    Returns:
    
    true if the layer can be pretrained (using fit(INDArray), false otherwise
  - clearNoiseWeightParams
```
void clearNoiseWeightParams()
```
  - feedForwardMaskArray
```
org.nd4j.linalg.primitives.Pair<org.nd4j.linalg.api.ndarray.INDArray,MaskState> feedForwardMaskArray(org.nd4j.linalg.api.ndarray.INDArray maskArray,
                                                                                                     MaskState currentMaskState,
                                                                                                     int minibatchSize)
```
    Feed forward the input mask array, setting in in the layer as appropriate. This allows different layers to handle masks differently - for example, bidirectional RNNs and normal RNNs operate differently with masks (the former sets activations to 0 outside of the data present region (and keeps the mask active for future layers like dense layers), whereas normal RNNs don't zero out the activations/errors )instead relying on backpropagated error arrays to handle the variable length case.
    This is also used for example for networks that contain global pooling layers, arbitrary preprocessors, etc.
    
    Parameters:
    
    maskArray - Mask array to set
    
    currentMaskState - Current state of the mask - see MaskState
    
    minibatchSize - Current minibatch size. Needs to be known as it cannot always be inferred from the activations array due to reshaping (such as a DenseLayer within a recurrent neural network)
    
    Returns:
    
    New mask array after this layer, along with the new mask state.

Interface Layer

Nested Class Summary

Method Summary

Methods inherited from interface org.deeplearning4j.nn.api.Model

Method Detail

setCacheMode

calcL2

calcL1

type

backpropGradient

activate

activate

transpose

clone

getListeners

setListeners

setListeners

setIndex

getIndex

getIterationCount

getEpochCount

setIterationCount

setEpochCount

setInput

setInputMiniBatchSize

getInputMiniBatchSize

setMaskArray

getMaskArray

isPretrainLayer

clearNoiseWeightParams

feedForwardMaskArray