MultiLayerNetwork (deeplearning4j-nn 1.0.0-beta API)

java.lang.Object
- org.deeplearning4j.nn.multilayer.MultiLayerNetwork

All Implemented Interfaces:

Serializable, Cloneable, Classifier, Layer, Model, NeuralNetwork
```
public class MultiLayerNetwork
extends Object
implements Serializable, Classifier, Layer, NeuralNetwork
```
MultiLayerNetwork is a neural network with multiple layers in a stack, and usually an output layer. For neural networks with a more complex connection architecture, use ComputationGraph which allows for an arbitrary directed acyclic graph connection structure between layers. MultiLayerNetwork is trainable via backprop, with optional pretraining, depending on the type of layers it contains.

Author:

Adam Gibson

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
`protected boolean`	`clearTbpttState`
`protected NeuralNetConfiguration`	`defaultConfiguration`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`flattenedGradients`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`flattenedParams`
`protected Gradient`	`gradient`
`protected boolean`	`initCalled`
`protected boolean`	`initDone`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`input`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`labels`
`protected ThreadLocal<Long>`	`lastEtlTime`
`protected int`	`layerIndex`
`protected LinkedHashMap<String,Layer>`	`layerMap`
`protected Layer[]`	`layers`
`protected MultiLayerConfiguration`	`layerWiseConfigurations`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`mask`
`protected double`	`score`
`protected Solver`	`solver`
`protected Collection<TrainingListener>`	`trainingListeners`
`protected static String`	`WS_ALL_LAYERS_ACT` Workspace for storing all layers' activations - used only to store activations (layer inputs) as part of backprop Not used for inference
`protected static org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration`	`WS_ALL_LAYERS_ACT_CONFIG`
`protected static String`	`WS_LAYER_ACT_1` Next 2 workspaces: used for: (a) Inference: holds activations for one layer only (b) Backprop: holds activation gradients for one layer only In both cases, they are opened and closed on every second layer
`protected static String`	`WS_LAYER_ACT_2`
`protected org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration`	`WS_LAYER_ACT_X_CONFIG`
`protected static String`	`WS_LAYER_WORKING_MEM` Workspace for working memory for a single layer: forward pass and backward pass Note that this is opened/closed once per op (activate/backpropGradient call)
`protected org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration`	`WS_LAYER_WORKING_MEM_CONFIG`
`protected static String`	`WS_RNN_LOOP_WORKING_MEM` Workspace for working memory in RNNs - opened and closed once per RNN time step
`protected static org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration`	`WS_RNN_LOOP_WORKING_MEM_CONFIG`

Constructor Summary

Constructors
Constructor and Description
`MultiLayerNetwork(MultiLayerConfiguration conf)`
`MultiLayerNetwork(MultiLayerConfiguration conf, org.nd4j.linalg.api.ndarray.INDArray params)` Initialize the network based on the configuraiton
`MultiLayerNetwork(String conf, org.nd4j.linalg.api.ndarray.INDArray params)` Initialize the network based on the configuration

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`accumulateScore(double accum)` Sets a rolling tally for the score.
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(boolean training, LayerWorkspaceMgr mgr)` 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)` Deprecated. Use `output(INDArray)`
`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.api.ndarray.INDArray`	`activate(org.nd4j.linalg.api.ndarray.INDArray input, Layer.TrainingMode training)`
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(Layer.TrainingMode training)`
`org.nd4j.linalg.api.ndarray.INDArray`	`activateSelectedLayers(int from, int to, org.nd4j.linalg.api.ndarray.INDArray input)` Calculate activation for few layers at once.
`org.nd4j.linalg.api.ndarray.INDArray`	`activationFromPrevLayer(int curr, org.nd4j.linalg.api.ndarray.INDArray input, boolean training, LayerWorkspaceMgr mgr)`
`void`	`addListeners(TrainingListener... listeners)` This method ADDS additional TrainingListener to existing listeners
`void`	`applyConstraints(int iteration, int epoch)` Apply any constraints to the model
`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
`int`	`batchSize()` The current inputs batch size
`protected org.nd4j.linalg.primitives.Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray>`	`calcBackpropGradients(org.nd4j.linalg.api.ndarray.INDArray epsilon, boolean withOutputLayer, boolean tbptt, boolean returnInputActGrad)` Calculate gradients and errors.
`double`	`calcL1(boolean backpropParamsOnly)` Calculate the l1 regularization term 0.0 if regularization is not used.
`double`	`calcL2(boolean backpropParamsOnly)` Calculate the l2 regularization term 0.0 if regularization is not used.
`org.nd4j.linalg.primitives.Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray>`	`calculateGradients(org.nd4j.linalg.api.ndarray.INDArray features, org.nd4j.linalg.api.ndarray.INDArray label, org.nd4j.linalg.api.ndarray.INDArray fMask, org.nd4j.linalg.api.ndarray.INDArray labelMask)` Calculate parameter gradients and input activation gradients given the input and labels
`void`	`clear()` Clear the inputs.
`void`	`clearLayerMaskArrays()` Remove the mask arrays from all layers. See `setLayerMaskArrays(INDArray, INDArray)` for details on mask arrays.
`protected void`	`clearLayersStates()` This method just makes sure there's no state preserved within layers
`void`	`clearNoiseWeightParams()`
`MultiLayerNetwork`	`clone()` Clones the multilayernetwork
`void`	`computeGradientAndScore()`
`void`	`computeGradientAndScore(LayerWorkspaceMgr layerWorkspaceMgr)` Update the score
`NeuralNetConfiguration`	`conf()` The configuration for the neural network
`<T extends IEvaluation> T[]`	`doEvaluation(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, T... evaluations)` Perform evaluation using an arbitrary IEvaluation instance.
`<T extends IEvaluation> T[]`	`doEvaluation(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator, T[] evaluations)` This method executes evaluation of the model against given iterator and evaluation implementations
`protected void`	`doTruncatedBPTT(org.nd4j.linalg.api.ndarray.INDArray input, org.nd4j.linalg.api.ndarray.INDArray labels, org.nd4j.linalg.api.ndarray.INDArray featuresMaskArray, org.nd4j.linalg.api.ndarray.INDArray labelsMaskArray, LayerWorkspaceMgr workspaceMgr)`
`boolean`	`equals(Object obj)` Indicates whether some other object is "equal to" this one.
`Evaluation`	`evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)` Evaluate the network (classification performance)
`Evaluation`	`evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, List<String> labelsList)` Evaluate the network on the provided data set.
`Evaluation`	`evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, List<String> labelsList, int topN)` Evaluate the network (for classification) on the provided data set, with top N accuracy in addition to standard accuracy.
`RegressionEvaluation`	`evaluateRegression(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)` Evaluate the network for regression performance
`ROC`	`evaluateROC(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)` Evaluate the network (must be a binary classifier) on the specified data, using the `ROC` class.
`ROC`	`evaluateROC(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, int rocThresholdSteps)` Evaluate the network (must be a binary classifier) on the specified data, using the `ROC` class
`ROCMultiClass`	`evaluateROCMultiClass(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)` Evaluate the network on the specified data, using the `ROCMultiClass` class.
`ROCMultiClass`	`evaluateROCMultiClass(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, int rocThresholdSteps)` Evaluate the network on the specified data, using the `ROCMultiClass` class
`double`	`f1Score(org.nd4j.linalg.dataset.api.DataSet data)` Sets the input and labels and returns a score for the prediction wrt true labels
`double`	`f1Score(org.nd4j.linalg.api.ndarray.INDArray input, org.nd4j.linalg.api.ndarray.INDArray labels)` Sets the input and labels and returns a score for the prediction wrt true labels
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward()` Compute activations from input to output of the output layer
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(boolean train)` Compute activations from input to output of the output layer
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(boolean train, boolean clearInputs)` Perform feed-forward, optionally (not) clearing the layer input arrays. Note: this method should NOT be used with clearInputs = true, unless you know what you are doing.
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(org.nd4j.linalg.api.ndarray.INDArray input)` Compute activations from input to output of the output layer
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(org.nd4j.linalg.api.ndarray.INDArray input, boolean train)` Compute activations from input to output of the output layer
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(org.nd4j.linalg.api.ndarray.INDArray input, org.nd4j.linalg.api.ndarray.INDArray featuresMask, org.nd4j.linalg.api.ndarray.INDArray labelsMask)` Compute the activations from the input to the output layer, given mask arrays (that may be null) The masking arrays are used in situations such an one-to-many and many-to-one rucerrent neural network (RNN) designs, as well as for supporting time series of varying lengths within the same minibatch for RNNs.
`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.
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForwardToLayer(int layerNum, boolean train)` Compute the activations from the input to the specified layer, using the currently set input for the network. To compute activations for all layers, use feedForward(...) methods Note: output list includes the original input.
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForwardToLayer(int layerNum, org.nd4j.linalg.api.ndarray.INDArray input)` Compute the activations from the input to the specified layer. To compute activations for all layers, use feedForward(...) methods Note: output list includes the original input.
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForwardToLayer(int layerNum, org.nd4j.linalg.api.ndarray.INDArray input, boolean train)` Compute the activations from the input to the specified layer. To compute activations for all layers, use feedForward(...) methods Note: output list includes the original input.
`protected List<org.nd4j.linalg.api.ndarray.INDArray>`	`ffToLayerActivationsDetached(boolean train, FwdPassType fwdPassType, boolean storeLastForTBPTT, int layerIndex, org.nd4j.linalg.api.ndarray.INDArray input, org.nd4j.linalg.api.ndarray.INDArray fMask, org.nd4j.linalg.api.ndarray.INDArray lMask, boolean clearInputs)` Feed-forward through the network - returning all array activations in a list, detached from any workspace.
`protected List<org.nd4j.linalg.api.ndarray.INDArray>`	`ffToLayerActivationsInWs(int layerIndex, FwdPassType fwdPassType, boolean storeLastForTBPTT, org.nd4j.linalg.api.ndarray.INDArray input, org.nd4j.linalg.api.ndarray.INDArray fMask, org.nd4j.linalg.api.ndarray.INDArray lMask)` Feed-forward through the network at training time - returning a list of all activations in a workspace (WS_ALL_LAYERS_ACT) if workspaces are enabled for training; or detached if no workspaces are used. Note: if using workspaces for training, this method requires that WS_ALL_LAYERS_ACT is open externally. If using NO workspaces, requires that no external workspace is open Note that this method does NOT clear the inputs to each layer - instead, they are in the WS_ALL_LAYERS_ACT workspace for use in later backprop.
`void`	`finetune()` Run SGD based on the given labels
`void`	`fit()` All models have a fit method
`void`	`fit(org.nd4j.linalg.dataset.api.DataSet data)` Fit the model
`void`	`fit(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)` Perform minibatch training on all minibatches in the DataSetIterator. Note that this method does not do layerwise pretraining. For pretraining use method pretrain..
`void`	`fit(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, int numEpochs)` Perform minibatch training on all minibatches in the DataSetIterator, for the specified number of epochs.
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray data, org.nd4j.linalg.api.ndarray.INDArray labels)` Fit the model
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray features, org.nd4j.linalg.api.ndarray.INDArray labels, org.nd4j.linalg.api.ndarray.INDArray featuresMask, org.nd4j.linalg.api.ndarray.INDArray labelsMask)` Fit the model
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray examples, int[] labels)` Fit the model
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray data, LayerWorkspaceMgr workspaceMgr)` Fit the model to the given data
`void`	`fit(org.nd4j.linalg.dataset.api.MultiDataSet dataSet)` This method fits model with a given MultiDataSet
`void`	`fit(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator)` Perform minibatch training on all minibatches in the MultiDataSetIterator. Note: The MultiDataSets in the MultiDataSetIterator must have exactly 1 input and output array (as MultiLayerNetwork only supports 1 input and 1 output)
`void`	`fit(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator, int numEpochs)` Perform minibatch training on all minibatches in the MultiDataSetIterator, for the specified number of epochs.
`NeuralNetConfiguration`	`getDefaultConfiguration()`
`int`	`getEpochCount()`
`org.nd4j.linalg.api.ndarray.INDArray`	`getGradientsViewArray()`
`int`	`getIndex()` Get the layer index.
`org.nd4j.linalg.api.ndarray.INDArray`	`getInput()`
`int`	`getInputMiniBatchSize()` Get current/last input mini-batch size, as set by setInputMiniBatchSize(int)
`int`	`getIterationCount()`
`org.nd4j.linalg.api.ndarray.INDArray`	`getLabels()`
`long`	`getLastEtlTime()`
`Layer`	`getLayer(int i)`
`Layer`	`getLayer(String name)`
`List<String>`	`getLayerNames()`
`Layer[]`	`getLayers()`
`MultiLayerConfiguration`	`getLayerWiseConfigurations()`
`Collection<TrainingListener>`	`getListeners()` Get the iteration listeners for this layer.
`org.nd4j.linalg.api.ndarray.INDArray`	`getMask()`
`org.nd4j.linalg.api.ndarray.INDArray`	`getMaskArray()`
`int`	`getnLayers()` Get the number of layers in the network
`ConvexOptimizer`	`getOptimizer()` Returns this models optimizer
`Layer`	`getOutputLayer()` Get the output layer
`org.nd4j.linalg.api.ndarray.INDArray`	`getParam(String param)` Get the parameter
`Collection<TrainingListener>`	`getTrainingListeners()`
`Updater`	`getUpdater()` Get the updater for this MultiLayerNetwork
`Gradient`	`gradient()` Get the gradient.
`org.nd4j.linalg.primitives.Pair<Gradient,Double>`	`gradientAndScore()` Get the gradient and score
`protected boolean`	`hasAFrozenLayer()`
`void`	`incrementEpochCount()` Increment the epoch count (in the underlying `MultiLayerConfiguration` by 1).
`void`	`init()` Initialize the MultiLayerNetwork.
`void`	`init(org.nd4j.linalg.api.ndarray.INDArray parameters, boolean cloneParametersArray)` Initialize the MultiLayerNetwork, optionally with an existing parameters array.
`void`	`initGradientsView()` This method: initializes the flattened gradients array (used in backprop) and sets the appropriate subset in all layers.
`void`	`initParams()` Initialize the parameters
`org.nd4j.linalg.api.ndarray.INDArray`	`input()` The input/feature matrix for the model
`protected void`	`intializeConfigurations()`
`boolean`	`isInitCalled()`
`boolean`	`isPretrainLayer()` Returns true if the layer can be trained in an unsupervised/pretrain manner (AE, VAE, etc)
`org.nd4j.linalg.api.ndarray.INDArray`	`labelProbabilities(org.nd4j.linalg.api.ndarray.INDArray examples)` Returns the probabilities for each label for each example row wise
`int`	`layerInputSize(int layer)` Return the input size (number of inputs) for the specified layer. Note that the meaning of the "input size" can depend on the type of layer.
`int`	`layerSize(int layer)` Return the layer size (number of units) for the specified layer. Note that the meaning of the "layer size" can depend on the type of layer.
`static MultiLayerNetwork`	`load(File f, boolean loadUpdater)` Restore a MultiLayerNetwork to a file, saved using `save(File)` or `ModelSerializer`
`int`	`numLabels()` Returns the number of possible labels
`int`	`numParams()` Returns a 1 x m vector where the vector is composed of a flattened vector of all of the weights for the various neuralNets and output layer
`int`	`numParams(boolean backwards)` the number of parameters for the model
`org.nd4j.linalg.api.ndarray.INDArray`	`output(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)` Generate the output for all examples/batches in the input iterator, and concatenate them into a single array
`org.nd4j.linalg.api.ndarray.INDArray`	`output(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, boolean train)` Generate the output for all examples/batches in the input iterator, and concatenate them into a single array
`org.nd4j.linalg.api.ndarray.INDArray`	`output(org.nd4j.linalg.api.ndarray.INDArray input)` Label the probabilities of the input
`org.nd4j.linalg.api.ndarray.INDArray`	`output(org.nd4j.linalg.api.ndarray.INDArray input, boolean train)` Label the probabilities of the input
`org.nd4j.linalg.api.ndarray.INDArray`	`output(org.nd4j.linalg.api.ndarray.INDArray input, boolean train, org.nd4j.linalg.api.ndarray.INDArray featuresMask, org.nd4j.linalg.api.ndarray.INDArray labelsMask)` Calculate the output of the network, with masking arrays.
`org.nd4j.linalg.api.ndarray.INDArray`	`output(org.nd4j.linalg.api.ndarray.INDArray input, Layer.TrainingMode train)` Label the probabilities of the input
`protected org.nd4j.linalg.api.ndarray.INDArray`	`outputOfLayerDetached(boolean train, FwdPassType fwdPassType, int layerIndex, org.nd4j.linalg.api.ndarray.INDArray input, org.nd4j.linalg.api.ndarray.INDArray featureMask, org.nd4j.linalg.api.ndarray.INDArray labelsMask)` Provide the output of the specified layer, detached from any workspace.
`org.nd4j.linalg.api.ndarray.INDArray`	`params()` Returns a 1 x m vector where the vector is composed of a flattened vector of all of the weights for the various neuralNets(w,hbias NOT VBIAS) and output layer
`org.nd4j.linalg.api.ndarray.INDArray`	`params(boolean backwardOnly)` Returns a 1 x m vector where the vector is composed of a flattened vector of all of the weights for the various neuralNets(w,hbias NOT VBIAS) and output layer
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`paramTable()` The param table
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`paramTable(boolean backpropParamsOnly)` Table of parameters by key, for backprop For many models (dense layers, etc) - all parameters are backprop parameters
`List<String>`	`predict(org.nd4j.linalg.dataset.api.DataSet dataSet)` Return predicted label names
`int[]`	`predict(org.nd4j.linalg.api.ndarray.INDArray d)` Returns the predictions for each example in the dataset
`void`	`pretrain(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iter)` Perform layerwise pretraining on all pre-trainable layers in the network (VAEs, Autoencoders, etc) Note that pretraining will be performed on one layer after the other, resetting the DataSetIterator between iterations. For multiple epochs per layer, appropriately wrap the iterator (for example, a MultipleEpochsIterator) or train each layer manually using `pretrainLayer(int, DataSetIterator)`
`void`	`pretrainLayer(int layerIdx, org.nd4j.linalg.dataset.api.iterator.DataSetIterator iter)` Perform layerwise unsupervised training on a single pre-trainable layer in the network (VAEs, Autoencoders, etc) If the specified layer index (0 to numLayers - 1) is not a pretrainable layer, this is a no-op.
`void`	`pretrainLayer(int layerIdx, org.nd4j.linalg.api.ndarray.INDArray features)` Perform layerwise unsupervised training on a single pre-trainable layer in the network (VAEs, Autoencoders, etc) If the specified layer index (0 to numLayers - 1) is not a pretrainable layer, this is a no-op.
`void`	`printConfiguration()` Prints the configuration
`org.nd4j.linalg.api.ndarray.INDArray`	`reconstruct(org.nd4j.linalg.api.ndarray.INDArray x, int layerNum)` Reconstructs the input.
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`rnnActivateUsingStoredState(org.nd4j.linalg.api.ndarray.INDArray input, boolean training, boolean storeLastForTBPTT)` Similar to rnnTimeStep and feedForward() methods.
`void`	`rnnClearPreviousState()` Clear the previous state of the RNN layers (if any).
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`rnnGetPreviousState(int layer)` Get the state of the RNN layer, as used in rnnTimeStep().
`void`	`rnnSetPreviousState(int layer, Map<String,org.nd4j.linalg.api.ndarray.INDArray> state)` Set the state of the RNN layer.
`org.nd4j.linalg.api.ndarray.INDArray`	`rnnTimeStep(org.nd4j.linalg.api.ndarray.INDArray input)` If this MultiLayerNetwork contains one or more RNN layers: conduct forward pass (prediction) but using previous stored state for any RNN layers.
`void`	`save(File f)` Save the MultiLayerNetwork to a file.
`void`	`save(File f, boolean saveUpdater)` Save the MultiLayerNetwork to a file.
`double`	`score()` Score of the model (relative to the objective function)
`double`	`score(org.nd4j.linalg.dataset.DataSet data)` Sets the input and labels and returns a score for the prediction with respect to the true labels This is equivalent to `score(DataSet, boolean)` with training==false.
`double`	`score(org.nd4j.linalg.dataset.DataSet data, boolean training)` Calculate the score (loss function) of the prediction with respect to the true labels
`org.nd4j.linalg.api.ndarray.INDArray`	`scoreExamples(org.nd4j.linalg.dataset.DataSet data, boolean addRegularizationTerms)` Calculate the score for each example in a DataSet individually.
`org.nd4j.linalg.api.ndarray.INDArray`	`scoreExamples(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iter, boolean addRegularizationTerms)`
`void`	`setBackpropGradientsViewArray(org.nd4j.linalg.api.ndarray.INDArray gradients)` Set the gradients array as a view of the full (backprop) network parameters NOTE: this is intended to be used internally in MultiLayerNetwork and ComputationGraph, not by users.
`void`	`setCacheMode(CacheMode mode)` This method sets specified CacheMode for all layers within network
`void`	`setConf(NeuralNetConfiguration conf)` Setter for the configuration
`void`	`setEpochCount(int epochCount)` Set the current epoch count (number of epochs passed ) for the layer/network
`void`	`setGradientsAccumulator(GradientsAccumulator accumulator)` This method allows you to specificy GradientsAccumulator instance to be used with this model PLEASE NOTE: Do not use this method unless you understand how to use GradientsAccumulator & updates sharing.
`void`	`setIndex(int index)` Set the layer index.
`void`	`setInput(org.nd4j.linalg.api.ndarray.INDArray input)` Note that if input isn't null and the neuralNets are null, this is a way of initializing the neural network
`void`	`setInput(org.nd4j.linalg.api.ndarray.INDArray input, LayerWorkspaceMgr mgr)` 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`	`setLabels(org.nd4j.linalg.api.ndarray.INDArray labels)`
`void`	`setLastEtlTime(long time)`
`void`	`setLayerMaskArrays(org.nd4j.linalg.api.ndarray.INDArray featuresMaskArray, org.nd4j.linalg.api.ndarray.INDArray labelsMaskArray)` Set the mask arrays for features and labels.
`void`	`setLayers(Layer[] layers)`
`void`	`setLayerWiseConfigurations(MultiLayerConfiguration layerWiseConfigurations)`
`void`	`setLearningRate(double newLr)` Set the learning rate for all layers in the network to the specified value.
`void`	`setLearningRate(int layerNumber, double newLr)` Set the learning rate for a single layer in the network to the specified value.
`void`	`setLearningRate(int layerNumber, org.nd4j.linalg.schedule.ISchedule newLr)` Set the learning rate schedule for a single layer in the network to the specified value. Note also that `setLearningRate(ISchedule)` should also be used in preference, when all layers need to be set to a new LR schedule. This schedule will replace any/all existing schedules, and also any fixed learning rate values. Note also that the iteration/epoch counts will not be reset.
`void`	`setLearningRate(org.nd4j.linalg.schedule.ISchedule newLr)` Set the learning rate schedule for all layers in the network to the specified schedule.
`void`	`setListeners(Collection<TrainingListener> listeners)` Set the trainingListeners for the ComputationGraph (and all layers in the network)
`void`	`setListeners(TrainingListener... listeners)` Set the trainingListeners for the ComputationGraph (and all layers in the network)
`void`	`setMask(org.nd4j.linalg.api.ndarray.INDArray mask)`
`void`	`setMaskArray(org.nd4j.linalg.api.ndarray.INDArray maskArray)` Set the mask array.
`void`	`setParam(String key, org.nd4j.linalg.api.ndarray.INDArray val)` Set the parameter with a new ndarray
`void`	`setParameters(org.nd4j.linalg.api.ndarray.INDArray params)` Sets parameters for the model.
`void`	`setParams(org.nd4j.linalg.api.ndarray.INDArray params)` Set the parameters for this model.
`void`	`setParamsViewArray(org.nd4j.linalg.api.ndarray.INDArray params)` Set the initial parameters array as a view of the full (backprop) network parameters NOTE: this is intended to be used internally in MultiLayerNetwork and ComputationGraph, not by users.
`void`	`setParamTable(Map<String,org.nd4j.linalg.api.ndarray.INDArray> paramTable)` Setter for the param table
`void`	`setScore(double score)`
`void`	`setUpdater(Updater updater)` Set the updater for the MultiLayerNetwork
`String`	`summary()` String detailing the architecture of the multilayernetwork.
`String`	`summary(InputType inputType)` String detailing the architecture of the multilayernetwork.
`protected void`	`synchronizeIterEpochCounts()`
`ComputationGraph`	`toComputationGraph()` Convert this MultiLayerNetwork to a ComputationGraph
`Layer`	`transpose()` Return a transposed copy of the weights/bias (this means reverse the number of inputs and outputs on the weights)
`Layer.Type`	`type()` Returns the layer type
`void`	`update(Gradient gradient)` Update layer weights and biases with gradient change
`void`	`update(org.nd4j.linalg.api.ndarray.INDArray gradient, String paramType)` Perform one update applying the gradient
`void`	`update(MultiLayerNetwork network)` Assigns the parameters of this model to the ones specified by this network.
`protected void`	`update(org.nd4j.linalg.heartbeat.reports.Task task)`
`void`	`updateRnnStateWithTBPTTState()`
`org.nd4j.linalg.api.ndarray.INDArray`	`updaterState()` This method returns updater state (if applicable), null otherwise
`protected void`	`validateArrayWorkspaces(LayerWorkspaceMgr mgr, org.nd4j.linalg.api.ndarray.INDArray array, ArrayType arrayType, int layerIdx, boolean isPreprocessor, String op)`
`void`	`validateInput()` Validate the input

Methods inherited from class java.lang.Object
finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - layers
```
protected Layer[] layers
```
  - layerMap
```
protected LinkedHashMap<String,Layer> layerMap
```
  - input
```
protected org.nd4j.linalg.api.ndarray.INDArray input
```
  - labels
```
protected org.nd4j.linalg.api.ndarray.INDArray labels
```
  - initCalled
```
protected boolean initCalled
```
  - trainingListeners
```
protected Collection<TrainingListener> trainingListeners
```
  - defaultConfiguration
```
protected NeuralNetConfiguration defaultConfiguration
```
  - layerWiseConfigurations
```
protected MultiLayerConfiguration layerWiseConfigurations
```
  - gradient
```
protected Gradient gradient
```
  - score
```
protected double score
```
  - initDone
```
protected boolean initDone
```
  - flattenedParams
```
protected org.nd4j.linalg.api.ndarray.INDArray flattenedParams
```
  - flattenedGradients
```
protected transient org.nd4j.linalg.api.ndarray.INDArray flattenedGradients
```
  - clearTbpttState
```
protected boolean clearTbpttState
```
  - lastEtlTime
```
protected transient ThreadLocal<Long> lastEtlTime
```
  - mask
```
protected org.nd4j.linalg.api.ndarray.INDArray mask
```
  - layerIndex
```
protected int layerIndex
```
  - solver
```
protected transient Solver solver
```
  - WS_LAYER_WORKING_MEM
```
protected static final String WS_LAYER_WORKING_MEM
```
    Workspace for working memory for a single layer: forward pass and backward pass Note that this is opened/closed once per op (activate/backpropGradient call)
    
    See Also:
    
    Constant Field Values
  - WS_ALL_LAYERS_ACT
```
protected static final String WS_ALL_LAYERS_ACT
```
    Workspace for storing all layers' activations - used only to store activations (layer inputs) as part of backprop Not used for inference
    
    See Also:
    
    Constant Field Values
  - WS_LAYER_ACT_1
```
protected static final String WS_LAYER_ACT_1
```
    Next 2 workspaces: used for: (a) Inference: holds activations for one layer only (b) Backprop: holds activation gradients for one layer only In both cases, they are opened and closed on every second layer
    
    See Also:
    
    Constant Field Values
  - WS_LAYER_ACT_2
```
protected static final String WS_LAYER_ACT_2
```
    See Also:
    
    Constant Field Values
  - WS_RNN_LOOP_WORKING_MEM
```
protected static final String WS_RNN_LOOP_WORKING_MEM
```
    Workspace for working memory in RNNs - opened and closed once per RNN time step
    
    See Also:
    
    Constant Field Values
  - WS_LAYER_WORKING_MEM_CONFIG
```
protected final org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration WS_LAYER_WORKING_MEM_CONFIG
```
  - WS_ALL_LAYERS_ACT_CONFIG
```
protected static final org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration WS_ALL_LAYERS_ACT_CONFIG
```
  - WS_LAYER_ACT_X_CONFIG
```
protected final org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration WS_LAYER_ACT_X_CONFIG
```
  - WS_RNN_LOOP_WORKING_MEM_CONFIG
```
protected static final org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration WS_RNN_LOOP_WORKING_MEM_CONFIG
```
- Constructor Detail
  - MultiLayerNetwork
```
public MultiLayerNetwork(MultiLayerConfiguration conf)
```
  - MultiLayerNetwork
```
public MultiLayerNetwork(String conf,
                         org.nd4j.linalg.api.ndarray.INDArray params)
```
    Initialize the network based on the configuration
    
    Parameters:
    
    conf - the configuration json
    
    params - the parameters
  - MultiLayerNetwork
```
public MultiLayerNetwork(MultiLayerConfiguration conf,
                         org.nd4j.linalg.api.ndarray.INDArray params)
```
    Initialize the network based on the configuraiton
    
    Parameters:
    
    conf - the configuration
    
    params - the parameters
- Method Detail
  - setCacheMode
```
public void setCacheMode(CacheMode mode)
```
    This method sets specified CacheMode for all layers within network
    
    Specified by:
    
    setCacheMode in interface Layer
    
    Parameters:
    
    mode -
  - setLastEtlTime
```
public void setLastEtlTime(long time)
```
  - getLastEtlTime
```
public long getLastEtlTime()
```
  - intializeConfigurations
```
protected void intializeConfigurations()
```
  - pretrain
```
public void pretrain(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iter)
```
    Perform layerwise pretraining on all pre-trainable layers in the network (VAEs, Autoencoders, etc)
    Note that pretraining will be performed on one layer after the other, resetting the DataSetIterator between iterations.
    For multiple epochs per layer, appropriately wrap the iterator (for example, a MultipleEpochsIterator) or train each layer manually using pretrainLayer(int, DataSetIterator)
    
    Parameters:
    
    iter - Training data
  - pretrainLayer
```
public void pretrainLayer(int layerIdx,
                          org.nd4j.linalg.dataset.api.iterator.DataSetIterator iter)
```
    Perform layerwise unsupervised training on a single pre-trainable layer in the network (VAEs, Autoencoders, etc)
    If the specified layer index (0 to numLayers - 1) is not a pretrainable layer, this is a no-op.
    
    Parameters:
    
    layerIdx - Index of the layer to train (0 to numLayers-1)
    
    iter - Training data
  - pretrainLayer
```
public void pretrainLayer(int layerIdx,
                          org.nd4j.linalg.api.ndarray.INDArray features)
```
    Perform layerwise unsupervised training on a single pre-trainable layer in the network (VAEs, Autoencoders, etc)
    If the specified layer index (0 to numLayers - 1) is not a pretrainable layer, this is a no-op.
    
    Parameters:
    
    layerIdx - Index of the layer to train (0 to numLayers-1)
    
    features - Training data array
  - batchSize
```
public int batchSize()
```
    Description copied from interface: Model
    
    The current inputs batch size
    
    Specified by:
    
    batchSize in interface Model
    
    Returns:
    
    the current inputs batch size
  - conf
```
public NeuralNetConfiguration conf()
```
    Description copied from interface: Model
    
    The configuration for the neural network
    
    Specified by:
    
    conf in interface Model
    
    Returns:
    
    the configuration for the neural network
  - setConf
```
public void setConf(NeuralNetConfiguration conf)
```
    Description copied from interface: Model
    
    Setter for the configuration
    
    Specified by:
    
    setConf in interface Model
  - input
```
public org.nd4j.linalg.api.ndarray.INDArray input()
```
    Description copied from interface: Model
    
    The input/feature matrix for the model
    
    Specified by:
    
    input in interface Model
    
    Returns:
    
    the input/feature matrix for the model
  - validateInput
```
public void validateInput()
```
    Description copied from interface: Model
    
    Validate the input
    
    Specified by:
    
    validateInput in interface Model
  - getOptimizer
```
public ConvexOptimizer getOptimizer()
```
    Description copied from interface: Model
    
    Returns this models optimizer
    
    Specified by:
    
    getOptimizer in interface Model
    
    Specified by:
    
    getOptimizer in interface NeuralNetwork
    
    Returns:
    
    this models optimizer
  - getParam
```
public org.nd4j.linalg.api.ndarray.INDArray getParam(String param)
```
    Description copied from interface: Model
    
    Get the parameter
    
    Specified by:
    
    getParam in interface Model
    
    Parameters:
    
    param - the key of the parameter
    
    Returns:
    
    the parameter vector/matrix with that particular key
  - initParams
```
public void initParams()
```
    Description copied from interface: Model
    
    Initialize the parameters
    
    Specified by:
    
    initParams in interface Model
  - paramTable
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> paramTable()
```
    Description copied from interface: Model
    
    The param table
    
    Specified by:
    
    paramTable in interface Model
    
    Returns:
  - paramTable
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> paramTable(boolean backpropParamsOnly)
```
    Description copied from interface: Model
    
    Table of parameters by key, for backprop For many models (dense layers, etc) - all parameters are backprop parameters
    
    Specified by:
    
    paramTable in interface Model
    
    Parameters:
    
    backpropParamsOnly - If true, return backprop params only. If false: return all params (equivalent to paramsTable())
  - setParamTable
```
public void setParamTable(Map<String,org.nd4j.linalg.api.ndarray.INDArray> paramTable)
```
    Description copied from interface: Model
    
    Setter for the param table
    
    Specified by:
    
    setParamTable in interface Model
  - setParam
```
public void setParam(String key,
                     org.nd4j.linalg.api.ndarray.INDArray val)
```
    Description copied from interface: Model
    
    Set the parameter with a new ndarray
    
    Specified by:
    
    setParam in interface Model
    
    Parameters:
    
    key - the key to se t
    
    val - the new ndarray
  - getLayerWiseConfigurations
```
public MultiLayerConfiguration getLayerWiseConfigurations()
```
  - setLayerWiseConfigurations
```
public void setLayerWiseConfigurations(MultiLayerConfiguration layerWiseConfigurations)
```
  - init
```
public void init()
```
    Initialize the MultiLayerNetwork. This should be called once before the network is used. This is functionally equivalent to calling init(null, false).
    
    Specified by:
    
    init in interface Model
    
    Specified by:
    
    init in interface NeuralNetwork
    
    See Also:
    
    init(INDArray, boolean)
  - init
```
public void init(org.nd4j.linalg.api.ndarray.INDArray parameters,
                 boolean cloneParametersArray)
```
    Initialize the MultiLayerNetwork, optionally with an existing parameters array. If an existing parameters array is specified, it will be used (and the values will not be modified) in the network; if no parameters array is specified, parameters will be initialized randomly according to the network configuration.
    
    Parameters:
    
    parameters - Network parameter. May be null. If null: randomly initialize.
    
    cloneParametersArray - Whether the parameter array (if any) should be cloned, or used directly
  - setGradientsAccumulator
```
public void setGradientsAccumulator(GradientsAccumulator accumulator)
```
    This method allows you to specificy GradientsAccumulator instance to be used with this model PLEASE NOTE: Do not use this method unless you understand how to use GradientsAccumulator & updates sharing. PLEASE NOTE: Do not use this method on standalone model
    
    Parameters:
    
    accumulator -
  - isInitCalled
```
public boolean isInitCalled()
```
  - initGradientsView
```
public void initGradientsView()
```
    This method: initializes the flattened gradients array (used in backprop) and sets the appropriate subset in all layers. As a general rule, this shouldn't ever need to be called manually when doing training via fit(DataSet) or fit(DataSetIterator)
  - activate
```
@Deprecated
public org.nd4j.linalg.api.ndarray.INDArray activate(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Deprecated. Use output(INDArray)
  - activationFromPrevLayer
```
public org.nd4j.linalg.api.ndarray.INDArray activationFromPrevLayer(int curr,
                                                                    org.nd4j.linalg.api.ndarray.INDArray input,
                                                                    boolean training,
                                                                    LayerWorkspaceMgr mgr)
```
  - activateSelectedLayers
```
public org.nd4j.linalg.api.ndarray.INDArray activateSelectedLayers(int from,
                                                                   int to,
                                                                   org.nd4j.linalg.api.ndarray.INDArray input)
```
    Calculate activation for few layers at once. Suitable for autoencoder partial activation. In example: in 10-layer deep autoencoder, layers 0 - 4 inclusive are used for encoding part, and layers 5-9 inclusive are used for decoding part.
    
    Parameters:
    
    from - first layer to be activated, inclusive
    
    to - last layer to be activated, inclusive
    
    Returns:
    
    the activation from the last layer
  - feedForward
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForward(org.nd4j.linalg.api.ndarray.INDArray input,
                                                              boolean train)
```
    Compute activations from input to output of the output layer
    
    Returns:
    
    the list of activations for each layer
  - feedForward
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForward(boolean train)
```
    Compute activations from input to output of the output layer
    
    Returns:
    
    the list of activations for each layer
  - feedForward
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForward(boolean train,
                                                              boolean clearInputs)
```
    Perform feed-forward, optionally (not) clearing the layer input arrays.
    Note: this method should NOT be used with clearInputs = true, unless you know what you are doing. Specifically: when using clearInputs=false, in combination with workspaces, the layer input fields may leak outside of the workspaces in which they were defined - potentially causing a crash. See https://deeplearning4j.org/workspaces for more details
    
    Parameters:
    
    train - training mode
    
    clearInputs - If false: don't clear the layer inputs
    
    Returns:
    
    Activations from feed-forward
  - feedForwardToLayer
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForwardToLayer(int layerNum,
                                                                     org.nd4j.linalg.api.ndarray.INDArray input)
```
    Compute the activations from the input to the specified layer.
    To compute activations for all layers, use feedForward(...) methods
    Note: output list includes the original input. So list.get(0) is always the original input, and list.get(i+1) is the activations of the ith layer.
    
    Parameters:
    
    layerNum - Index of the last layer to calculate activations for. Layers are zero-indexed. feedForwardToLayer(i,input) will return the activations for layers 0..i (inclusive)
    
    input - Input to the network
    
    Returns:
    
    list of activations.
  - feedForwardToLayer
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForwardToLayer(int layerNum,
                                                                     org.nd4j.linalg.api.ndarray.INDArray input,
                                                                     boolean train)
```
    Compute the activations from the input to the specified layer.
    To compute activations for all layers, use feedForward(...) methods
    Note: output list includes the original input. So list.get(0) is always the original input, and list.get(i+1) is the activations of the ith layer.
    
    Parameters:
    
    layerNum - Index of the last layer to calculate activations for. Layers are zero-indexed. feedForwardToLayer(i,input) will return the activations for layers 0..i (inclusive)
    
    input - Input to the network
    
    train - true for training, false for test (i.e., false if using network after training)
    
    Returns:
    
    list of activations.
  - feedForwardToLayer
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForwardToLayer(int layerNum,
                                                                     boolean train)
```
    Compute the activations from the input to the specified layer, using the currently set input for the network.
    To compute activations for all layers, use feedForward(...) methods
    Note: output list includes the original input. So list.get(0) is always the original input, and list.get(i+1) is the activations of the ith layer.
    
    Parameters:
    
    layerNum - Index of the last layer to calculate activations for. Layers are zero-indexed. feedForwardToLayer(i,input) will return the activations for layers 0..i (inclusive)
    
    train - true for training, false for test (i.e., false if using network after training)
    
    Returns:
    
    list of activations.
  - validateArrayWorkspaces
```
protected void validateArrayWorkspaces(LayerWorkspaceMgr mgr,
                                       org.nd4j.linalg.api.ndarray.INDArray array,
                                       ArrayType arrayType,
                                       int layerIdx,
                                       boolean isPreprocessor,
                                       String op)
```
  - ffToLayerActivationsDetached
```
protected List<org.nd4j.linalg.api.ndarray.INDArray> ffToLayerActivationsDetached(boolean train,
                                                                                  @NonNull
                                                                                  FwdPassType fwdPassType,
                                                                                  boolean storeLastForTBPTT,
                                                                                  int layerIndex,
                                                                                  @NonNull
                                                                                  org.nd4j.linalg.api.ndarray.INDArray input,
                                                                                  org.nd4j.linalg.api.ndarray.INDArray fMask,
                                                                                  org.nd4j.linalg.api.ndarray.INDArray lMask,
                                                                                  boolean clearInputs)
```
    Feed-forward through the network - returning all array activations in a list, detached from any workspace. Note that no workspace should be active externally when calling this method (an exception will be thrown if a workspace is open externally)
    
    Parameters:
    
    train - Training mode (true) or test/inference mode (false)
    
    fwdPassType - Type of forward pass to perform (STANDARD or RNN_ACTIVATE_WITH_STORED_STATE only)
    
    storeLastForTBPTT - ONLY used if fwdPassType == FwdPassType.RNN_ACTIVATE_WITH_STORED_STATE
    
    layerIndex - Index (inclusive) to stop forward pass at. For all layers, use numLayers-1
    
    input - Input to the network
    
    fMask - Feature mask array. May be null.
    
    lMask - Label mask array. May be null.
    
    clearInputs - Whether the layer inputs should be cleared
    
    Returns:
    
    List of activations (including the input), detached from any workspace
  - ffToLayerActivationsInWs
```
protected List<org.nd4j.linalg.api.ndarray.INDArray> ffToLayerActivationsInWs(int layerIndex,
                                                                              @NonNull
                                                                              FwdPassType fwdPassType,
                                                                              boolean storeLastForTBPTT,
                                                                              @NonNull
                                                                              org.nd4j.linalg.api.ndarray.INDArray input,
                                                                              org.nd4j.linalg.api.ndarray.INDArray fMask,
                                                                              org.nd4j.linalg.api.ndarray.INDArray lMask)
```
    Feed-forward through the network at training time - returning a list of all activations in a workspace (WS_ALL_LAYERS_ACT) if workspaces are enabled for training; or detached if no workspaces are used.
    Note: if using workspaces for training, this method requires that WS_ALL_LAYERS_ACT is open externally.
    If using NO workspaces, requires that no external workspace is open
    Note that this method does NOT clear the inputs to each layer - instead, they are in the WS_ALL_LAYERS_ACT workspace for use in later backprop.
    
    Parameters:
    
    layerIndex - Index (inclusive) to stop forward pass at. For all layers, use numLayers-1
    
    fwdPassType - Type of forward pass to perform (STANDARD or RNN_ACTIVATE_WITH_STORED_STATE only)
    
    storeLastForTBPTT - ONLY used if fwdPassType == FwdPassType.RNN_ACTIVATE_WITH_STORED_STATE
    
    input - Input to network
    
    fMask - Feature mask array. May be null
    
    lMask - Label mask aray. May be null.
    
    Returns:
  - outputOfLayerDetached
```
protected org.nd4j.linalg.api.ndarray.INDArray outputOfLayerDetached(boolean train,
                                                                     @NonNull
                                                                     FwdPassType fwdPassType,
                                                                     int layerIndex,
                                                                     @NonNull
                                                                     org.nd4j.linalg.api.ndarray.INDArray input,
                                                                     org.nd4j.linalg.api.ndarray.INDArray featureMask,
                                                                     org.nd4j.linalg.api.ndarray.INDArray labelsMask)
```
    Provide the output of the specified layer, detached from any workspace. This is most commonly used at inference/test time, and is more memory efficient than ffToLayerActivationsDetached(boolean, FwdPassType, boolean, int, INDArray, INDArray, INDArray, boolean) and ffToLayerActivationsInWs(int, FwdPassType, boolean, INDArray, INDArray, INDArray).
    This method clears all layer inputs. NOTE: in general, no workspaces should be activated externally for this method! This method handles the workspace activation as required
    
    Parameters:
    
    train - Training mode (true) or test/inference mode (false)
    
    fwdPassType - Type of forward pass to perform (STANDARD, RNN_TIMESTEP or RNN_ACTIVATE_WITH_STORED_STATE)
    
    layerIndex - Index (inclusive) to stop forward pass at. For all layers, use numLayers-1
    
    input - Input to the network
    
    featureMask - Input/feature mask array. May be null.
    
    labelsMask - Labels mask array. May be null
    
    Returns:
    
    Output of the specified layer, detached from any workspace
  - feedForward
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForward()
```
    Compute activations from input to output of the output layer
    
    Returns:
    
    the list of activations for each layer
  - feedForward
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForward(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Compute activations from input to output of the output layer
    
    Returns:
    
    the list of activations for each layer
  - feedForward
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForward(org.nd4j.linalg.api.ndarray.INDArray input,
                                                              org.nd4j.linalg.api.ndarray.INDArray featuresMask,
                                                              org.nd4j.linalg.api.ndarray.INDArray labelsMask)
```
    Compute the activations from the input to the output layer, given mask arrays (that may be null) The masking arrays are used in situations such an one-to-many and many-to-one rucerrent neural network (RNN) designs, as well as for supporting time series of varying lengths within the same minibatch for RNNs.
  - gradient
```
public Gradient gradient()
```
    Description copied from interface: Model
    
    Get the gradient. Note that this method will not calculate the gradient, it will rather return the gradient that has been computed before. For calculating the gradient, see Model#computeGradientAndScore() .
    
    Specified by:
    
    gradient in interface Model
    
    Returns:
    
    the gradient for this model, as calculated before
  - gradientAndScore
```
public org.nd4j.linalg.primitives.Pair<Gradient,Double> gradientAndScore()
```
    Description copied from interface: Model
    
    Get the gradient and score
    
    Specified by:
    
    gradientAndScore in interface Model
    
    Returns:
    
    the gradient and score
  - clone
```
public MultiLayerNetwork clone()
```
    Clones the multilayernetwork
    
    Specified by:
    
    clone in interface Layer
    
    Overrides:
    
    clone in class Object
    
    Returns:
  - hasAFrozenLayer
```
protected boolean hasAFrozenLayer()
```
  - params
```
public org.nd4j.linalg.api.ndarray.INDArray params(boolean backwardOnly)
```
    Returns a 1 x m vector where the vector is composed of a flattened vector of all of the weights for the various neuralNets(w,hbias NOT VBIAS) and output layer
    
    Returns:
    
    the params for this neural net
  - params
```
public org.nd4j.linalg.api.ndarray.INDArray params()
```
    Returns a 1 x m vector where the vector is composed of a flattened vector of all of the weights for the various neuralNets(w,hbias NOT VBIAS) and output layer
    
    Specified by:
    
    params in interface Model
    
    Specified by:
    
    params in interface NeuralNetwork
    
    Returns:
    
    the params for this neural net
  - setParams
```
public void setParams(org.nd4j.linalg.api.ndarray.INDArray params)
```
    Set the parameters for this model. This expects a linear ndarray which then be unpacked internally relative to the expected ordering of the model
    
    Specified by:
    
    setParams in interface Model
    
    Parameters:
    
    params - the parameters for the model
  - setParamsViewArray
```
public void setParamsViewArray(org.nd4j.linalg.api.ndarray.INDArray params)
```
    Description copied from interface: Model
    
    Set the initial parameters array as a view of the full (backprop) network parameters NOTE: this is intended to be used internally in MultiLayerNetwork and ComputationGraph, not by users.
    
    Specified by:
    
    setParamsViewArray in interface Model
    
    Parameters:
    
    params - a 1 x nParams row vector that is a view of the larger (MLN/CG) parameters array
  - getGradientsViewArray
```
public org.nd4j.linalg.api.ndarray.INDArray getGradientsViewArray()
```
    Specified by:
    
    getGradientsViewArray in interface Model
  - setBackpropGradientsViewArray
```
public void setBackpropGradientsViewArray(org.nd4j.linalg.api.ndarray.INDArray gradients)
```
    Description copied from interface: Model
    
    Set the gradients array as a view of the full (backprop) network parameters NOTE: this is intended to be used internally in MultiLayerNetwork and ComputationGraph, not by users.
    
    Specified by:
    
    setBackpropGradientsViewArray in interface Model
    
    Parameters:
    
    gradients - a 1 x nParams row vector that is a view of the larger (MLN/CG) gradients array
  - numParams
```
public int numParams()
```
    Returns a 1 x m vector where the vector is composed of a flattened vector of all of the weights for the various neuralNets and output layer
    
    Specified by:
    
    numParams in interface Model
    
    Returns:
    
    the params for this neural net
  - numParams
```
public int numParams(boolean backwards)
```
    Description copied from interface: Model
    
    the number of parameters for the model
    
    Specified by:
    
    numParams in interface Model
    
    Returns:
    
    the number of parameters for the model
  - f1Score
```
public double f1Score(org.nd4j.linalg.dataset.api.DataSet data)
```
    Sets the input and labels and returns a score for the prediction wrt true labels
    
    Specified by:
    
    f1Score in interface Classifier
    
    Parameters:
    
    data - the data to score
    
    Returns:
    
    the score for the given input,label pairs
  - fit
```
public void fit(@NonNull
                org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                int numEpochs)
```
    Perform minibatch training on all minibatches in the DataSetIterator, for the specified number of epochs. Equvalent to calling fit(DataSetIterator) numEpochs times in a loop
    
    Parameters:
    
    iterator - Training data (DataSetIterator). Iterator must support resetting
    
    numEpochs - Number of training epochs, >= 1
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)
```
    Perform minibatch training on all minibatches in the DataSetIterator.
    Note that this method does not do layerwise pretraining.
    For pretraining use method pretrain.. pretrain(DataSetIterator)
    
    Specified by:
    
    fit in interface Classifier
    
    Specified by:
    
    fit in interface NeuralNetwork
    
    Parameters:
    
    iterator - Training data (DataSetIterator)
  - calculateGradients
```
public org.nd4j.linalg.primitives.Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray> calculateGradients(@NonNull
                                                                                                         org.nd4j.linalg.api.ndarray.INDArray features,
                                                                                                         @NonNull
                                                                                                         org.nd4j.linalg.api.ndarray.INDArray label,
                                                                                                         org.nd4j.linalg.api.ndarray.INDArray fMask,
                                                                                                         org.nd4j.linalg.api.ndarray.INDArray labelMask)
```
    Calculate parameter gradients and input activation gradients given the input and labels
    
    Parameters:
    
    features - Features for gradient calculation
    
    label - Labels for gradient
    
    fMask - Features mask array (may be null)
    
    labelMask - Label mask array (may be null)
    
    Returns:
    
    A pair of gradient arrays: parameter gradients (in Gradient object) and input activation gradients
  - calcBackpropGradients
```
protected org.nd4j.linalg.primitives.Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray> calcBackpropGradients(org.nd4j.linalg.api.ndarray.INDArray epsilon,
                                                                                                               boolean withOutputLayer,
                                                                                                               boolean tbptt,
                                                                                                               boolean returnInputActGrad)
```
    Calculate gradients and errors. Used in two places: (a) backprop (for standard multi layer network learning) (b) backpropGradient (layer method, for when MultiLayerNetwork is used as a layer)
    
    Parameters:
    
    epsilon - Errors (technically errors .* activations). Not used if withOutputLayer = true
    
    withOutputLayer - if true: assume last layer is output layer, and calculate errors based on labels. In this case, the epsilon input is not used (may/should be null). If false: calculate backprop gradients
    
    returnInputActGrad - If true: terun the input activation gradients (detached). False: don't return
    
    Returns:
    
    Gradients and the error (epsilon) at the input
  - doTruncatedBPTT
```
protected void doTruncatedBPTT(org.nd4j.linalg.api.ndarray.INDArray input,
                               org.nd4j.linalg.api.ndarray.INDArray labels,
                               org.nd4j.linalg.api.ndarray.INDArray featuresMaskArray,
                               org.nd4j.linalg.api.ndarray.INDArray labelsMaskArray,
                               LayerWorkspaceMgr workspaceMgr)
```
  - updateRnnStateWithTBPTTState
```
public void updateRnnStateWithTBPTTState()
```
  - getListeners
```
public Collection<TrainingListener> getListeners()
```
    Description copied from interface: Layer
    
    Get the iteration listeners for this layer.
    
    Specified by:
    
    getListeners in interface Layer
    
    Returns:
    
    listeners
  - getTrainingListeners
```
public Collection<TrainingListener> getTrainingListeners()
```
    Returns:
    
    trainingListeners
  - setListeners
```
public void setListeners(Collection<TrainingListener> listeners)
```
    Description copied from interface: Model
    
    Set the trainingListeners for the ComputationGraph (and all layers in the network)
    
    Specified by:
    
    setListeners in interface Layer
    
    Specified by:
    
    setListeners in interface Model
  - addListeners
```
public void addListeners(TrainingListener... listeners)
```
    This method ADDS additional TrainingListener to existing listeners
    
    Specified by:
    
    addListeners in interface Model
    
    Parameters:
    
    listeners -
  - setListeners
```
public void setListeners(TrainingListener... listeners)
```
    Description copied from interface: Model
    
    Set the trainingListeners for the ComputationGraph (and all layers in the network)
    
    Specified by:
    
    setListeners in interface Layer
    
    Specified by:
    
    setListeners in interface Model
  - finetune
```
public void finetune()
```
    Run SGD based on the given labels
  - predict
```
public int[] predict(org.nd4j.linalg.api.ndarray.INDArray d)
```
    Returns the predictions for each example in the dataset
    
    Specified by:
    
    predict in interface Classifier
    
    Parameters:
    
    d - the matrix to predict
    
    Returns:
    
    the prediction for the dataset
  - predict
```
public List<String> predict(org.nd4j.linalg.dataset.api.DataSet dataSet)
```
    Return predicted label names
    
    Specified by:
    
    predict in interface Classifier
    
    Parameters:
    
    dataSet - to predict
    
    Returns:
    
    the predicted labels for the dataSet
  - labelProbabilities
```
public org.nd4j.linalg.api.ndarray.INDArray labelProbabilities(org.nd4j.linalg.api.ndarray.INDArray examples)
```
    Returns the probabilities for each label for each example row wise
    
    Specified by:
    
    labelProbabilities in interface Classifier
    
    Parameters:
    
    examples - the examples to classify (one example in each row)
    
    Returns:
    
    the likelihoods of each example and each label
  - fit
```
public void fit(org.nd4j.linalg.api.ndarray.INDArray data,
                org.nd4j.linalg.api.ndarray.INDArray labels)
```
    Fit the model
    
    Specified by:
    
    fit in interface Classifier
    
    Parameters:
    
    data - the examples to classify (one example in each row)
    
    labels - the example labels(a binary outcome matrix)
  - fit
```
public void fit(org.nd4j.linalg.api.ndarray.INDArray features,
                org.nd4j.linalg.api.ndarray.INDArray labels,
                org.nd4j.linalg.api.ndarray.INDArray featuresMask,
                org.nd4j.linalg.api.ndarray.INDArray labelsMask)
```
    Fit the model
    
    Parameters:
    
    features - the examples to classify (one example in each row)
    
    labels - the example labels(a binary outcome matrix)
    
    featuresMask - The mask array for the features (used for variable length time series, etc). May be null.
    
    labelsMask - The mask array for the labels (used for variable length time series, etc). May be null.
  - fit
```
public void fit(org.nd4j.linalg.api.ndarray.INDArray data,
                LayerWorkspaceMgr workspaceMgr)
```
    Description copied from interface: Model
    
    Fit the model to the given data
    
    Specified by:
    
    fit in interface Model
    
    Parameters:
    
    data - the data to fit the model to
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.DataSet data)
```
    Fit the model
    
    Specified by:
    
    fit in interface Classifier
    
    Specified by:
    
    fit in interface NeuralNetwork
    
    Parameters:
    
    data - the data to train on
  - fit
```
public void fit(org.nd4j.linalg.api.ndarray.INDArray examples,
                int[] labels)
```
    Fit the model
    
    Specified by:
    
    fit in interface Classifier
    
    Parameters:
    
    examples - the examples to classify (one example in each row)
    
    labels - the labels for each example (the number of labels must match
  - output
```
public org.nd4j.linalg.api.ndarray.INDArray output(org.nd4j.linalg.api.ndarray.INDArray input,
                                                   Layer.TrainingMode train)
```
    Label the probabilities of the input
    
    Parameters:
    
    input - the input to label
    
    train - whether the output is test or train. This mainly affect hyper parameters such as drop out where certain things should be applied with activations
    
    Returns:
    
    a vector of probabilities given each label.
    This is typically of the form: [0.5, 0.5] or some other probability distribution summing to one
  - output
```
public org.nd4j.linalg.api.ndarray.INDArray output(org.nd4j.linalg.api.ndarray.INDArray input,
                                                   boolean train)
```
    Label the probabilities of the input
    
    Parameters:
    
    input - the input to label
    
    train - whether the output is test or train. This mainly affect hyper parameters such as drop out where certain things should be applied with activations
    
    Returns:
    
    a vector of probabilities given each label.
    This is typically of the form: [0.5, 0.5] or some other probability distribution summing to one
  - output
```
public org.nd4j.linalg.api.ndarray.INDArray output(org.nd4j.linalg.api.ndarray.INDArray input,
                                                   boolean train,
                                                   org.nd4j.linalg.api.ndarray.INDArray featuresMask,
                                                   org.nd4j.linalg.api.ndarray.INDArray labelsMask)
```
    Calculate the output of the network, with masking arrays. The masking arrays are used in situations such as one-to-many and many-to-one recurrent neural network (RNN) designs, as well as for supporting time series of varying lengths within the same minibatch.
  - output
```
public org.nd4j.linalg.api.ndarray.INDArray output(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Label the probabilities of the input
    
    Parameters:
    
    input - the input to label
    
    Returns:
    
    a vector of probabilities given each label.
    This is typically of the form: [0.5, 0.5] or some other probability distribution summing to one
  - output
```
public org.nd4j.linalg.api.ndarray.INDArray output(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                                                   boolean train)
```
    Generate the output for all examples/batches in the input iterator, and concatenate them into a single array
    
    Parameters:
    
    iterator - Data to pass through the network
    
    Returns:
    
    output for all examples in the iterator
  - output
```
public org.nd4j.linalg.api.ndarray.INDArray output(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)
```
    Generate the output for all examples/batches in the input iterator, and concatenate them into a single array
    
    Parameters:
    
    iterator - Data to pass through the network
    
    Returns:
    
    output for all examples in the iterator
  - reconstruct
```
public org.nd4j.linalg.api.ndarray.INDArray reconstruct(org.nd4j.linalg.api.ndarray.INDArray x,
                                                        int layerNum)
```
    Reconstructs the input. This is equivalent functionality to a deep autoencoder.
    
    Parameters:
    
    x - the input to transform
    
    layerNum - the layer to output for encoding
    
    Returns:
    
    a reconstructed matrix relative to the size of the last hidden layer. This is great for data compression and visualizing high dimensional data (or just doing dimensionality reduction).
    This is typically of the form: [0.5, 0.5] or some other probability distribution summing to one
  - printConfiguration
```
public void printConfiguration()
```
    Prints the configuration
  - update
```
public void update(MultiLayerNetwork network)
```
    Assigns the parameters of this model to the ones specified by this network. This is used in loading from input streams, factory methods, etc
    
    Parameters:
    
    network - the network to get parameters from
  - f1Score
```
public double f1Score(org.nd4j.linalg.api.ndarray.INDArray input,
                      org.nd4j.linalg.api.ndarray.INDArray labels)
```
    Sets the input and labels and returns a score for the prediction wrt true labels
    
    Specified by:
    
    f1Score in interface Classifier
    
    Parameters:
    
    input - the input to score
    
    labels - the true labels
    
    Returns:
    
    the score for the given input,label pairs
  - numLabels
```
public int numLabels()
```
    Returns the number of possible labels
    
    Specified by:
    
    numLabels in interface Classifier
    
    Returns:
    
    the number of possible labels for this classifier
  - score
```
public double score(org.nd4j.linalg.dataset.DataSet data)
```
    Sets the input and labels and returns a score for the prediction with respect to the true labels
    This is equivalent to score(DataSet, boolean) with training==false.
    
    Parameters:
    
    data - the data to score
    
    Returns:
    
    the score for the given input,label pairs
    
    See Also:
    
    score(DataSet, boolean)
  - score
```
public double score(org.nd4j.linalg.dataset.DataSet data,
                    boolean training)
```
    Calculate the score (loss function) of the prediction with respect to the true labels
    
    Parameters:
    
    data - data to calculate score for
    
    training - If true: score during training. If false: score at test time. This can affect the application of certain features, such as dropout and dropconnect (which are applied at training time only)
    
    Returns:
    
    the score (value of the loss function)
  - scoreExamples
```
public org.nd4j.linalg.api.ndarray.INDArray scoreExamples(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iter,
                                                          boolean addRegularizationTerms)
```
  - scoreExamples
```
public org.nd4j.linalg.api.ndarray.INDArray scoreExamples(org.nd4j.linalg.dataset.DataSet data,
                                                          boolean addRegularizationTerms)
```
    Calculate the score for each example in a DataSet individually. Unlike score(DataSet) and score(DataSet, boolean) this method does not average/sum over examples. This method allows for examples to be scored individually (at test time only), which may be useful for example for autoencoder architectures and the like.
    Each row of the output (assuming addRegularizationTerms == true) is equivalent to calling score(DataSet) with a single example.
    
    Parameters:
    
    data - The data to score
    
    addRegularizationTerms - If true: add l1/l2 regularization terms (if any) to the score. If false: don't add regularization terms
    
    Returns:
    
    An INDArray (column vector) of size input.numRows(); the ith entry is the score (loss value) of the ith example
  - fit
```
public void fit()
```
    Description copied from interface: Model
    
    All models have a fit method
    
    Specified by:
    
    fit in interface Model
  - update
```
public void update(org.nd4j.linalg.api.ndarray.INDArray gradient,
                   String paramType)
```
    Description copied from interface: Model
    
    Perform one update applying the gradient
    
    Specified by:
    
    update in interface Model
    
    Parameters:
    
    gradient - the gradient to apply
  - score
```
public double score()
```
    Score of the model (relative to the objective function)
    
    Specified by:
    
    score in interface Model
    
    Returns:
    
    the score of the model (relative to the objective function)
  - setScore
```
public void setScore(double score)
```
  - computeGradientAndScore
```
public void computeGradientAndScore(LayerWorkspaceMgr layerWorkspaceMgr)
```
    Description copied from interface: Model
    
    Update the score
    
    Specified by:
    
    computeGradientAndScore in interface Model
  - computeGradientAndScore
```
public void computeGradientAndScore()
```
  - accumulateScore
```
public void accumulateScore(double accum)
```
    Description copied from interface: Model
    
    Sets a rolling tally for the score. This is useful for mini batch learning when you are accumulating error across a dataset.
    
    Specified by:
    
    accumulateScore in interface Model
    
    Parameters:
    
    accum - the amount to accum
  - clear
```
public void clear()
```
    Clear the inputs. Clears optimizer state.
    
    Specified by:
    
    clear in interface Model
  - applyConstraints
```
public void applyConstraints(int iteration,
                             int epoch)
```
    Description copied from interface: Model
    
    Apply any constraints to the model
    
    Specified by:
    
    applyConstraints in interface Model
  - setInput
```
public void setInput(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Note that if input isn't null and the neuralNets are null, this is a way of initializing the neural network
    
    Parameters:
    
    input -
  - setInput
```
public void setInput(org.nd4j.linalg.api.ndarray.INDArray input,
                     LayerWorkspaceMgr mgr)
```
    Description copied from interface: Layer
    
    Set the layer input.
    
    Specified by:
    
    setInput in interface Layer
  - getOutputLayer
```
public Layer getOutputLayer()
```
    Get the output layer
    
    Returns:
  - setParameters
```
public void setParameters(org.nd4j.linalg.api.ndarray.INDArray params)
```
    Sets parameters for the model. This is used to manipulate the weights and biases across all neuralNets (including the output layer)
    
    Parameters:
    
    params - a parameter vector equal 1,numParameters
  - getDefaultConfiguration
```
public NeuralNetConfiguration getDefaultConfiguration()
```
  - getLabels
```
public org.nd4j.linalg.api.ndarray.INDArray getLabels()
```
  - getInput
```
public org.nd4j.linalg.api.ndarray.INDArray getInput()
```
  - setLabels
```
public void setLabels(org.nd4j.linalg.api.ndarray.INDArray labels)
```
    Parameters:
    
    labels -
  - getnLayers
```
public int getnLayers()
```
    Get the number of layers in the network
    
    Returns:
    
    the number of layers in the network
  - getLayers
```
public Layer[] getLayers()
```
    Returns:
  - getLayer
```
public Layer getLayer(int i)
```
  - getLayer
```
public Layer getLayer(String name)
```
  - getLayerNames
```
public List<String> getLayerNames()
```
  - setLayers
```
public void setLayers(Layer[] layers)
```
  - getMask
```
public org.nd4j.linalg.api.ndarray.INDArray getMask()
```
  - setMask
```
public void setMask(org.nd4j.linalg.api.ndarray.INDArray mask)
```
  - getMaskArray
```
public org.nd4j.linalg.api.ndarray.INDArray getMaskArray()
```
    Specified by:
    
    getMaskArray in interface Layer
  - 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)
    
    Specified by:
    
    isPretrainLayer in interface Layer
    
    Returns:
    
    true if the layer can be pretrained (using fit(INDArray), false otherwise
  - clearNoiseWeightParams
```
public void clearNoiseWeightParams()
```
    Specified by:
    
    clearNoiseWeightParams in interface Layer
  - 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
    
    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.
  - type
```
public Layer.Type type()
```
    Description copied from interface: Layer
    
    Returns the layer type
    
    Specified by:
    
    type in interface Layer
    
    Returns:
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate(Layer.TrainingMode training)
```
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate(org.nd4j.linalg.api.ndarray.INDArray input,
                                                     Layer.TrainingMode training)
```
  - transpose
```
public Layer transpose()
```
    Description copied from interface: Layer
    
    Return a transposed copy of the weights/bias (this means reverse the number of inputs and outputs on the weights)
    
    Specified by:
    
    transpose in interface Layer
    
    Returns:
    
    the transposed layer
  - 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
    
    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
  - setIndex
```
public void setIndex(int index)
```
    Description copied from interface: Layer
    
    Set the layer index.
    
    Specified by:
    
    setIndex in interface Layer
  - getIndex
```
public int getIndex()
```
    Description copied from interface: Layer
    
    Get the layer index.
    
    Specified by:
    
    getIndex in interface Layer
  - getIterationCount
```
public int getIterationCount()
```
    Specified by:
    
    getIterationCount in interface Layer
    
    Returns:
    
    The current iteration count (number of parameter updates) for the layer/network
  - getEpochCount
```
public int getEpochCount()
```
    Specified by:
    
    getEpochCount in interface Layer
    
    Returns:
    
    The current epoch count (number of training epochs passed) for the layer/network
  - setIterationCount
```
public void setIterationCount(int iterationCount)
```
    Description copied from interface: Layer
    
    Set the current iteration count (number of parameter updates) for the layer/network
    
    Specified by:
    
    setIterationCount in interface Layer
  - setEpochCount
```
public void setEpochCount(int epochCount)
```
    Description copied from interface: Layer
    
    Set the current epoch count (number of epochs passed ) for the layer/network
    
    Specified by:
    
    setEpochCount in interface Layer
  - calcL2
```
public double calcL2(boolean backpropParamsOnly)
```
    Description copied from interface: Layer
    
    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
    
    Specified by:
    
    calcL2 in interface Layer
    
    Parameters:
    
    backpropParamsOnly - 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
```
public double calcL1(boolean backpropParamsOnly)
```
    Description copied from interface: Layer
    
    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
    
    Specified by:
    
    calcL1 in interface Layer
    
    Parameters:
    
    backpropParamsOnly - 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.
  - update
```
public void update(Gradient gradient)
```
    Description copied from interface: Model
    
    Update layer weights and biases with gradient change
    
    Specified by:
    
    update in interface Model
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate(boolean training,
                                                     LayerWorkspaceMgr mgr)
```
    Description copied from interface: Layer
    
    Perform forward pass and return the activations array with the last set input
    
    Specified by:
    
    activate in interface Layer
    
    Parameters:
    
    training - training or test mode
    
    mgr - 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 mgr)
```
    Description copied from interface: Layer
    
    Perform forward pass and return the activations array with the specified input
    
    Specified by:
    
    activate in interface Layer
    
    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
  - setInputMiniBatchSize
```
public void setInputMiniBatchSize(int size)
```
    Description copied from interface: Layer
    
    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.
    
    Specified by:
    
    setInputMiniBatchSize in interface Layer
  - getInputMiniBatchSize
```
public int getInputMiniBatchSize()
```
    Description copied from interface: Layer
    
    Get current/last input mini-batch size, as set by setInputMiniBatchSize(int)
    
    Specified by:
    
    getInputMiniBatchSize in interface Layer
    
    See Also:
    
    Layer.setInputMiniBatchSize(int)
  - setMaskArray
```
public void setMaskArray(org.nd4j.linalg.api.ndarray.INDArray maskArray)
```
    Description copied from interface: Layer
    
    Set the mask array. Note: In general, Layer.feedForwardMaskArray(INDArray, MaskState, int) should be used in preference to this.
    
    Specified by:
    
    setMaskArray in interface Layer
    
    Parameters:
    
    maskArray - Mask array to set
  - rnnTimeStep
```
public org.nd4j.linalg.api.ndarray.INDArray rnnTimeStep(org.nd4j.linalg.api.ndarray.INDArray input)
```
    If this MultiLayerNetwork contains one or more RNN layers: conduct forward pass (prediction) but using previous stored state for any RNN layers. The activations for the final step are also stored in the RNN layers for use next time rnnTimeStep() is called.
    This method can be used to generate output one or more steps at a time instead of always having to do forward pass from t=0. Example uses are for streaming data, and for generating samples from network output one step at a time (where samples are then fed back into the network as input)
    If no previous state is present in RNN layers (i.e., initially or after calling rnnClearPreviousState()), the default initialization (usually 0) is used.
    Supports mini-batch (i.e., multiple predictions/forward pass in parallel) as well as for single examples.
    
    Parameters:
    
    input - Input to network. May be for one or multiple time steps. For single time step: input has shape [miniBatchSize,inputSize] or [miniBatchSize,inputSize,1]. miniBatchSize=1 for single example.
    For multiple time steps: [miniBatchSize,inputSize,inputTimeSeriesLength]
    
    Returns:
    
    Output activations. If output is RNN layer (such as RnnOutputLayer): if input has shape [miniBatchSize,inputSize] i.e., is 2d, output has shape [miniBatchSize,outputSize] (i.e., also 2d).
    Otherwise output is 3d [miniBatchSize,outputSize,inputTimeSeriesLength] when using RnnOutputLayer.
  - rnnGetPreviousState
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> rnnGetPreviousState(int layer)
```
    Get the state of the RNN layer, as used in rnnTimeStep().
    
    Parameters:
    
    layer - Number/index of the layer.
    
    Returns:
    
    Hidden state, or null if layer is not an RNN layer
  - rnnSetPreviousState
```
public void rnnSetPreviousState(int layer,
                                Map<String,org.nd4j.linalg.api.ndarray.INDArray> state)
```
    Set the state of the RNN layer.
    
    Parameters:
    
    layer - The number/index of the layer.
    
    state - The state to set the specified layer to
  - rnnClearPreviousState
```
public void rnnClearPreviousState()
```
    Clear the previous state of the RNN layers (if any).
  - rnnActivateUsingStoredState
```
public List<org.nd4j.linalg.api.ndarray.INDArray> rnnActivateUsingStoredState(org.nd4j.linalg.api.ndarray.INDArray input,
                                                                              boolean training,
                                                                              boolean storeLastForTBPTT)
```
    Similar to rnnTimeStep and feedForward() methods. Difference here is that this method:
    (a) like rnnTimeStep does forward pass using stored state for RNN layers, and
    (b) unlike rnnTimeStep does not modify the RNN layer state
    Therefore multiple calls to this method with the same input should have the same output.
    Typically used during training only. Use rnnTimeStep for prediction/forward pass at test time.
    
    Parameters:
    
    input - Input to network
    
    training - Whether training or not
    
    storeLastForTBPTT - set to true if used as part of truncated BPTT training
    
    Returns:
    
    Activations for each layer (including input, as per feedforward() etc)
  - getUpdater
```
public Updater getUpdater()
```
    Get the updater for this MultiLayerNetwork
    
    Returns:
    
    Updater for MultiLayerNetwork
  - setUpdater
```
public void setUpdater(Updater updater)
```
    Set the updater for the MultiLayerNetwork
  - setLayerMaskArrays
```
public void setLayerMaskArrays(org.nd4j.linalg.api.ndarray.INDArray featuresMaskArray,
                               org.nd4j.linalg.api.ndarray.INDArray labelsMaskArray)
```
    Set the mask arrays for features and labels. Mask arrays are typically used in situations such as one-to-many and many-to-one learning with recurrent neural networks, as well as for supporting time series of varying lengths within the same minibatch.
    For example, with RNN data sets with input of shape [miniBatchSize,nIn,timeSeriesLength] and outputs of shape [miniBatchSize,nOut,timeSeriesLength], the features and mask arrays will have shape [miniBatchSize,timeSeriesLength] and contain values 0 or 1 at each element (to specify whether a given input/example is present - or merely padding - at a given time step).
    NOTE: This method is not usually used directly. Instead, methods such as feedForward(INDArray, INDArray, INDArray) and output(INDArray, boolean, INDArray, INDArray) handle setting of masking internally.
    
    Parameters:
    
    featuresMaskArray - Mask array for features (input)
    
    labelsMaskArray - Mask array for labels (output)
    
    See Also:
    
    clearLayerMaskArrays()
  - clearLayerMaskArrays
```
public void clearLayerMaskArrays()
```
    Remove the mask arrays from all layers.
    See setLayerMaskArrays(INDArray, INDArray) for details on mask arrays.
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)
```
    Evaluate the network (classification performance)
    
    Parameters:
    
    iterator - Iterator to evaluate on
    
    Returns:
    
    Evaluation object; results of evaluation on all examples in the data set
  - evaluateRegression
```
public RegressionEvaluation evaluateRegression(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)
```
    Evaluate the network for regression performance
    
    Parameters:
    
    iterator - Data to evaluate on
    
    Returns:
  - evaluateROC
```
public ROC evaluateROC(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)
```
    Evaluate the network (must be a binary classifier) on the specified data, using the ROC class. Defaults to exact mode for ROC instead of thresholded
    
    Parameters:
    
    iterator - Data to evaluate on
    
    Returns:
    
    ROC evaluation on the given dataset
  - evaluateROC
```
public ROC evaluateROC(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                       int rocThresholdSteps)
```
    Evaluate the network (must be a binary classifier) on the specified data, using the ROC class
    
    Parameters:
    
    iterator - Data to evaluate on
    
    rocThresholdSteps - Number of threshold steps to use with ROC
    
    Returns:
    
    ROC evaluation on the given dataset
  - evaluateROCMultiClass
```
public ROCMultiClass evaluateROCMultiClass(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)
```
    Evaluate the network on the specified data, using the ROCMultiClass class. Defaults to exact mode for ROCMultiClass instead of thresholded
    
    Parameters:
    
    iterator - Data to evaluate on
    
    Returns:
    
    Multi-class ROC evaluation on the given dataset
  - evaluateROCMultiClass
```
public ROCMultiClass evaluateROCMultiClass(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                                           int rocThresholdSteps)
```
    Evaluate the network on the specified data, using the ROCMultiClass class
    
    Parameters:
    
    iterator - Data to evaluate on
    
    rocThresholdSteps - Number of threshold steps to use with ROCMultiClass
    
    Returns:
    
    Multi-class ROC evaluation on the given dataset
  - doEvaluation
```
public <T extends IEvaluation> T[] doEvaluation(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                                                T... evaluations)
```
    Perform evaluation using an arbitrary IEvaluation instance.
    
    Specified by:
    
    doEvaluation in interface NeuralNetwork
    
    Parameters:
    
    iterator - data to evaluate on
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                           List<String> labelsList)
```
    Evaluate the network on the provided data set. Used for evaluating the performance of classifiers
    
    Parameters:
    
    iterator - Data to undertake evaluation on
    
    Returns:
    
    Evaluation object, summarizing the results of the evaluation on the provided DataSetIterator
  - updaterState
```
public org.nd4j.linalg.api.ndarray.INDArray updaterState()
```
    Description copied from interface: NeuralNetwork
    
    This method returns updater state (if applicable), null otherwise
    
    Specified by:
    
    updaterState in interface NeuralNetwork
    
    Returns:
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.MultiDataSet dataSet)
```
    Description copied from interface: NeuralNetwork
    
    This method fits model with a given MultiDataSet
    
    Specified by:
    
    fit in interface NeuralNetwork
  - fit
```
public void fit(@NonNull
                org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator,
                int numEpochs)
```
    Perform minibatch training on all minibatches in the MultiDataSetIterator, for the specified number of epochs. Equvalent to calling fit(MultiDataSetIterator) numEpochs times in a loop
    
    Parameters:
    
    iterator - Training data (DataSetIterator). Iterator must support resetting
    
    numEpochs - Number of training epochs, >= 1
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator)
```
    Perform minibatch training on all minibatches in the MultiDataSetIterator.
    Note: The MultiDataSets in the MultiDataSetIterator must have exactly 1 input and output array (as MultiLayerNetwork only supports 1 input and 1 output)
    
    Specified by:
    
    fit in interface NeuralNetwork
    
    Parameters:
    
    iterator - Training data (DataSetIterator). Iterator must support resetting
  - doEvaluation
```
public <T extends IEvaluation> T[] doEvaluation(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator,
                                                T[] evaluations)
```
    Description copied from interface: NeuralNetwork
    
    This method executes evaluation of the model against given iterator and evaluation implementations
    
    Specified by:
    
    doEvaluation in interface NeuralNetwork
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                           List<String> labelsList,
                           int topN)
```
    Evaluate the network (for classification) on the provided data set, with top N accuracy in addition to standard accuracy. For 'standard' accuracy evaluation only, use topN = 1
    
    Parameters:
    
    iterator - Iterator (data) to evaluate on
    
    labelsList - List of labels. May be null.
    
    topN - N value for top N accuracy evaluation
    
    Returns:
    
    Evaluation object, summarizing the results of the evaluation on the provided DataSetIterator
  - update
```
protected void update(org.nd4j.linalg.heartbeat.reports.Task task)
```
  - summary
```
public String summary()
```
    String detailing the architecture of the multilayernetwork. Columns are LayerIndex with layer type, nIn, nOut, Total number of parameters and the Shapes of the parameters Will also give information about frozen layers, if any.
    
    Returns:
    
    Summary as a string
  - summary
```
public String summary(InputType inputType)
```
    String detailing the architecture of the multilayernetwork. Will also display activation size when given an input type. Columns are LayerIndex with layer type, nIn, nOut, Total number of parameters, Shapes of the parameters, Input activation shape, Output activation shape Will also give information about frozen layers, if any.
    
    Returns:
    
    Summary as a string
  - clearLayersStates
```
protected void clearLayersStates()
```
    This method just makes sure there's no state preserved within layers
  - incrementEpochCount
```
public void incrementEpochCount()
```
    Increment the epoch count (in the underlying MultiLayerConfiguration by 1). Note that this is done automatically when using iterator-based fitting methods, such as fit(DataSetIterator). However, when using non-iterator fit methods (DataSet, INDArray/INDArray etc), the network has no way to know when one epoch ends and another starts. In such situations, this method can be used to increment the epoch counter.
    Note that the epoch counter is used for situations such as some learning rate schedules, and the like. The current epoch count can be obtained using MultiLayerConfiguration.getLayerwiseConfiguration().getEpochCount()
  - synchronizeIterEpochCounts
```
protected void synchronizeIterEpochCounts()
```
  - save
```
public void save(File f)
          throws IOException
```
    Save the MultiLayerNetwork to a file. Restore using load(File, boolean). Note that this saves the updater (i.e., the state array for momentum/Adam/rmsprop etc), which is desirable if further training will be undertaken.
    
    Parameters:
    
    f - File to save the network to
    
    Throws:
    
    IOException
    
    See Also:
    
    ModelSerializer for more details (and saving/loading via streams), save(File, boolean)
  - save
```
public void save(File f,
                 boolean saveUpdater)
          throws IOException
```
    Save the MultiLayerNetwork to a file. Restore using load(File, boolean).
    
    Parameters:
    
    f - File to save the network to
    
    saveUpdater - If true: save the updater (i.e., the state array for momentum/Adam/rmsprop etc), which should usually be saved if further training is required
    
    Throws:
    
    IOException
    
    See Also:
    
    ModelSerializer for more details (and saving/loading via streams), save(File, boolean)
  - load
```
public static MultiLayerNetwork load(File f,
                                     boolean loadUpdater)
                              throws IOException
```
    Restore a MultiLayerNetwork to a file, saved using save(File) or ModelSerializer
    
    Parameters:
    
    f - File to load the network from
    
    loadUpdater - If true: load the updater if it is available (i.e., the state array for momentum/Adam/rmsprop etc) - use false if no further training is required, or true if further training will be undertaken
    
    Throws:
    
    IOException
    
    See Also:
    
    ModelSerializer for more details (and saving/loading via streams)
  - toComputationGraph
```
public ComputationGraph toComputationGraph()
```
    Convert this MultiLayerNetwork to a ComputationGraph
    
    Returns:
    
    ComputationGraph equivalent to this network (including parameters and updater state)
  - setLearningRate
```
public void setLearningRate(double newLr)
```
    Set the learning rate for all layers in the network to the specified value. Note that if any learning rate schedules are currently present, these will be removed in favor of the new (fixed) learning rate.
    
    Note: This method not free from a performance point of view: a proper learning rate schedule should be used in preference to calling this method at every iteration.
    
    Parameters:
    
    newLr - New learning rate for all layers
    
    See Also:
    
    setLearningRate(ISchedule), setLearningRate(int, double)
  - setLearningRate
```
public void setLearningRate(org.nd4j.linalg.schedule.ISchedule newLr)
```
    Set the learning rate schedule for all layers in the network to the specified schedule. This schedule will replace any/all existing schedules, and also any fixed learning rate values.
    Note that the iteration/epoch counts will not be reset. Use MultiLayerConfiguration#setIterationCount(int) and MultiLayerConfiguration#setEpochCount(int) if this is required
    
    Parameters:
    
    newLr - New learning rate schedule for all layers
    
    See Also:
    
    setLearningRate(ISchedule), setLearningRate(int, double)
  - setLearningRate
```
public void setLearningRate(int layerNumber,
                            double newLr)
```
    Set the learning rate for a single layer in the network to the specified value. Note that if any learning rate schedules are currently present, these will be removed in favor of the new (fixed) learning rate.
    
    Note: This method not free from a performance point of view: a proper learning rate schedule should be used in preference to calling this method at every iteration. Note also that setLearningRate(double) should also be used in preference, when all layers need to be set to a new LR
    
    Parameters:
    
    layerNumber - Number of the layer to set the LR for
    
    newLr - New learning rate for a single layer
    
    See Also:
    
    setLearningRate(ISchedule), setLearningRate(int, double)
  - setLearningRate
```
public void setLearningRate(int layerNumber,
                            org.nd4j.linalg.schedule.ISchedule newLr)
```
    Set the learning rate schedule for a single layer in the network to the specified value.
    Note also that setLearningRate(ISchedule) should also be used in preference, when all layers need to be set to a new LR schedule.
    This schedule will replace any/all existing schedules, and also any fixed learning rate values.
    Note also that the iteration/epoch counts will not be reset. Use MultiLayerConfiguration#setIterationCount(int) and MultiLayerConfiguration#setEpochCount(int) if this is required
    
    Parameters:
    
    layerNumber - Number of the layer to set the LR schedule for
    
    newLr - New learning rate for a single layer
    
    See Also:
    
    setLearningRate(ISchedule), setLearningRate(int, double)
  - layerSize
```
public int layerSize(int layer)
```
    Return the layer size (number of units) for the specified layer.
    Note that the meaning of the "layer size" can depend on the type of layer. For example:
    - DenseLayer, OutputLayer, recurrent layers: number of units (nOut configuration option)
    - ConvolutionLayer: the channels (number of channels)
    - Subsampling layers, global pooling layers, etc: size of 0 is always returned
    
    Parameters:
    
    layer - Index of the layer to get the size of. Must be in range 0 to nLayers-1 inclusive
    
    Returns:
    
    Size of the layer
  - layerInputSize
```
public int layerInputSize(int layer)
```
    Return the input size (number of inputs) for the specified layer.
    Note that the meaning of the "input size" can depend on the type of layer. For example:
    - DenseLayer, OutputLayer, etc: the feature vector size (nIn configuration option)
    - Recurrent layers: the feature vector size per time step (nIn configuration option)
    - ConvolutionLayer: the channels (number of channels)
    - Subsampling layers, global pooling layers, etc: size of 0 is always returned
    
    Parameters:
    
    layer - Index of the layer to get the size of. Must be in range 0 to nLayers-1 inclusive
    
    Returns:
    
    Size of the layer
  - equals
```
public boolean equals(Object obj)
```
    Indicates whether some other object is "equal to" this one.
    The equals method implements an equivalence relation on non-null object references:
    - It is reflexive: for any non-null reference value x, x.equals(x) should return true.
    - It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
    - It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
    - It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
    - For any non-null reference value x, x.equals(null) should return false.
    The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).
    Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    obj - the reference object with which to compare.
    
    Returns:
    
    true if this object is the same as the obj argument; false otherwise.
    
    See Also:
    
    Object.hashCode(), HashMap

Class MultiLayerNetwork

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

layers

layerMap

input

labels

initCalled

trainingListeners

defaultConfiguration

layerWiseConfigurations

gradient

score

initDone

flattenedParams

flattenedGradients

clearTbpttState

lastEtlTime

mask

layerIndex

solver

WS_LAYER_WORKING_MEM

WS_ALL_LAYERS_ACT

WS_LAYER_ACT_1

WS_LAYER_ACT_2

WS_RNN_LOOP_WORKING_MEM

WS_LAYER_WORKING_MEM_CONFIG

WS_ALL_LAYERS_ACT_CONFIG

WS_LAYER_ACT_X_CONFIG

WS_RNN_LOOP_WORKING_MEM_CONFIG

Constructor Detail

MultiLayerNetwork

MultiLayerNetwork

MultiLayerNetwork

Method Detail

setCacheMode

setLastEtlTime

getLastEtlTime

intializeConfigurations

pretrain

pretrainLayer

pretrainLayer

batchSize

conf

setConf

input

validateInput

getOptimizer

getParam

initParams

paramTable

paramTable

setParamTable

setParam

getLayerWiseConfigurations

setLayerWiseConfigurations

init

init

setGradientsAccumulator

isInitCalled

initGradientsView

activate

activationFromPrevLayer

activateSelectedLayers

feedForward

feedForward

feedForward

feedForwardToLayer

feedForwardToLayer

feedForwardToLayer

validateArrayWorkspaces

ffToLayerActivationsDetached

ffToLayerActivationsInWs

outputOfLayerDetached

feedForward