org.deeplearning4j.nn.layers.recurrent

Class SimpleRnn

java.lang.Object

org.deeplearning4j.nn.layers.AbstractLayer<LayerConfT>

org.deeplearning4j.nn.layers.BaseLayer<LayerConfT>

org.deeplearning4j.nn.layers.recurrent.BaseRecurrentLayer<SimpleRnn>

org.deeplearning4j.nn.layers.recurrent.SimpleRnn

All Implemented Interfaces:

Serializable, Cloneable, Layer, RecurrentLayer, Model

public class SimpleRnn
extends BaseRecurrentLayer<SimpleRnn>

Simple RNN - aka "vanilla" RNN is the simplest type of recurrent neural network layer. It implements out_t = activationFn( in_t * inWeight + out_(t-1) * recurrentWeights + bias). Note that other architectures (LSTM, etc) are usually more effective, especially for longer time series

Author:

Alex Black

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

Modifier and Type	Field and Description
static String	STATE_KEY_PREV_ACTIVATION

Fields inherited from class org.deeplearning4j.nn.layers.recurrent.BaseRecurrentLayer

stateMap, tBpttStateMap

Fields inherited from class org.deeplearning4j.nn.layers.BaseLayer

gradient, gradientsFlattened, gradientViews, optimizer, params, paramsFlattened, score, solver, weightNoiseParams

Fields inherited from class org.deeplearning4j.nn.layers.AbstractLayer

cacheMode, conf, dropoutApplied, dropoutMask, epochCount, index, input, iterationCount, iterationListeners, maskArray, maskState, preOutput

Constructor Summary

Constructors

Constructor and Description
SimpleRnn(NeuralNetConfiguration conf)

Method Summary

Modifier and Type	Method and Description
org.nd4j.linalg.api.ndarray.INDArray	activate(boolean 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
boolean	isPretrainLayer() Returns true if the layer can be trained in an unsupervised/pretrain manner (AE, VAE, etc)
org.nd4j.linalg.api.ndarray.INDArray	preOutput(boolean training)
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.
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 class org.deeplearning4j.nn.layers.recurrent.BaseRecurrentLayer

rnnClearPreviousState, rnnGetPreviousState, rnnGetTBPTTState, rnnSetPreviousState, rnnSetTBPTTState

Methods inherited from class org.deeplearning4j.nn.layers.BaseLayer

accumulateScore, activate, activate, calcL1, calcL2, clear, clearNoiseWeightParams, clone, computeGradientAndScore, fit, fit, getGradientsViewArray, getOptimizer, getParam, getParamWithNoise, gradient, hasBias, initParams, iterate, layerConf, numParams, params, paramTable, paramTable, preOutput, score, setBackpropGradientsViewArray, setParam, setParams, setParams, setParamsViewArray, setParamTable, setScoreWithZ, toString, transpose, update, update

Methods inherited from class org.deeplearning4j.nn.layers.AbstractLayer

activate, activate, activate, addListeners, applyConstraints, applyDropOutIfNecessary, applyMask, batchSize, conf, feedForwardMaskArray, getIndex, getInput, getInputMiniBatchSize, getListeners, getMaskArray, gradientAndScore, init, input, layerId, migrateInput, numParams, preOutput, preOutput, setCacheMode, setConf, setIndex, setInput, setInputMiniBatchSize, setListeners, setListeners, setMaskArray, type, validateInput

Methods inherited from class java.lang.Object

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

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

activate, activate, activate, activate, activate, calcL1, calcL2, clearNoiseWeightParams, clone, feedForwardMaskArray, getEpochCount, getIndex, getInputMiniBatchSize, getIterationCount, getListeners, getMaskArray, migrateInput, preOutput, preOutput, preOutput, setCacheMode, setEpochCount, setIndex, setInput, setInputMiniBatchSize, setIterationCount, setListeners, setListeners, setMaskArray, transpose, 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

Field Detail

STATE_KEY_PREV_ACTIVATION

public static final String STATE_KEY_PREV_ACTIVATION

See Also:

Constant Field Values

Constructor Detail

SimpleRnn

public SimpleRnn(NeuralNetConfiguration conf)

Method Detail

rnnTimeStep

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

Description copied from interface: RecurrentLayer

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

rnnActivateUsingStoredState

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

Description copied from interface: RecurrentLayer

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

backpropGradient

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

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 BaseLayer<SimpleRnn>

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

tbpttBackpropGradient

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

Description copied from interface: RecurrentLayer

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.

isPretrainLayer

public boolean isPretrainLayer()

Description copied from interface: Layer

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

preOutput

public org.nd4j.linalg.api.ndarray.INDArray preOutput(boolean training)

Overrides:

preOutput in class BaseLayer<SimpleRnn>

activate

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

Description copied from interface: Layer

Trigger an activation with the last specified input

Specified by:

activate in interface Layer

Overrides:

activate in class BaseLayer<SimpleRnn>

Parameters:

training - training or test mode

Returns:

the activation of the last specified input