Layer (deeplearning4j-nn 1.0.0-alpha 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, ConvolutionLayer, Cropping2DLayer, Deconvolution2DLayer, DenseLayer, DropoutLayer, ElementWiseMultiplicationLayer, EmbeddingLayer, FrozenLayer, GlobalPoolingLayer, GravesBidirectionalLSTM, GravesLSTM, LastTimeStepLayer, LocalResponseNormalization, LossLayer, LSTM, MaskLayer, MaskZeroLayer, MultiLayerNetwork, OutputLayer, RnnLossLayer, RnnOutputLayer, SameDiffLayer, SeparableConvolution2DLayer, SimpleRnn, SpaceToBatch, SpaceToDepth, Subsampling1DLayer, SubsamplingLayer, Upsampling1D, Upsampling2D, VariationalAutoencoder, Yolo2OutputLayer, ZeroPadding1DLayer, 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()` Trigger an activation with the last specified input
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(boolean training)` Trigger an activation with the last specified input
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(org.nd4j.linalg.api.ndarray.INDArray input)` Initialize the layer with the given input and return the activation for this layer given this input
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(org.nd4j.linalg.api.ndarray.INDArray input, boolean training)` Initialize the layer with the given input and return the activation for this layer given this input
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(org.nd4j.linalg.api.ndarray.INDArray input, Layer.TrainingMode training)` Initialize the layer with the given input and return the activation for this layer given this input
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(Layer.TrainingMode training)` Trigger an activation with the last specified input
`org.nd4j.linalg.primitives.Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray>`	`backpropGradient(org.nd4j.linalg.api.ndarray.INDArray epsilon)` 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()` Clone the layer
`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<IterationListener>`	`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`	`migrateInput()` For use with ND4J workspaces.
`org.nd4j.linalg.api.ndarray.INDArray`	`preOutput(org.nd4j.linalg.api.ndarray.INDArray x)` Raw activations
`org.nd4j.linalg.api.ndarray.INDArray`	`preOutput(org.nd4j.linalg.api.ndarray.INDArray x, boolean training)` Raw activations
`org.nd4j.linalg.api.ndarray.INDArray`	`preOutput(org.nd4j.linalg.api.ndarray.INDArray x, Layer.TrainingMode training)` Raw activations
`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)` Get 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<IterationListener> listeners)` Set the iteration listeners for this layer.
`void`	`setListeners(IterationListener... 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, iterate, 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)
```
    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.
    
    Returns:
    
    Pair where Gradient is gradient for this layer, INDArray is epsilon 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() == (w^(L)*(delta^(L))^T)^T
  - preOutput
```
org.nd4j.linalg.api.ndarray.INDArray preOutput(org.nd4j.linalg.api.ndarray.INDArray x)
```
    Raw activations
    
    Parameters:
    
    x - the input to transform
    
    Returns:
    
    the raw activation for this layer
  - preOutput
```
org.nd4j.linalg.api.ndarray.INDArray preOutput(org.nd4j.linalg.api.ndarray.INDArray x,
                                               Layer.TrainingMode training)
```
    Raw activations
    
    Parameters:
    
    x - the input to transform
    
    Returns:
    
    the raw activation for this layer
  - activate
```
org.nd4j.linalg.api.ndarray.INDArray activate(Layer.TrainingMode training)
```
    Trigger an activation with the last specified input
    
    Parameters:
    
    training - training or test mode
    
    Returns:
    
    the activation of the last specified input
  - activate
```
org.nd4j.linalg.api.ndarray.INDArray activate(org.nd4j.linalg.api.ndarray.INDArray input,
                                              Layer.TrainingMode training)
```
    Initialize the layer with the given input and return the activation for this layer given this input
    
    Parameters:
    
    input - the input to use
    
    training - train or test mode
    
    Returns:
  - preOutput
```
org.nd4j.linalg.api.ndarray.INDArray preOutput(org.nd4j.linalg.api.ndarray.INDArray x,
                                               boolean training)
```
    Raw activations
    
    Parameters:
    
    x - the input to transform
    
    Returns:
    
    the raw activation for this layer
  - activate
```
org.nd4j.linalg.api.ndarray.INDArray activate(boolean training)
```
    Trigger an activation with the last specified input
    
    Parameters:
    
    training - training or test mode
    
    Returns:
    
    the activation of the last specified input
  - activate
```
org.nd4j.linalg.api.ndarray.INDArray activate(org.nd4j.linalg.api.ndarray.INDArray input,
                                              boolean training)
```
    Initialize the layer with the given input and return the activation for this layer given this input
    
    Parameters:
    
    input - the input to use
    
    training - train or test mode
    
    Returns:
  - activate
```
org.nd4j.linalg.api.ndarray.INDArray activate()
```
    Trigger an activation with the last specified input
    
    Returns:
    
    the activation of the last specified input
  - activate
```
org.nd4j.linalg.api.ndarray.INDArray activate(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Initialize the layer with the given input and return the activation for this layer given this input
    
    Parameters:
    
    input - the input to use
    
    Returns:
  - 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
```
Layer clone()
```
    Clone the layer
    
    Returns:
  - getListeners
```
Collection<IterationListener> getListeners()
```
    Get the iteration listeners for this layer.
  - setListeners
```
void setListeners(IterationListener... listeners)
```
    Set the iteration listeners for this layer.
    
    Specified by:
    
    setListeners in interface Model
  - setListeners
```
void setListeners(Collection<IterationListener> 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)
```
    Get the layer input.
  - migrateInput
```
void migrateInput()
```
    For use with ND4J workspaces. If present, both input and mask arrays will migrated to the currently active workspace, or detached from any workspaces (if no workspace is currently active)
  - 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

preOutput

preOutput

activate

activate

preOutput

activate

activate

activate

activate

transpose

clone

getListeners

setListeners

setListeners

setIndex

getIndex

getIterationCount

getEpochCount

setIterationCount

setEpochCount

setInput

migrateInput

setInputMiniBatchSize

getInputMiniBatchSize

setMaskArray

getMaskArray

isPretrainLayer

clearNoiseWeightParams

feedForwardMaskArray