org.deeplearning4j.nn.api.layers

Interface RecurrentLayer

All Superinterfaces:

Cloneable, Layer, Model, Serializable

All Known Implementing Classes:

BaseRecurrentLayer, GravesBidirectionalLSTM, GravesLSTM, LSTM

public interface RecurrentLayer
extends Layer

Created by Alex on 28/08/2016.

Nested Class Summary

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

Layer.TrainingMode, Layer.Type

Method Summary

Modifier and Type	Method and Description
org.nd4j.linalg.api.ndarray.INDArray	rnnActivateUsingStoredState(org.nd4j.linalg.api.ndarray.INDArray input, boolean training, boolean storeLastForTBPTT) Similar to rnnTimeStep, this method is used for activations using the state stored in the stateMap as the initialization.
void	rnnClearPreviousState() Reset/clear the stateMap for rnnTimeStep() and tBpttStateMap for rnnActivateUsingStoredState()
Map<String,org.nd4j.linalg.api.ndarray.INDArray>	rnnGetPreviousState() Returns a shallow copy of the RNN stateMap (that contains the stored history for use in methods such as rnnTimeStep
Map<String,org.nd4j.linalg.api.ndarray.INDArray>	rnnGetTBPTTState() Get the RNN truncated backpropagations through time (TBPTT) state for the recurrent layer.
void	rnnSetPreviousState(Map<String,org.nd4j.linalg.api.ndarray.INDArray> stateMap) Set the stateMap (stored history).
void	rnnSetTBPTTState(Map<String,org.nd4j.linalg.api.ndarray.INDArray> state) Set the RNN truncated backpropagations through time (TBPTT) state for the recurrent layer.
org.nd4j.linalg.api.ndarray.INDArray	rnnTimeStep(org.nd4j.linalg.api.ndarray.INDArray input) Do one or more time steps using the previous time step state stored in stateMap. Can be used to efficiently do forward pass one or n-steps at a time (instead of doing forward pass always from t=0) If stateMap is empty, default initialization (usually zeros) is used Implementations also update stateMap at the end of this method
org.nd4j.linalg.primitives.Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray>	tbpttBackpropGradient(org.nd4j.linalg.api.ndarray.INDArray epsilon, int tbpttBackLength) Truncated BPTT equivalent of Layer.backpropGradient().

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

activate, activate, activate, activate, activate, activate, activationMean, backpropGradient, calcGradient, calcL1, calcL2, clone, derivativeActivation, error, feedForwardMaskArray, getIndex, getInputMiniBatchSize, getListeners, getMaskArray, isPretrainLayer, merge, preOutput, preOutput, preOutput, setCacheMode, setIndex, setInput, setInputMiniBatchSize, setListeners, setListeners, setMaskArray, transpose, type

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

accumulateScore, addListeners, applyLearningRateScoreDecay, 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

rnnTimeStep

org.nd4j.linalg.api.ndarray.INDArray rnnTimeStep(org.nd4j.linalg.api.ndarray.INDArray input)

Do one or more time steps using the previous time step state stored in stateMap.
Can be used to efficiently do forward pass one or n-steps at a time (instead of doing forward pass always from t=0)
If stateMap is empty, default initialization (usually zeros) is used
Implementations also update stateMap at the end of this method

Parameters:

input - Input to this layer

Returns:

activations

rnnGetPreviousState

Map<String,org.nd4j.linalg.api.ndarray.INDArray> rnnGetPreviousState()

Returns a shallow copy of the RNN stateMap (that contains the stored history for use in methods such as rnnTimeStep

rnnSetPreviousState

void rnnSetPreviousState(Map<String,org.nd4j.linalg.api.ndarray.INDArray> stateMap)

Set the stateMap (stored history). Values set using this method will be used in next call to rnnTimeStep()

rnnClearPreviousState

void rnnClearPreviousState()

Reset/clear the stateMap for rnnTimeStep() and tBpttStateMap for rnnActivateUsingStoredState()

rnnActivateUsingStoredState

org.nd4j.linalg.api.ndarray.INDArray rnnActivateUsingStoredState(org.nd4j.linalg.api.ndarray.INDArray input,
                                                                 boolean training,
                                                                 boolean storeLastForTBPTT)

Similar to rnnTimeStep, this method is used for activations using the state stored in the stateMap as the initialization. However, unlike rnnTimeStep this method does not alter the stateMap; therefore, unlike rnnTimeStep, multiple calls to this method (with identical input) will:
(a) result in the same output
(b) leave the state maps (both stateMap and tBpttStateMap) in an identical state

Parameters:

input - Layer input

training - if true: training. Otherwise: test

storeLastForTBPTT - If true: store the final state in tBpttStateMap for use in truncated BPTT training

Returns:

Layer activations

rnnGetTBPTTState

Map<String,org.nd4j.linalg.api.ndarray.INDArray> rnnGetTBPTTState()

Get the RNN truncated backpropagations through time (TBPTT) state for the recurrent layer. The TBPTT state is used to store intermediate activations/state between updating parameters when doing TBPTT learning

Returns:

State for the RNN layer

rnnSetTBPTTState

void rnnSetTBPTTState(Map<String,org.nd4j.linalg.api.ndarray.INDArray> state)

Set the RNN truncated backpropagations through time (TBPTT) state for the recurrent layer. The TBPTT state is used to store intermediate activations/state between updating parameters when doing TBPTT learning

Parameters:

state - TBPTT state to set

tbpttBackpropGradient

org.nd4j.linalg.primitives.Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray> tbpttBackpropGradient(org.nd4j.linalg.api.ndarray.INDArray epsilon,
                                                                                                     int tbpttBackLength)

Truncated BPTT equivalent of Layer.backpropGradient(). Primary difference here is that forward pass in the context of BPTT is that we do forward pass using stored state for truncated BPTT vs. from zero initialization for standard BPTT.