org.deeplearning4j.nn.layers.recurrent

Class MaskZeroLayer

java.lang.Object

org.deeplearning4j.nn.layers.wrapper.BaseWrapperLayer

org.deeplearning4j.nn.layers.recurrent.MaskZeroLayer

All Implemented Interfaces:

Serializable, Cloneable, Layer, Model

public class MaskZeroLayer
extends BaseWrapperLayer

Masks timesteps with 0 activation. Assumes that the input shape is [batch_size, input_size, timesteps].

Author:

Martin Boyanov [email protected]

See Also:

Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from interface org.deeplearning4j.nn.api.Layer

Layer.TrainingMode, Layer.Type

Field Summary

Fields inherited from class org.deeplearning4j.nn.layers.wrapper.BaseWrapperLayer

underlying

Constructor Summary

Constructors

Constructor and Description
MaskZeroLayer(Layer underlying)

Method Summary

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 workspaceMgr) 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
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	numParams() the number of parameters for the model
Layer.Type	type() Returns the layer type

Methods inherited from class org.deeplearning4j.nn.layers.wrapper.BaseWrapperLayer

accumulateScore, addListeners, applyConstraints, batchSize, calcL1, calcL2, clear, clearNoiseWeightParams, clone, computeGradientAndScore, conf, fit, fit, getEpochCount, getGradientsViewArray, getIndex, getInputMiniBatchSize, getIterationCount, getListeners, getMaskArray, getOptimizer, getParam, gradient, gradientAndScore, init, initParams, input, isPretrainLayer, numParams, params, paramTable, paramTable, score, setBackpropGradientsViewArray, setCacheMode, setConf, setEpochCount, setIndex, setInput, setInputMiniBatchSize, setIterationCount, setListeners, setListeners, setMaskArray, setParam, setParams, setParamsViewArray, setParamTable, transpose, update, update, validateInput

Methods inherited from class java.lang.Object

equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MaskZeroLayer

public MaskZeroLayer(@NonNull
                     Layer underlying)

Method Detail

type

public Layer.Type type()

Description copied from interface: Layer

Returns the layer type

Specified by:

type in interface Layer

Overrides:

type in class BaseWrapperLayer

Returns:

backpropGradient

public org.nd4j.linalg.primitives.Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray> backpropGradient(org.nd4j.linalg.api.ndarray.INDArray epsilon,
                                                                                                       LayerWorkspaceMgr workspaceMgr)

Description copied from interface: Layer

Calculate the gradient relative to the error in the next layer

Specified by:

backpropGradient in interface Layer

Overrides:

backpropGradient in class BaseWrapperLayer

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

public org.nd4j.linalg.api.ndarray.INDArray activate(boolean training,
                                                     LayerWorkspaceMgr workspaceMgr)

Description copied from interface: Layer

Perform forward pass and return the activations array with the last set input

Specified by:

activate in interface Layer

Overrides:

activate in class BaseWrapperLayer

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

public org.nd4j.linalg.api.ndarray.INDArray activate(org.nd4j.linalg.api.ndarray.INDArray input,
                                                     boolean training,
                                                     LayerWorkspaceMgr workspaceMgr)

Description copied from interface: Layer

Perform forward pass and return the activations array with the specified input

Specified by:

activate in interface Layer

Overrides:

activate in class BaseWrapperLayer

Parameters:

input - the input to use

training - train or test mode

workspaceMgr - Workspace manager.

Returns:

Activations array. Note that the returned array should be placed in the ArrayType.ACTIVATIONS workspace via the workspace manager

numParams

public int numParams()

Description copied from interface: Model

the number of parameters for the model

Specified by:

numParams in interface Model

Overrides:

numParams in class BaseWrapperLayer

Returns:

the number of parameters for the model

feedForwardMaskArray

public org.nd4j.linalg.primitives.Pair<org.nd4j.linalg.api.ndarray.INDArray,MaskState> feedForwardMaskArray(org.nd4j.linalg.api.ndarray.INDArray maskArray,
                                                                                                            MaskState currentMaskState,
                                                                                                            int minibatchSize)

Description copied from interface: Layer

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.

Specified by:

feedForwardMaskArray in interface Layer

Overrides:

feedForwardMaskArray in class BaseWrapperLayer

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.