MultiLayerNetwork

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

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, Classifier, Layer, Model
```
public class MultiLayerNetwork
extends java.lang.Object
implements java.io.Serializable, Classifier, Layer
```
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.

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 NeuralNetConfiguration`	`defaultConfiguration`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`epsilon`
`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 int`	`layerIndex`
`protected java.util.LinkedHashMap<java.lang.String,Layer>`	`layerMap`
`protected Layer[]`	`layers`
`protected MultiLayerConfiguration`	`layerWiseConfigurations`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`mask`
`protected double`	`score`
`protected Solver`	`solver`

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(java.lang.String conf, org.nd4j.linalg.api.ndarray.INDArray params)` Initialize the network based on the configuration

Method Summary

All 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()` Triggers the activation of the last hidden layer ie: not logistic regression
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(boolean training)` Trigger an activation with the last specified input
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(org.nd4j.linalg.api.ndarray.INDArray input)` Initialize the layer with the given input and return the activation for this layer given this input
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(org.nd4j.linalg.api.ndarray.INDArray input, boolean training)` Initialize the layer with the given input and return the activation for this layer given this input
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(org.nd4j.linalg.api.ndarray.INDArray input, Layer.TrainingMode training)` Initialize the layer with the given input and return the activation for this layer given this input
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(int layer)` Triggers the activation for a given layer
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(int layer, org.nd4j.linalg.api.ndarray.INDArray input)` Triggers the activation of the given layer
`org.nd4j.linalg.api.ndarray.INDArray`	`activate(Layer.TrainingMode training)` Trigger an activation with the last specified input
`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)` Calculate activation from previous layer including pre processing where necessary
`org.nd4j.linalg.api.ndarray.INDArray`	`activationMean()` Calculate the mean representation for the activation for this layer
`void`	`applyLearningRateScoreDecay()` Update learningRate using for this model.
`protected void`	`backprop()` Calculate and set gradients for MultiLayerNetwork, based on OutputLayer and labels
`Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray>`	`backpropGradient(org.nd4j.linalg.api.ndarray.INDArray epsilon)` Calculate the gradient relative to the error in the next layer
`int`	`batchSize()` The current inputs batch size
`protected Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray>`	`calcBackpropGradients(org.nd4j.linalg.api.ndarray.INDArray epsilon, boolean withOutputLayer)` Calculate gradients and errors.
`Gradient`	`calcGradient(Gradient layerError, org.nd4j.linalg.api.ndarray.INDArray activation)` Calculate the gradient
`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.
`void`	`clear()` Clear the inputs.
`void`	`clearLayerMaskArrays()` Remove the mask arrays from all layers. See `setLayerMaskArrays(INDArray, INDArray)` for details on mask arrays.
`MultiLayerNetwork`	`clone()` Clone the layer
`void`	`computeGradientAndScore()` Update the score
`java.util.List<org.nd4j.linalg.api.ndarray.INDArray>`	`computeZ(boolean training)` * Compute input linear transformation (z) of the output layer
`java.util.List<org.nd4j.linalg.api.ndarray.INDArray>`	`computeZ(org.nd4j.linalg.api.ndarray.INDArray input, boolean training)` Compute activations from input to output of the output layer
`NeuralNetConfiguration`	`conf()` The configuration for the neural network
`org.nd4j.linalg.api.ndarray.INDArray`	`derivativeActivation(org.nd4j.linalg.api.ndarray.INDArray input)` Take the derivative of the given input based on the activation
`<T extends IEvaluation> T`	`doEvaluation(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, T evaluation)` Perform evaluation using an arbitrary IEvaluation instance.
`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)`
`org.nd4j.linalg.api.ndarray.INDArray`	`epsilon()`
`Gradient`	`error(org.nd4j.linalg.api.ndarray.INDArray errorSignal)` Calculate error with respect to the current layer.
`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, java.util.List<java.lang.String> labelsList)` Evaluate the network on the provided data set.
`Evaluation`	`evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, java.util.List<java.lang.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, 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, 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
`java.util.List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward()` Compute activations from input to output of the output layer
`java.util.List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(boolean train)` Compute activations from input to output of the output layer
`java.util.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
`java.util.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
`java.util.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.
`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.
`java.util.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.
`java.util.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.
`java.util.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.
`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)` Train the model based on the datasetiterator
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray data)` Fit the unsupervised model
`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
`NeuralNetConfiguration`	`getDefaultConfiguration()`
`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)
`org.nd4j.linalg.api.ndarray.INDArray`	`getLabels()`
`Layer`	`getLayer(int i)`
`Layer`	`getLayer(java.lang.String name)`
`java.util.List<java.lang.String>`	`getLayerNames()`
`Layer[]`	`getLayers()`
`MultiLayerConfiguration`	`getLayerWiseConfigurations()`
`java.util.Collection<IterationListener>`	`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(java.lang.String param)` Get the parameter
`Updater`	`getUpdater()` Get the updater for this MultiLayerNetwork
`Gradient`	`gradient()` Calculate a gradient
`Pair<Gradient,java.lang.Double>`	`gradientAndScore()` Get the gradient and score
`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`	`initialize(org.nd4j.linalg.dataset.DataSet data)` Sets the input and labels from this dataset
`void`	`initializeLayers(org.nd4j.linalg.api.ndarray.INDArray input)` Base class for initializing the neuralNets based on the input.
`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 (VAE, RBMs etc)
`void`	`iterate(org.nd4j.linalg.api.ndarray.INDArray input)` Run one iteration
`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
`void`	`merge(Layer layer, int batchSize)` Deprecated. Not supported and not used
`void`	`merge(MultiLayerNetwork network, int batchSize)` Deprecated. As of 0.7.3 - Feb 2017. No longer used; parameter averaging is performed via alternative means/methods
`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)`
`org.nd4j.linalg.api.ndarray.INDArray`	`output(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, boolean train)` Label the probabilities of the input
`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
`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
`java.util.Map<java.lang.String,org.nd4j.linalg.api.ndarray.INDArray>`	`paramTable()` The param table
`java.util.Map<java.lang.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
`java.util.List<java.lang.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
`org.nd4j.linalg.api.ndarray.INDArray`	`preOutput(org.nd4j.linalg.api.ndarray.INDArray x)` Raw activations
`org.nd4j.linalg.api.ndarray.INDArray`	`preOutput(org.nd4j.linalg.api.ndarray.INDArray x, boolean training)` Raw activations
`org.nd4j.linalg.api.ndarray.INDArray`	`preOutput(org.nd4j.linalg.api.ndarray.INDArray x, Layer.TrainingMode training)` Raw activations
`void`	`pretrain(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iter)` Perform layerwise pretraining on all pre-trainable layers in the network (VAEs, RBMs, 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`	`pretrain(org.nd4j.linalg.api.ndarray.INDArray input)` Deprecated. use `pretrain(DataSetIterator)` or `pretrainLayer(int, DataSetIterator)` or `pretrainLayer(int, INDArray)`. Pretraining each layer in a row on a single minibatch (as per this method) instead of N epochs per layer is not advisable.
`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, RBMs, 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, RBMs, 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.
`java.util.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).
`java.util.Map<java.lang.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, java.util.Map<java.lang.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.
`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==true.
`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`	`setConf(NeuralNetConfiguration conf)` Setter for the configuration
`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`	`setInputMiniBatchSize(int size)` Set current/last input mini-batch size. Used for score and gradient calculations.
`void`	`setLabels(org.nd4j.linalg.api.ndarray.INDArray labels)`
`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`	`setListeners(java.util.Collection<IterationListener> listeners)` Set the IterationListeners for the ComputationGraph (and all layers in the network)
`void`	`setListeners(IterationListener... listeners)` Set the IterationListeners 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(java.lang.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(java.util.Map<java.lang.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
`java.lang.String`	`summary()` String detailing the architecture of the multilayernetwork.
`Layer`	`transpose()` Return a transposed copy of the weights/bias (this means reverse the number of inputs and outputs on the weights)
`protected void`	`truncatedBPTTGradient()` Equivalent to backprop(), but calculates gradient for truncated BPTT instead.
`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, java.lang.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.
`void`	`updateRnnStateWithTBPTTState()`
`void`	`validateInput()` Validate the input
`org.nd4j.linalg.api.ndarray.INDArray`	`zFromPrevLayer(int curr, org.nd4j.linalg.api.ndarray.INDArray input, boolean training)` Compute input linear transformation (z) from previous layer Apply pre processing transformation where necessary

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

- Field Detail
  - layers
```
protected Layer[] layers
```
  - layerMap
```
protected java.util.LinkedHashMap<java.lang.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
```
  - defaultConfiguration
```
protected NeuralNetConfiguration defaultConfiguration
```
  - layerWiseConfigurations
```
protected MultiLayerConfiguration layerWiseConfigurations
```
  - gradient
```
protected Gradient gradient
```
  - epsilon
```
protected org.nd4j.linalg.api.ndarray.INDArray epsilon
```
  - 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
```
  - mask
```
protected org.nd4j.linalg.api.ndarray.INDArray mask
```
  - layerIndex
```
protected int layerIndex
```
  - solver
```
protected transient Solver solver
```
- Constructor Detail
  - MultiLayerNetwork
```
public MultiLayerNetwork(MultiLayerConfiguration conf)
```
  - MultiLayerNetwork
```
public MultiLayerNetwork(java.lang.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
  - 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, RBMs, 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, RBMs, 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, RBMs, 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
  - pretrain
```
@Deprecated
public void pretrain(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Deprecated. use pretrain(DataSetIterator) or pretrainLayer(int, DataSetIterator) or pretrainLayer(int, INDArray). Pretraining each layer in a row on a single minibatch (as per this method) instead of N epochs per layer is not advisable.
  - 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
    
    Returns:
    
    this models optimizer
  - getParam
```
public org.nd4j.linalg.api.ndarray.INDArray getParam(java.lang.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 java.util.Map<java.lang.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 java.util.Map<java.lang.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(java.util.Map<java.lang.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(java.lang.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)
```
  - initializeLayers
```
public void initializeLayers(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Base class for initializing the neuralNets based on the input. This is meant for capturing numbers such as input columns or other things.
    
    Parameters:
    
    input - the input matrix for training
  - init
```
public void init()
```
    Initialize the MultiLayerNetwork. This should be called once before the network is used.
    
    Specified by:
    
    init in interface Model
  - 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
  - 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
```
public org.nd4j.linalg.api.ndarray.INDArray activate()
```
    Triggers the activation of the last hidden layer ie: not logistic regression
    
    Specified by:
    
    activate in interface Layer
    
    Returns:
    
    the activation of the last hidden layer given the last input to the network
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate(int layer)
```
    Triggers the activation for a given layer
    
    Parameters:
    
    layer - the layer to activate on
    
    Returns:
    
    the activation for a given layer
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Description copied from interface: Layer
    
    Initialize the layer with the given input and return the activation for this layer given this input
    
    Specified by:
    
    activate in interface Layer
    
    Parameters:
    
    input - the input to use
    
    Returns:
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate(int layer,
                                                     org.nd4j.linalg.api.ndarray.INDArray input)
```
    Triggers the activation of the given layer
    
    Parameters:
    
    layer - the layer to trigger on
    
    input - the input to the hidden layer
    
    Returns:
    
    the activation of the layer based on the input
  - activationMean
```
public org.nd4j.linalg.api.ndarray.INDArray activationMean()
```
    Description copied from interface: Layer
    
    Calculate the mean representation for the activation for this layer
    
    Specified by:
    
    activationMean in interface Layer
    
    Returns:
    
    the activation mean for this layer
  - initialize
```
public void initialize(org.nd4j.linalg.dataset.DataSet data)
```
    Sets the input and labels from this dataset
    
    Parameters:
    
    data - the dataset to initialize with
  - zFromPrevLayer
```
public org.nd4j.linalg.api.ndarray.INDArray zFromPrevLayer(int curr,
                                                           org.nd4j.linalg.api.ndarray.INDArray input,
                                                           boolean training)
```
    Compute input linear transformation (z) from previous layer Apply pre processing transformation where necessary
    
    Parameters:
    
    curr - the current layer
    
    input - the input
    
    training - training or test mode
    
    Returns:
    
    the activation from the previous layer
  - activationFromPrevLayer
```
public org.nd4j.linalg.api.ndarray.INDArray activationFromPrevLayer(int curr,
                                                                    org.nd4j.linalg.api.ndarray.INDArray input,
                                                                    boolean training)
```
    Calculate activation from previous layer including pre processing where necessary
    
    Parameters:
    
    curr - the current layer
    
    input - the input
    
    Returns:
    
    the activation from the previous layer
  - 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
  - computeZ
```
public java.util.List<org.nd4j.linalg.api.ndarray.INDArray> computeZ(boolean training)
```
    * Compute input linear transformation (z) of the output layer
    
    Returns:
    
    the list of activations for each layer
  - computeZ
```
public java.util.List<org.nd4j.linalg.api.ndarray.INDArray> computeZ(org.nd4j.linalg.api.ndarray.INDArray input,
                                                                     boolean training)
```
    Compute activations from input to output of the output layer
    
    Returns:
    
    the list of activations for each layer
  - feedForward
```
public java.util.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 java.util.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
  - feedForwardToLayer
```
public java.util.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 java.util.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 java.util.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.
  - feedForward
```
public java.util.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 java.util.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 java.util.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
    
    Calculate a gradient
    
    Specified by:
    
    gradient in interface Model
    
    Returns:
    
    the gradient for this model
  - epsilon
```
public org.nd4j.linalg.api.ndarray.INDArray epsilon()
```
  - gradientAndScore
```
public Pair<Gradient,java.lang.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()
```
    Description copied from interface: Layer
    
    Clone the layer
    
    Specified by:
    
    clone in interface Layer
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
  - 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
    
    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
  - 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(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)
```
    Description copied from interface: Classifier
    
    Train the model based on the datasetiterator
    
    Specified by:
    
    fit in interface Classifier
    
    Parameters:
    
    iterator - the iterator to train on
  - backprop
```
protected void backprop()
```
    Calculate and set gradients for MultiLayerNetwork, based on OutputLayer and labels
  - calcBackpropGradients
```
protected Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray> calcBackpropGradients(org.nd4j.linalg.api.ndarray.INDArray epsilon,
                                                                                    boolean withOutputLayer)
```
    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
    
    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)
```
  - updateRnnStateWithTBPTTState
```
public void updateRnnStateWithTBPTTState()
```
  - truncatedBPTTGradient
```
protected void truncatedBPTTGradient()
```
    Equivalent to backprop(), but calculates gradient for truncated BPTT instead.
  - getListeners
```
public java.util.Collection<IterationListener> getListeners()
```
    Description copied from interface: Layer
    
    Get the iteration listeners for this layer.
    
    Specified by:
    
    getListeners in interface Layer
    
    Returns:
  - setListeners
```
public void setListeners(java.util.Collection<IterationListener> listeners)
```
    Description copied from interface: Model
    
    Set the IterationListeners for the ComputationGraph (and all layers in the network)
    
    Specified by:
    
    setListeners in interface Layer
    
    Specified by:
    
    setListeners in interface Model
  - setListeners
```
public void setListeners(IterationListener... listeners)
```
    Description copied from interface: Model
    
    Set the IterationListeners 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 java.util.List<java.lang.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)
```
    Fit the unsupervised model
    
    Specified by:
    
    fit in interface Model
    
    Parameters:
    
    data - the examples to classify (one example in each row)
  - iterate
```
public void iterate(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Description copied from interface: Model
    
    Run one iteration
    
    Specified by:
    
    iterate in interface Model
    
    Parameters:
    
    input - the input to iterate on
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.DataSet data)
```
    Fit the model
    
    Specified by:
    
    fit in interface Classifier
    
    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)
```
    Label the probabilities of the input
    
    Parameters:
    
    iterator - test data to evaluate
    
    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)
```
  - 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 getFromOrigin 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==true.
    
    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,
                   java.lang.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()
```
    Description copied from interface: Model
    
    Update the score
    
    Specified by:
    
    computeGradientAndScore in interface Model
  - 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
  - merge
```
@Deprecated
public void merge(Layer layer,
                              int batchSize)
```
    Deprecated. Not supported and not used
    
    Averages the given logistic regression from a mini batch in to this one
    
    Specified by:
    
    merge in interface Layer
    
    Parameters:
    
    layer - the logistic regression to average in to this one
    
    batchSize - the batch size
  - merge
```
@Deprecated
public void merge(MultiLayerNetwork network,
                              int batchSize)
```
    Deprecated. As of 0.7.3 - Feb 2017. No longer used; parameter averaging is performed via alternative means/methods
    
    Deprecated: Merges this network with the other one.
    
    Parameters:
    
    network - the network to merge with
    
    batchSize - the batch size (number of training examples) to average by
  - 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
    
    Specified by:
    
    setInput in interface Layer
    
    Parameters:
    
    input -
  - 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
  - applyLearningRateScoreDecay
```
public void applyLearningRateScoreDecay()
```
    Description copied from interface: Model
    
    Update learningRate using for this model. Use the learningRateScoreBasedDecay to adapt the score if the Eps termination condition is met
    
    Specified by:
    
    applyLearningRateScoreDecay in interface Model
  - 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(java.lang.String name)
```
  - getLayerNames
```
public java.util.List<java.lang.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 (VAE, RBMs etc)
    
    Specified by:
    
    isPretrainLayer in interface Layer
    
    Returns:
    
    true if the layer can be pretrained (using fit(INDArray), false otherwise
  - feedForwardMaskArray
```
public 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.
  - error
```
public Gradient error(org.nd4j.linalg.api.ndarray.INDArray errorSignal)
```
    Description copied from interface: Layer
    
    Calculate error with respect to the current layer. This gradient will contain the error signal
    
    Specified by:
    
    error in interface Layer
    
    Parameters:
    
    errorSignal - the gradient for the forward layer If this is the final layer, it will start with the error from the output. This is on the user to initialize.
    
    Returns:
    
    the gradient wrt the parameters on the current layer
  - type
```
public Layer.Type type()
```
    Description copied from interface: Layer
    
    Returns the layer type
    
    Specified by:
    
    type in interface Layer
    
    Returns:
  - derivativeActivation
```
public org.nd4j.linalg.api.ndarray.INDArray derivativeActivation(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Description copied from interface: Layer
    
    Take the derivative of the given input based on the activation
    
    Specified by:
    
    derivativeActivation in interface Layer
    
    Parameters:
    
    input - the input to take the derivative of
    
    Returns:
    
    the derivative of the action
  - calcGradient
```
public Gradient calcGradient(Gradient layerError,
                             org.nd4j.linalg.api.ndarray.INDArray activation)
```
    Description copied from interface: Layer
    
    Calculate the gradient
    
    Specified by:
    
    calcGradient in interface Layer
    
    Parameters:
    
    layerError - the layer error
    
    Returns:
    
    the gradient
  - preOutput
```
public org.nd4j.linalg.api.ndarray.INDArray preOutput(org.nd4j.linalg.api.ndarray.INDArray x)
```
    Description copied from interface: Layer
    
    Raw activations
    
    Specified by:
    
    preOutput in interface Layer
    
    Parameters:
    
    x - the input to transform
    
    Returns:
    
    the raw activation for this layer
  - preOutput
```
public org.nd4j.linalg.api.ndarray.INDArray preOutput(org.nd4j.linalg.api.ndarray.INDArray x,
                                                      Layer.TrainingMode training)
```
    Description copied from interface: Layer
    
    Raw activations
    
    Specified by:
    
    preOutput in interface Layer
    
    Parameters:
    
    x - the input to transform
    
    Returns:
    
    the raw activation for this layer
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate(Layer.TrainingMode training)
```
    Description copied from interface: Layer
    
    Trigger an activation with the last specified input
    
    Specified by:
    
    activate in interface Layer
    
    Parameters:
    
    training - training or test mode
    
    Returns:
    
    the activation of the last specified input
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate(org.nd4j.linalg.api.ndarray.INDArray input,
                                                     Layer.TrainingMode training)
```
    Description copied from interface: Layer
    
    Initialize the layer with the given input and return the activation for this layer given this input
    
    Specified by:
    
    activate in interface Layer
    
    Parameters:
    
    input - the input to use
    
    training - train or test mode
    
    Returns:
  - 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 Pair<Gradient,org.nd4j.linalg.api.ndarray.INDArray> backpropGradient(org.nd4j.linalg.api.ndarray.INDArray epsilon)
```
    Description copied from interface: Layer
    
    Calculate the gradient relative to the error in the next layer
    
    Specified by:
    
    backpropGradient in interface Layer
    
    Parameters:
    
    epsilon - w^(L+1)*delta^(L+1). Or, equiv: dC/da, i.e., (dC/dz)*(dz/da) = dC/da, where C is cost function a=sigma(z) is activation.
    
    Returns:
    
    Pair where Gradient is gradient for this layer, INDArray is epsilon needed by next layer, but before element-wise multiply by sigmaPrime(z). So for standard feed-forward layer, if this layer is L, then return.getSecond() == (w^(L)*(delta^(L))^T)^T
  - 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
  - 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
  - preOutput
```
public org.nd4j.linalg.api.ndarray.INDArray preOutput(org.nd4j.linalg.api.ndarray.INDArray x,
                                                      boolean training)
```
    Description copied from interface: Layer
    
    Raw activations
    
    Specified by:
    
    preOutput in interface Layer
    
    Parameters:
    
    x - the input to transform
    
    Returns:
    
    the raw activation for this layer
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate(boolean training)
```
    Description copied from interface: Layer
    
    Trigger an activation with the last specified input
    
    Specified by:
    
    activate in interface Layer
    
    Parameters:
    
    training - training or test mode
    
    Returns:
    
    the activation of the last specified input
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate(org.nd4j.linalg.api.ndarray.INDArray input,
                                                     boolean training)
```
    Description copied from interface: Layer
    
    Initialize the layer with the given input and return the activation for this layer given this input
    
    Specified by:
    
    activate in interface Layer
    
    Parameters:
    
    input - the input to use
    
    training - train or test mode
    
    Returns:
  - 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 java.util.Map<java.lang.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,
                                java.util.Map<java.lang.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 java.util.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,
                       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,
                                           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 evaluation)
```
    Perform evaluation using an arbitrary IEvaluation instance.
    
    Parameters:
    
    iterator - data to evaluate on
    
    evaluation - IEvaluation instance to perform evaluation with
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                           java.util.List<java.lang.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
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                           java.util.List<java.lang.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
  - summary
```
public java.lang.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

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

defaultConfiguration

layerWiseConfigurations

gradient

epsilon

score

initDone

flattenedParams

flattenedGradients

mask

layerIndex

solver

Constructor Detail

MultiLayerNetwork

MultiLayerNetwork

MultiLayerNetwork

Method Detail

intializeConfigurations

pretrain

pretrainLayer

pretrainLayer

pretrain

batchSize

conf

setConf

input

validateInput

getOptimizer

getParam

initParams

paramTable

paramTable

setParamTable

setParam

getLayerWiseConfigurations

setLayerWiseConfigurations

initializeLayers

init

init

isInitCalled

initGradientsView

activate

activate

activate

activate

activationMean

initialize

zFromPrevLayer

activationFromPrevLayer

activateSelectedLayers

computeZ

computeZ

feedForward

feedForward

feedForwardToLayer

feedForwardToLayer

feedForwardToLayer

feedForward

feedForward

feedForward

gradient

epsilon

gradientAndScore

clone

params

params

setParams

setParamsViewArray