BaseMultiLayerNetwork (deeplearning4j-core 0.0.3.2 API)

java.lang.Object
- org.deeplearning4j.nn.BaseMultiLayerNetwork

All Implemented Interfaces:

Serializable, Classifier, Model, Persistable

Direct Known Subclasses:

DBN, SemanticHashing, StackedAutoEncoder, StackedDenoisingAutoEncoder
```
public abstract class BaseMultiLayerNetwork
extends Object
implements Serializable, Persistable, Classifier
```
A base class for a multi layer neural network with a logistic output layer and multiple hidden neuralNets.

Author:

Adam Gibson

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class BaseMultiLayerNetwork.Builder<E extends BaseMultiLayerNetwork>

static class BaseMultiLayerNetwork.ParamRange

Nested Classes
Modifier and Type	Class and Description
`static class`	`BaseMultiLayerNetwork.Builder<E extends BaseMultiLayerNetwork>`
`static class`	`BaseMultiLayerNetwork.ParamRange`

Field Summary

Fields
Modifier and Type	Field and Description
`protected double`	`dampingFactor`
`protected NeuralNetConfiguration`	`defaultConfiguration`
`protected double`	`errorTolerance`
`protected boolean`	`forceNumEpochs`
`protected Map<Integer,org.nd4j.linalg.transformation.MatrixTransform>`	`hiddenBiasTransforms`
`protected int[]`	`hiddenLayerSizes`
`protected boolean`	`initCalled`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`input`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`labels`
`protected Layer[]`	`layers`
`protected List<NeuralNetConfiguration>`	`layerWiseConfigurations`
`protected double`	`learningRateUpdate`
`protected boolean`	`lineSearchBackProp` Whether to use conjugate gradient line search for back prop or normal SGD backprop
`protected org.nd4j.linalg.api.ndarray.INDArray`	`mask`
`protected NeuralNetwork[]`	`neuralNets`
`protected MultiLayerNetworkOptimizer`	`optimizer`
`protected boolean`	`sampleFromHiddenActivations`
`protected boolean`	`shouldBackProp`
`protected boolean`	`useDropConnect`
`protected boolean`	`useGaussNewtonVectorProductBackProp`
`protected Map<Integer,org.nd4j.linalg.transformation.MatrixTransform>`	`visibleBiasTransforms`
`protected Map<Integer,org.nd4j.linalg.transformation.MatrixTransform>`	`weightTransforms`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`BaseMultiLayerNetwork()`
`protected`	`BaseMultiLayerNetwork(int[] hiddenLayerSizes, int nLayers)`
`protected`	`BaseMultiLayerNetwork(int[] hiddenLayerSizes, int nLayers, org.nd4j.linalg.api.ndarray.INDArray input, org.nd4j.linalg.api.ndarray.INDArray labels)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`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(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`	`activationFromPrevLayer(int curr, org.nd4j.linalg.api.ndarray.INDArray input)`
`protected void`	`applyDropConnectIfNecessary(org.nd4j.linalg.api.ndarray.INDArray input)` Applies drop connect relative to connections.
`protected void`	`applyTransforms()`
`void`	`backProp(double lr, int epochs)` Backpropagation of errors for weights
`void`	`backProp(double lr, int epochs, TrainingEvaluator eval)` Backpropagation of errors for weights
`protected List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>>`	`backPropGradient()` Do a back prop iteration.
`protected List<Pair<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>,Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>>>`	`backPropGradient2()` Do a back prop iteration.
`protected List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>>`	`backPropGradientR(org.nd4j.linalg.api.ndarray.INDArray v)` Do a back prop iteration.
`void`	`backPropStep()` One step of back prop
`void`	`backPropStepR(org.nd4j.linalg.api.ndarray.INDArray v)` One step of back prop with the R operator
`void`	`clearInput()` Clears the input from all of the neuralNets
`BaseMultiLayerNetwork`	`clone()`
`protected void`	`computeDeltas(List<org.nd4j.linalg.api.ndarray.INDArray> deltaRet)`
`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)`
`Layer`	`createHiddenLayer(int index, org.nd4j.linalg.api.ndarray.INDArray layerInput)` Creates a hidden layer with the given parameters.
`abstract NeuralNetwork`	`createLayer(org.nd4j.linalg.api.ndarray.INDArray input, org.nd4j.linalg.api.ndarray.INDArray W, org.nd4j.linalg.api.ndarray.INDArray hbias, org.nd4j.linalg.api.ndarray.INDArray vBias, int index)` Creates a layer depending on the index.
`abstract NeuralNetwork[]`	`createNetworkLayers(int numLayers)`
`void`	`dampingUpdate(double rho, double boost, double decrease)`
`void`	`dimensionCheck()`
`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(org.nd4j.linalg.api.ndarray.INDArray input)` Compute activations from input to output of the output layer
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`feedForwardR(org.nd4j.linalg.api.ndarray.INDArray v)` Feed forward with the r operator
`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
`void`	`finetune(DataSetIterator iter, double lr, int iterations)` Run SGD based on the given labels
`void`	`finetune(DataSetIterator iter, double lr, int iterations, TrainingEvaluator eval)` Run training algorithm based on the datastet iterator
`void`	`finetune(double lr, int epochs)` Finetunes with the current cached labels
`void`	`finetune(org.nd4j.linalg.api.ndarray.INDArray labels, double lr, int iterations)` Run SGD based on the given labels
`void`	`finetune(org.nd4j.linalg.api.ndarray.INDArray labels, double lr, int iterations, TrainingEvaluator eval)` Run training algorithm based on the given labels
`void`	`fit(org.nd4j.linalg.dataset.api.DataSet data)` Fit the model
`void`	`fit(org.nd4j.linalg.dataset.api.DataSet data, Object[] params)` Fit the model
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray data)` Fit the model to the given data
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray examples, org.nd4j.linalg.api.ndarray.INDArray labels)` Fit the model
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray examples, org.nd4j.linalg.api.ndarray.INDArray labels, Object[] params)` Fit the model
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray examples, int[] labels)` Fit the model
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray examples, int[] labels, Object[] params)` Fit the model
`Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>`	`getBackPropGradient2()` Gets the back prop gradient with the r operator (gauss vector) and the associated precon matrix This is also called computeGV
`org.nd4j.linalg.api.ndarray.INDArray`	`getBackPropRGradient(org.nd4j.linalg.api.ndarray.INDArray v)` Gets the back prop gradient with the r operator (gauss vector) This is also called computeGV
`NeuralNetConfiguration`	`getDefaultConfiguration()`
`Map<Integer,org.nd4j.linalg.transformation.MatrixTransform>`	`getHiddenBiasTransforms()`
`int[]`	`getHiddenLayerSizes()`
`org.nd4j.linalg.api.ndarray.INDArray`	`getInput()`
`org.nd4j.linalg.api.ndarray.INDArray`	`getLabels()`
`Layer[]`	`getLayers()`
`List<NeuralNetConfiguration>`	`getLayerWiseConfigurations()`
`org.nd4j.linalg.api.ndarray.INDArray`	`getMask()`
`NeuralNetwork[]`	`getNeuralNets()`
`int`	`getnLayers()`
`OutputLayer`	`getOutputLayer()`
`Map<Integer,org.nd4j.linalg.transformation.MatrixTransform>`	`getVisibleBiasTransforms()`
`Map<Integer,org.nd4j.linalg.transformation.MatrixTransform>`	`getWeightTransforms()`
`void`	`init()`
`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.
`protected void`	`intializeConfigurations()`
`boolean`	`isForceNumEpochs()`
`boolean`	`isLineSearchBackProp()`
`boolean`	`isSampleFromHiddenActivations()`
`boolean`	`isShouldBackProp()`
`boolean`	`isUseDropConnect()`
`boolean`	`isUseGaussNewtonVectorProductBackProp()`
`void`	`iterate(org.nd4j.linalg.api.ndarray.INDArray examples, int[] labels, Object[] params)` Iterate once on the model
`void`	`iterate(org.nd4j.linalg.api.ndarray.INDArray input, Object[] params)` 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`	`load(InputStream is)` Load (using `ObjectInputStream`
`void`	`merge(BaseMultiLayerNetwork 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
`org.nd4j.linalg.api.ndarray.INDArray`	`output(org.nd4j.linalg.api.ndarray.INDArray x)` Label the probabilities of the input
`org.nd4j.linalg.api.ndarray.INDArray`	`pack()` 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
`org.nd4j.linalg.api.ndarray.INDArray`	`pack(List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>> layers)` Packs a set of matrices in to one vector
`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
`int[]`	`predict(org.nd4j.linalg.api.ndarray.INDArray d)` Returns the predictions for each example in the dataset
`abstract void`	`pretrain(DataSetIterator iter, Object[] otherParams)`
`abstract void`	`pretrain(org.nd4j.linalg.api.ndarray.INDArray input, Object[] otherParams)`
`void`	`printConfiguration()` Prints the configuration
`org.nd4j.linalg.api.ndarray.INDArray`	`reconstruct(org.nd4j.linalg.api.ndarray.INDArray x, int layerNum)` Reconstructs the input.
`double`	`reductionRatio(org.nd4j.linalg.api.ndarray.INDArray p, double currScore, double score, org.nd4j.linalg.api.ndarray.INDArray gradient)`
`double`	`score()` Score of the model (relative to the objective function)
`double`	`score(org.nd4j.linalg.dataset.api.DataSet data)` Sets the input and labels and returns a score for the prediction wrt true labels
`double`	`score(org.nd4j.linalg.dataset.DataSet data)` Sets the input and labels and returns a score for the prediction wrt true labels
`double`	`score(org.nd4j.linalg.api.ndarray.INDArray param)` Score of the model (relative to the objective function)
`double`	`score(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
`void`	`setDefaultConfiguration(NeuralNetConfiguration defaultConfiguration)`
`void`	`setForceNumEpochs(boolean forceNumEpochs)`
`void`	`setHiddenLayerSizes(int[] hiddenLayerSizes)`
`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`	`setLabels(org.nd4j.linalg.api.ndarray.INDArray labels)`
`void`	`setLayers(Layer[] layers)`
`void`	`setLayers(NeuralNetwork[] layers)`
`void`	`setLayerWiseConfigurations(List<NeuralNetConfiguration> layerWiseConfigurations)`
`void`	`setLineSearchBackProp(boolean lineSearchBackProp)`
`void`	`setMask(org.nd4j.linalg.api.ndarray.INDArray mask)`
`void`	`setNeuralNets(NeuralNetwork[] neuralNets)`
`void`	`setnLayers(int nLayers)`
`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`	`setSampleFromHiddenActivations(boolean sampleFromHiddenActivations)`
`void`	`setShouldBackProp(boolean shouldBackProp)`
`void`	`setUseDropConnect(boolean useDropConnect)`
`void`	`setUseGaussNewtonVectorProductBackProp(boolean useGaussNewtonVectorProductBackProp)`
`BaseMultiLayerNetwork.ParamRange`	`startIndexForLayer(int layer)` Returns a start index for a given layer (neural net or outputlayer)
`org.nd4j.linalg.api.ndarray.INDArray`	`transform(org.nd4j.linalg.api.ndarray.INDArray data)` Transform the data based on the model's output.
`List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>>`	`unPack(org.nd4j.linalg.api.ndarray.INDArray param)` Unpacks a parameter matrix in to a applyTransformToDestination of pairs(w,hbias) triples with layer wise
`void`	`update(BaseMultiLayerNetwork network)` Assigns the parameters of this model to the ones specified by this network.
`List<org.nd4j.linalg.api.ndarray.INDArray>`	`weightMatrices()`
`void`	`write(OutputStream os)`

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

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

- Field Detail
  - hiddenLayerSizes
```
protected int[] hiddenLayerSizes
```
  - layers
```
protected Layer[] layers
```
  - input
```
protected org.nd4j.linalg.api.ndarray.INDArray input
```
  - labels
```
protected org.nd4j.linalg.api.ndarray.INDArray labels
```
  - optimizer
```
protected MultiLayerNetworkOptimizer optimizer
```
  - weightTransforms
```
protected Map<Integer,org.nd4j.linalg.transformation.MatrixTransform> weightTransforms
```
  - hiddenBiasTransforms
```
protected Map<Integer,org.nd4j.linalg.transformation.MatrixTransform> hiddenBiasTransforms
```
  - visibleBiasTransforms
```
protected Map<Integer,org.nd4j.linalg.transformation.MatrixTransform> visibleBiasTransforms
```
  - shouldBackProp
```
protected boolean shouldBackProp
```
  - forceNumEpochs
```
protected boolean forceNumEpochs
```
  - initCalled
```
protected boolean initCalled
```
  - sampleFromHiddenActivations
```
protected boolean sampleFromHiddenActivations
```
  - defaultConfiguration
```
protected NeuralNetConfiguration defaultConfiguration
```
  - layerWiseConfigurations
```
protected List<NeuralNetConfiguration> layerWiseConfigurations
```
  - learningRateUpdate
```
protected double learningRateUpdate
```
  - neuralNets
```
protected NeuralNetwork[] neuralNets
```
  - errorTolerance
```
protected double errorTolerance
```
  - lineSearchBackProp
```
protected boolean lineSearchBackProp
```
    Whether to use conjugate gradient line search for back prop or normal SGD backprop
  - mask
```
protected org.nd4j.linalg.api.ndarray.INDArray mask
```
  - useDropConnect
```
protected boolean useDropConnect
```
  - dampingFactor
```
protected double dampingFactor
```
  - useGaussNewtonVectorProductBackProp
```
protected boolean useGaussNewtonVectorProductBackProp
```
- Constructor Detail
  - BaseMultiLayerNetwork
```
protected BaseMultiLayerNetwork()
```
  - BaseMultiLayerNetwork
```
protected BaseMultiLayerNetwork(int[] hiddenLayerSizes,
                                int nLayers)
```
  - BaseMultiLayerNetwork
```
protected BaseMultiLayerNetwork(int[] hiddenLayerSizes,
                                int nLayers,
                                org.nd4j.linalg.api.ndarray.INDArray input,
                                org.nd4j.linalg.api.ndarray.INDArray labels)
```
- Method Detail
  - intializeConfigurations
```
protected void intializeConfigurations()
```
  - dimensionCheck
```
public void dimensionCheck()
```
  - transform
```
public org.nd4j.linalg.api.ndarray.INDArray transform(org.nd4j.linalg.api.ndarray.INDArray data)
```
    Transform the data based on the model's output. This can be anything from a number to reconstructions.
    
    Specified by:
    
    transform in interface Model
    
    Parameters:
    
    data - the data to transform
    
    Returns:
    
    the transformed data
  - getDefaultConfiguration
```
public NeuralNetConfiguration getDefaultConfiguration()
```
  - setDefaultConfiguration
```
public void setDefaultConfiguration(NeuralNetConfiguration defaultConfiguration)
```
  - getLayerWiseConfigurations
```
public List<NeuralNetConfiguration> getLayerWiseConfigurations()
```
  - setLayerWiseConfigurations
```
public void setLayerWiseConfigurations(List<NeuralNetConfiguration> 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()
```
  - activate
```
public org.nd4j.linalg.api.ndarray.INDArray activate()
```
    Triggers the activation of the last hidden layer ie: not logistic regression
    
    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(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
  - finetune
```
public void finetune(double lr,
                     int epochs)
```
    Finetunes with the current cached labels
    
    Parameters:
    
    lr - the learning rate to use
    
    epochs - the max number of epochs to finetune with
  - 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
  - activationFromPrevLayer
```
public org.nd4j.linalg.api.ndarray.INDArray activationFromPrevLayer(int curr,
                                                                    org.nd4j.linalg.api.ndarray.INDArray input)
```
  - 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
  - applyDropConnectIfNecessary
```
protected void applyDropConnectIfNecessary(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Applies drop connect relative to connections. This should be used on the activation of a neural net. (Post sigmoid layer)
    
    Parameters:
    
    input - the input to apply drop connect to
  - computeDeltasR
```
protected List<org.nd4j.linalg.api.ndarray.INDArray> computeDeltasR(org.nd4j.linalg.api.ndarray.INDArray v)
```
  - dampingUpdate
```
public void dampingUpdate(double rho,
                          double boost,
                          double decrease)
```
  - reductionRatio
```
public double reductionRatio(org.nd4j.linalg.api.ndarray.INDArray p,
                             double currScore,
                             double score,
                             org.nd4j.linalg.api.ndarray.INDArray gradient)
```
  - computeDeltas2
```
protected List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>> computeDeltas2()
```
  - 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
  - fit
```
public void fit(org.nd4j.linalg.api.ndarray.INDArray data)
```
    Fit the model to the given data
    
    Specified by:
    
    fit in interface Model
    
    Parameters:
    
    data - the data to fit the model to
  - computeDeltas
```
protected void computeDeltas(List<org.nd4j.linalg.api.ndarray.INDArray> deltaRet)
```
  - backPropStep
```
public void backPropStep()
```
    One step of back prop
  - backPropStepR
```
public void backPropStepR(org.nd4j.linalg.api.ndarray.INDArray v)
```
    One step of back prop with the R operator
    
    Parameters:
    
    v - for gaussian vector, this is for g * v. This is optional.
  - getLayers
```
public Layer[] getLayers()
```
  - setLayers
```
public void setLayers(Layer[] layers)
```
  - setNeuralNets
```
public void setNeuralNets(NeuralNetwork[] neuralNets)
```
  - getBackPropRGradient
```
public org.nd4j.linalg.api.ndarray.INDArray getBackPropRGradient(org.nd4j.linalg.api.ndarray.INDArray v)
```
    Gets the back prop gradient with the r operator (gauss vector) This is also called computeGV
    
    Parameters:
    
    v - the v in gaussian newton vector g * v
    
    Returns:
    
    the back prop with r gradient
  - getBackPropGradient2
```
public Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray> getBackPropGradient2()
```
    Gets the back prop gradient with the r operator (gauss vector) and the associated precon matrix This is also called computeGV
    
    Returns:
    
    the back prop with r gradient
  - clone
```
public BaseMultiLayerNetwork clone()
```
    Overrides:
    
    clone in class Object
  - weightMatrices
```
public List<org.nd4j.linalg.api.ndarray.INDArray> weightMatrices()
```
  - 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
  - feedForwardR
```
public List<org.nd4j.linalg.api.ndarray.INDArray> feedForwardR(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
  - backProp
```
public void backProp(double lr,
                     int epochs,
                     TrainingEvaluator eval)
```
    Backpropagation of errors for weights
    
    Parameters:
    
    lr - the learning rate to use
    
    epochs - the number of epochs to iterate (this is already called in finetune)
    
    eval - the evaluator for stopping
  - backProp
```
public void backProp(double lr,
                     int epochs)
```
    Backpropagation of errors for weights
    
    Parameters:
    
    lr - the learning rate to use
    
    epochs - the number of epochs to iterate (this is already called in finetune)
  - isUseDropConnect
```
public boolean isUseDropConnect()
```
  - setUseDropConnect
```
public void setUseDropConnect(boolean useDropConnect)
```
  - 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
  - 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
  - pack
```
public org.nd4j.linalg.api.ndarray.INDArray pack()
```
    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
```
public org.nd4j.linalg.api.ndarray.INDArray pack(List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>> layers)
```
    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
  - score
```
public double score(org.nd4j.linalg.dataset.api.DataSet data)
```
    Sets the input and labels and returns a score for the prediction wrt true labels
    
    Specified by:
    
    score in interface Classifier
    
    Parameters:
    
    data - the data to score
    
    Returns:
    
    the score for the given input,label pairs
  - backPropGradient
```
protected List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>> backPropGradient()
```
    Do a back prop iteration. This involves computing the activations, tracking the last neuralNets weights to revert to in case of convergence, the learning rate being used to iterate and the current epoch
    
    Returns:
    
    whether the training should converge or not
  - unPack
```
public List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>> unPack(org.nd4j.linalg.api.ndarray.INDArray param)
```
    Unpacks a parameter matrix in to a applyTransformToDestination of pairs(w,hbias) triples with layer wise
    
    Parameters:
    
    param - the param vector
    
    Returns:
    
    a segmented list of the param vector
  - backPropGradient2
```
protected List<Pair<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>,Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>>> backPropGradient2()
```
    Do a back prop iteration. This involves computing the activations, tracking the last neuralNets weights to revert to in case of convergence, the learning rate being used to iterate and the current epoch
    
    Returns:
    
    whether the training should converge or not
  - backPropGradientR
```
protected List<Pair<org.nd4j.linalg.api.ndarray.INDArray,org.nd4j.linalg.api.ndarray.INDArray>> backPropGradientR(org.nd4j.linalg.api.ndarray.INDArray v)
```
    Do a back prop iteration. This involves computing the activations, tracking the last neuralNets weights to revert to in case of convergence, the learning rate being used to iterate and the current epoch
    
    Parameters:
    
    v - the v in gaussian newton vector g * v
    
    Returns:
    
    whether the training should converge or not
  - finetune
```
public void finetune(DataSetIterator iter,
                     double lr,
                     int iterations)
```
    Run SGD based on the given labels
    
    Parameters:
    
    iter - fine tune based on the labels
    
    lr - the learning rate during training
    
    iterations - the number of times to iterate
  - finetune
```
public void finetune(DataSetIterator iter,
                     double lr,
                     int iterations,
                     TrainingEvaluator eval)
```
    Run training algorithm based on the datastet iterator
    
    Parameters:
    
    iter - the labels to use
    
    lr - the learning rate during training
    
    iterations - the number of times to iterate
  - finetune
```
public void finetune(org.nd4j.linalg.api.ndarray.INDArray labels,
                     double lr,
                     int iterations)
```
    Run SGD based on the given labels
    
    Parameters:
    
    labels - the labels to use
    
    lr - the learning rate during training
    
    iterations - the number of times to iterate
  - finetune
```
public void finetune(org.nd4j.linalg.api.ndarray.INDArray labels,
                     double lr,
                     int iterations,
                     TrainingEvaluator eval)
```
    Run training algorithm based on the given labels
    
    Parameters:
    
    labels - the labels to use
    
    lr - the learning rate during training
    
    iterations - the number of times to iterate
  - 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
  - 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 examples,
                org.nd4j.linalg.api.ndarray.INDArray labels)
```
    Fit the model
    
    Specified by:
    
    fit in interface Classifier
    
    Parameters:
    
    examples - the examples to classify (one example in each row)
    
    labels - the example labels(a binary outcome matrix)
  - 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 x)
```
    Label the probabilities of the input
    
    Parameters:
    
    x - 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
  - 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
  - write
```
public void write(OutputStream os)
```
    Specified by:
    
    write in interface Persistable
  - load
```
public void load(InputStream is)
```
    Load (using ObjectInputStream
    
    Specified by:
    
    load in interface Persistable
    
    Parameters:
    
    is - the input stream to load from (usually a file)
  - update
```
public void update(BaseMultiLayerNetwork 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
  - score
```
public double score(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:
    
    score 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 wrt true labels
    
    Parameters:
    
    data - the data to score
    
    Returns:
    
    the score for the given input,label pairs
  - score
```
public double score()
```
    Score of the model (relative to the objective function)
    
    Specified by:
    
    score in interface Classifier
    
    Specified by:
    
    score in interface Model
    
    Returns:
    
    the score of the model (relative to the objective function)
  - score
```
public double score(org.nd4j.linalg.api.ndarray.INDArray param)
```
    Score of the model (relative to the objective function)
    
    Parameters:
    
    param - the current parameters
    
    Returns:
    
    the score of the model (relative to the objective function)
  - applyTransforms
```
protected void applyTransforms()
```
  - createLayer
```
public abstract NeuralNetwork createLayer(org.nd4j.linalg.api.ndarray.INDArray input,
                                          org.nd4j.linalg.api.ndarray.INDArray W,
                                          org.nd4j.linalg.api.ndarray.INDArray hbias,
                                          org.nd4j.linalg.api.ndarray.INDArray vBias,
                                          int index)
```
    Creates a layer depending on the index. The main reason this matters is for continuous variations such as the DBN where the first layer needs to be an RBM for continuous inputs.
    
    Parameters:
    
    input - the input to the layer
    
    W - the weight vector
    
    hbias - the hidden bias
    
    vBias - the visible bias
    
    index - the index of the layer
    
    Returns:
    
    a neural network layer such as RBM
  - pretrain
```
public abstract void pretrain(DataSetIterator iter,
                              Object[] otherParams)
```
  - pretrain
```
public abstract void pretrain(org.nd4j.linalg.api.ndarray.INDArray input,
                              Object[] otherParams)
```
  - createNetworkLayers
```
public abstract NeuralNetwork[] createNetworkLayers(int numLayers)
```
  - createHiddenLayer
```
public Layer createHiddenLayer(int index,
                               org.nd4j.linalg.api.ndarray.INDArray layerInput)
```
    Creates a hidden layer with the given parameters. The default implementation is a binomial sampling hidden layer, but this can be overridden for other kinds of hidden units
    
    Parameters:
    
    layerInput - the layer starting input for generating weights
    
    Returns:
    
    a hidden layer with the given parameters
  - merge
```
public void merge(BaseMultiLayerNetwork 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
  - getLabels
```
public org.nd4j.linalg.api.ndarray.INDArray getLabels()
```
  - setInput
```
public void setInput(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Note that if input isn't null and the neuralNets are null, this is a way of initializing the neural network
    
    Parameters:
    
    input -
  - isShouldBackProp
```
public boolean isShouldBackProp()
```
  - getInput
```
public org.nd4j.linalg.api.ndarray.INDArray getInput()
```
  - getNeuralNets
```
public NeuralNetwork[] getNeuralNets()
```
  - isForceNumEpochs
```
public boolean isForceNumEpochs()
```
  - getHiddenLayerSizes
```
public int[] getHiddenLayerSizes()
```
  - setHiddenLayerSizes
```
public void setHiddenLayerSizes(int[] hiddenLayerSizes)
```
  - getWeightTransforms
```
public Map<Integer,org.nd4j.linalg.transformation.MatrixTransform> getWeightTransforms()
```
  - setLabels
```
public void setLabels(org.nd4j.linalg.api.ndarray.INDArray labels)
```
  - setForceNumEpochs
```
public void setForceNumEpochs(boolean forceNumEpochs)
```
  - isSampleFromHiddenActivations
```
public boolean isSampleFromHiddenActivations()
```
  - setSampleFromHiddenActivations
```
public void setSampleFromHiddenActivations(boolean sampleFromHiddenActivations)
```
  - getHiddenBiasTransforms
```
public Map<Integer,org.nd4j.linalg.transformation.MatrixTransform> getHiddenBiasTransforms()
```
  - getVisibleBiasTransforms
```
public Map<Integer,org.nd4j.linalg.transformation.MatrixTransform> getVisibleBiasTransforms()
```
  - getnLayers
```
public int getnLayers()
```
  - setnLayers
```
public void setnLayers(int nLayers)
```
  - setShouldBackProp
```
public void setShouldBackProp(boolean shouldBackProp)
```
  - setLayers
```
public void setLayers(NeuralNetwork[] layers)
```
  - isUseGaussNewtonVectorProductBackProp
```
public boolean isUseGaussNewtonVectorProductBackProp()
```
  - setUseGaussNewtonVectorProductBackProp
```
public void setUseGaussNewtonVectorProductBackProp(boolean useGaussNewtonVectorProductBackProp)
```
  - getMask
```
public org.nd4j.linalg.api.ndarray.INDArray getMask()
```
  - setMask
```
public void setMask(org.nd4j.linalg.api.ndarray.INDArray mask)
```
  - clearInput
```
public void clearInput()
```
    Clears the input from all of the neuralNets
  - getOutputLayer
```
public OutputLayer getOutputLayer()
```
  - isLineSearchBackProp
```
public boolean isLineSearchBackProp()
```
  - setLineSearchBackProp
```
public void setLineSearchBackProp(boolean lineSearchBackProp)
```
  - 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
  - startIndexForLayer
```
public BaseMultiLayerNetwork.ParamRange startIndexForLayer(int layer)
```
    Returns a start index for a given layer (neural net or outputlayer)
    
    Parameters:
    
    layer - the layer to getFromOrigin the index for
    
    Returns:
    
    the index for the layer
  - iterate
```
public void iterate(org.nd4j.linalg.api.ndarray.INDArray input,
                    Object[] params)
```
    Run one iteration
    
    Specified by:
    
    iterate in interface Model
    
    Parameters:
    
    input - the input to iterate on
    
    params - the extra params for the neural network(k, corruption level, max epochs,...)
  - fit
```
public void fit(org.nd4j.linalg.api.ndarray.INDArray examples,
                org.nd4j.linalg.api.ndarray.INDArray labels,
                Object[] params)
```
    Fit the model
    
    Specified by:
    
    fit in interface Classifier
    
    Parameters:
    
    examples - the examples to classify (one example in each row)
    
    labels - the example labels(a binary outcome matrix)
    
    params - extra parameters
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.DataSet data,
                Object[] params)
```
    Fit the model
    
    Specified by:
    
    fit in interface Classifier
    
    Parameters:
    
    data - the data to train on
    
    params - extra parameters
  - fit
```
public void fit(org.nd4j.linalg.api.ndarray.INDArray examples,
                int[] labels,
                Object[] params)
```
    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 the number of rows in the example
    
    params - extra parameters
  - iterate
```
public void iterate(org.nd4j.linalg.api.ndarray.INDArray examples,
                    int[] labels,
                    Object[] params)
```
    Iterate once on the model
    
    Specified by:
    
    iterate 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 the number of rows in the example
    
    params - extra parameters

Class BaseMultiLayerNetwork

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Field Detail

hiddenLayerSizes

layers

input

labels

optimizer

weightTransforms

hiddenBiasTransforms

visibleBiasTransforms

shouldBackProp

forceNumEpochs

initCalled

sampleFromHiddenActivations

defaultConfiguration

layerWiseConfigurations

learningRateUpdate

neuralNets

errorTolerance

lineSearchBackProp

mask

useDropConnect

dampingFactor

useGaussNewtonVectorProductBackProp

Constructor Detail

BaseMultiLayerNetwork

BaseMultiLayerNetwork

BaseMultiLayerNetwork

Method Detail

intializeConfigurations

dimensionCheck

transform

getDefaultConfiguration

setDefaultConfiguration

getLayerWiseConfigurations

setLayerWiseConfigurations

initializeLayers

init

activate

activate

activate

finetune

initialize

activationFromPrevLayer

feedForward

feedForward

applyDropConnectIfNecessary

computeDeltasR

dampingUpdate

reductionRatio

computeDeltas2

setParams

fit

computeDeltas

backPropStep

backPropStepR

getLayers

setLayers

setNeuralNets

getBackPropRGradient

getBackPropGradient2

clone

weightMatrices

feedForwardR

feedForwardR

backProp

backProp

isUseDropConnect

setUseDropConnect

params

numParams

pack

pack

score