MultiLayerNetwork (deeplearning4j-nn 0.6.0 API)

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

All Implemented Interfaces:

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

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 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 LinkedHashMap<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(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()` Calculate the l1 regularization term 0.0 if regularization is not used.
`double`	`calcL2()` 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
`protected List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>>`	`computeDeltas2()`
`protected List<org.nd4j.linalg.api.ndarray.INDArray>`	`computeDeltasR(org.nd4j.linalg.api.ndarray.INDArray v)`
`void`	`computeGradientAndScore()` Update the score
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`computeZ(boolean training)` * Compute input linear transformation (z) of the output layer
`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
`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, List<String> labelsList)` Evaluate the network on the provided data set.
`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(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.
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForwardR(List<org.nd4j.linalg.api.ndarray.INDArray> acts, org.nd4j.linalg.api.ndarray.INDArray v)` Feed forward with the r operator
`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.
`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 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(String name)`
`List<String>`	`getLayerNames()`
`Layer[]`	`getLayers()`
`MultiLayerConfiguration`	`getLayerWiseConfigurations()`
`Collection<IterationListener>`	`getListeners()` Get the iteration listeners for this layer.
`org.nd4j.linalg.api.ndarray.INDArray`	`getMask()`
`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
`Updater`	`getUpdater()` Get the updater for this MultiLayerNetwork
`Gradient`	`gradient()` Calculate a gradient
`Pair<Gradient,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()`
`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)` Averages the given logistic regression from a mini batch in to this one
`void`	`merge(MultiLayerNetwork network, int batchSize)` Merges this network with the other one.
`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`	`pack()` Deprecated. use
`org.nd4j.linalg.api.ndarray.INDArray`	`pack(List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>> layers)` Deprecated. use `params()`
`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
`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
`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)` This unsupervised learning method runs contrastive divergence on each RBM layer in the network.
`void`	`pretrain(org.nd4j.linalg.api.ndarray.INDArray input)` This unsupervised learning method runs contrastive divergence on each RBM layer in the network.
`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.
`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(Collection<IterationListener> listeners)` Set the iteration listeners for this layer.
`void`	`setListeners(IterationListener... listeners)` Set the iteration listeners for this layer.
`void`	`setMask(org.nd4j.linalg.api.ndarray.INDArray mask)`
`void`	`setMaskArray(org.nd4j.linalg.api.ndarray.INDArray maskArray)`
`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
`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
`List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>>`	`unPack(org.nd4j.linalg.api.ndarray.INDArray param)` Deprecated. use `setParameters(INDArray)`
`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.
`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 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
```
  - 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(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)
```
    This unsupervised learning method runs contrastive divergence on each RBM layer in the network.
    
    Parameters:
    
    iter - the input to iterate on The typical tip is that the higher k is the closer to the model you will be approximating due to more sampling. K = 1 usually gives very good results and is the default in quite a few situations.
  - pretrain
```
public void pretrain(org.nd4j.linalg.api.ndarray.INDArray input)
```
    This unsupervised learning method runs contrastive divergence on each RBM layer in the network.
    
    Parameters:
    
    input - the input to iterate on The typical tip is that the higher k is the closer to the model you will be approximating due to more sampling. K = 1 usually gives very good results and is the default in quite a few situations.
  - 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(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:
  - 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)
```
  - 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.
  - 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 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 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 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
  - 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.
  - 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
    
    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,Double> gradientAndScore()
```
    Description copied from interface: Model
    
    Get the gradient and score
    
    Specified by:
    
    gradientAndScore in interface Model
    
    Returns:
    
    the gradient and score
  - computeDeltasR
```
protected List<org.nd4j.linalg.api.ndarray.INDArray> computeDeltasR(org.nd4j.linalg.api.ndarray.INDArray v)
```
  - computeDeltas2
```
protected List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>> computeDeltas2()
```
  - clone
```
public MultiLayerNetwork clone()
```
    Description copied from interface: Layer
    
    Clone the layer
    
    Specified by:
    
    clone in interface Layer
    
    Overrides:
    
    clone in class 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
  - pack
```
@Deprecated
public org.nd4j.linalg.api.ndarray.INDArray pack()
```
    Deprecated. use
    
    Packs a set of matrices in to one vector, where the matrices in this case are the w,hbias at each layer and the output layer w,bias
    
    Returns:
    
    a singular matrix of all of the neuralNets packed in to one matrix
  - pack
```
@Deprecated
public org.nd4j.linalg.api.ndarray.INDArray pack(List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>> layers)
```
    Deprecated. use params()
    
    Packs a set of matrices in to one vector
    
    Parameters:
    
    layers - the neuralNets to pack
    
    Returns:
    
    a singular matrix of all of the neuralNets packed in to one matrix
  - 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
  - unPack
```
@Deprecated
public List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>> unPack(org.nd4j.linalg.api.ndarray.INDArray param)
```
    Deprecated. use setParameters(INDArray)
    
    Unpacks a parameter matrix in to a transform of pairs(w,hbias) triples with layer wise
    
    Parameters:
    
    param - the param vector
    
    Returns:
    
    a segmented list of the param vector
  - 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 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(Collection<IterationListener> listeners)
```
    Description copied from interface: Layer
    
    Set the iteration listeners for this layer.
    
    Specified by:
    
    setListeners in interface Layer
  - setListeners
```
public void setListeners(IterationListener... listeners)
```
    Description copied from interface: Layer
    
    Set the iteration listeners for this layer.
    
    Specified by:
    
    setListeners in interface Layer
  - 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 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,
                   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
```
public void merge(Layer layer,
                  int batchSize)
```
    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
```
public void merge(MultiLayerNetwork network,
                  int batchSize)
```
    Merges this network with the other one. This is a weight averaging with the update of: a += b - a / n where a is a matrix on the network b is the incoming matrix and n is the batch size. This update is performed across the network neuralNets as well as hidden neuralNets and logistic neuralNets
    
    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
  - feedForwardR
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForwardR(List<org.nd4j.linalg.api.ndarray.INDArray> acts,
                                                               org.nd4j.linalg.api.ndarray.INDArray v)
```
    Feed forward with the r operator
    
    Parameters:
    
    v - the v for the r operator
    
    Returns:
    
    the activations based on the r operator
  - 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)
```
  - 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()
```
    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
    
    Returns:
    
    the l2 regularization term for this layer.
  - calcL1
```
public double calcL1()
```
    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
    
    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)
```
    Specified by:
    
    setMaskArray in interface Layer
  - 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
  - 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 returs of the evaluation

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

pretrain

batchSize

conf

setConf

input

validateInput

getOptimizer

getParam

initParams

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

computeDeltasR

computeDeltas2

clone

params

params

setParams

setParamsViewArray

setBackpropGradientsViewArray