BaseMultiLayerNetwork (deeplearning4j-core 0.0.3.1 API)

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

All Implemented Interfaces:

Serializable, Persistable

Direct Known Subclasses:

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

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>

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

Field Summary

Fields
Modifier and Type	Field and Description
`protected double`	`dropOut`
`double`	`errorTolerance`
`protected Map<Integer,List<NeuralNetworkGradientListener>>`	`gradientListeners`
`double`	`learningRateUpdate`
`protected NeuralNetwork.LossFunction`	`lossFunction` Which loss function to use: Squared loss, Reconstruction entropy, negative log likelihood
`protected List<MultiLayerGradientListener>`	`multiLayerGradientListeners`
`protected boolean`	`normalizeByInputRows`
`protected NeuralNetwork.OptimizationAlgorithm`	`optimizationAlgorithm` Which optimization algorithm to use: SGD or CG

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`BaseMultiLayerNetwork()`
`protected`	`BaseMultiLayerNetwork(int nIns, int[] hiddenLayerSizes, int nOuts, int nLayers, org.apache.commons.math3.random.RandomGenerator rng)`
`protected`	`BaseMultiLayerNetwork(int nIn, int[] hiddenLayerSizes, int nOuts, int nLayers, org.apache.commons.math3.random.RandomGenerator rng, org.jblas.DoubleMatrix input, org.jblas.DoubleMatrix labels)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`applyTransforms()`
`void`	`asDecoder(BaseMultiLayerNetwork network)` Set as decoder for another neural net designed for encoding (primary output is encoding input)
`void`	`backProp(double lr, int epochs)` Backpropagation of errors for weights
`protected void`	`backPropStep(BaseMultiLayerNetwork revert, double lr, int epoch)` Do a back prop iteration.
`BaseMultiLayerNetwork`	`clone()`
`HiddenLayer`	`createHiddenLayer(int index, int nIn, int nOut, ActivationFunction activation, org.apache.commons.math3.random.RandomGenerator rng, org.jblas.DoubleMatrix layerInput, org.apache.commons.math3.distribution.RealDistribution dist)` Creates a hidden layer with the given parameters.
`abstract NeuralNetwork`	`createLayer(org.jblas.DoubleMatrix input, int nVisible, int nHidden, org.jblas.DoubleMatrix W, org.jblas.DoubleMatrix hbias, org.jblas.DoubleMatrix vBias, org.apache.commons.math3.random.RandomGenerator rng, int index)` Creates a layer depending on the index.
`abstract NeuralNetwork[]`	`createNetworkLayers(int numLayers)`
`void`	`encode(BaseMultiLayerNetwork network)` Transposes this network to turn it in to ad encoder for the given auto encoder networkk
`double`	`fanIn()` Returns the -fanIn to fanIn coefficient used for initializing the weights.
`List<org.jblas.DoubleMatrix>`	`feedForward()` Compute activations from input to output of the output layer
`List<org.jblas.DoubleMatrix>`	`feedForward(org.jblas.DoubleMatrix input)` Compute activations from input to output of the output layer
`void`	`finetune(double lr, int epochs)` Finetunes with the current cached labels
`void`	`finetune(org.jblas.DoubleMatrix labels, double lr, int epochs)` Run SGD based on the given labels
`ActivationFunction`	`getActivation()`
`org.jblas.DoubleMatrix`	`getColumnMeans()`
`org.jblas.DoubleMatrix`	`getColumnStds()`
`org.jblas.DoubleMatrix`	`getColumnSums()`
`org.apache.commons.math3.distribution.RealDistribution`	`getDist()`
`double`	`getDropOut()`
`double`	`getErrorTolerance()`
`double`	`getFanIn()`
`MultiLayerGradient`	`getGradient(Object[] params)` Gets the multi layer gradient for this network.
`Map<Integer,MatrixTransform>`	`getHiddenBiasTransforms()`
`int[]`	`getHiddenLayerSizes()`
`org.jblas.DoubleMatrix`	`getInput()`
`double`	`getL2()`
`org.jblas.DoubleMatrix`	`getLabels()`
`NeuralNetwork[]`	`getLayers()`
`double`	`getLearningRateUpdate()`
`LogisticRegression`	`getLogLayer()`
`NeuralNetwork.LossFunction`	`getLossFunction()`
`double`	`getMomentum()`
`int`	`getnIns()`
`int`	`getnLayers()`
`int`	`getnOuts()`
`NeuralNetwork.OptimizationAlgorithm`	`getOptimizationAlgorithm()`
`MultiLayerNetworkOptimizer`	`getOptimizer()`
`double`	`getReconstructionCrossEntropy()` Returns the sum of the reconstruction entropies divided by the number of layers
`int`	`getRenderWeightsEveryNEpochs()`
`org.apache.commons.math3.random.RandomGenerator`	`getRng()`
`HiddenLayer[]`	`getSigmoidLayers()`
`double`	`getSparsity()`
`Map<Integer,MatrixTransform>`	`getVisibleBiasTransforms()`
`Map<Integer,MatrixTransform>`	`getWeightTransforms()`
`void`	`init()`
`void`	`initialize(DataSet data)` Sets the input and labels from this dataset
`void`	`initializeLayers(org.jblas.DoubleMatrix input)` Base class for initializing the layers based on the input.
`protected void`	`initializeNetwork(NeuralNetwork network)`
`boolean`	`isForceNumEpochs()`
`boolean`	`isNormalizeByInputRows()`
`boolean`	`isShouldBackProp()`
`boolean`	`isShouldInit()`
`boolean`	`isToDecode()`
`boolean`	`isUseAdaGrad()`
`boolean`	`isUseHiddenActivationsForwardProp()`
`boolean`	`isUseRegularization()`
`void`	`load(InputStream is)` Load (using `ObjectInputStream`
`static BaseMultiLayerNetwork`	`loadFromFile(InputStream is)` Load (using `ObjectInputStream`
`void`	`merge(BaseMultiLayerNetwork network, int batchSize)` Merges this network with the other one.
`double`	`negativeLogLikelihood()` Negative log likelihood of the model
`org.jblas.DoubleMatrix`	`predict(org.jblas.DoubleMatrix x)` Label the probabilities of the input
`abstract void`	`pretrain(org.jblas.DoubleMatrix input, Object[] otherParams)` Pretrain the network with the given parameters
`org.jblas.DoubleMatrix`	`reconstruct(org.jblas.DoubleMatrix x)` Reconstruct from the final layer
`org.jblas.DoubleMatrix`	`reconstruct(org.jblas.DoubleMatrix x, int layerNum)` Reconstructs the input.
`void`	`resetAdaGrad(double lr)` Resets adagrad with the given learning rate.
`void`	`setActivation(ActivationFunction activation)`
`void`	`setColumnMeans(org.jblas.DoubleMatrix columnMeans)`
`void`	`setColumnStds(org.jblas.DoubleMatrix columnStds)`
`void`	`setColumnSums(org.jblas.DoubleMatrix columnSums)`
`void`	`setDist(org.apache.commons.math3.distribution.RealDistribution dist)`
`void`	`setDropOut(double dropOut)`
`void`	`setErrorTolerance(double errorTolerance)`
`void`	`setFanIn(double fanIn)`
`void`	`setForceNumEpochs(boolean forceNumEpochs)`
`void`	`setHiddenLayerSizes(int[] hiddenLayerSizes)`
`void`	`setInput(org.jblas.DoubleMatrix input)` Note that if input isn't null and the layers are null, this is a way of initializing the neural network
`void`	`setL2(double l2)`
`void`	`setLabels(org.jblas.DoubleMatrix labels)`
`void`	`setLayers(NeuralNetwork[] layers)`
`void`	`setLearningRateUpdate(double learningRateUpdate)`
`void`	`setLogLayer(LogisticRegression logLayer)`
`void`	`setLossFunction(NeuralNetwork.LossFunction lossFunction)`
`void`	`setMomentum(double momentum)`
`void`	`setnIns(int nIns)`
`void`	`setnLayers(int nLayers)`
`void`	`setNormalizeByInputRows(boolean normalizeByInputRows)`
`void`	`setnOuts(int nOuts)`
`void`	`setOptimizationAlgorithm(NeuralNetwork.OptimizationAlgorithm optimizationAlgorithm)`
`void`	`setOptimizer(MultiLayerNetworkOptimizer optimizer)`
`void`	`setRenderWeightsEveryNEpochs(int renderWeightsEveryNEpochs)`
`void`	`setRng(org.apache.commons.math3.random.RandomGenerator rng)`
`void`	`setShouldBackProp(boolean shouldBackProp)`
`void`	`setShouldInit(boolean shouldInit)`
`void`	`setSigmoidLayers(HiddenLayer[] sigmoidLayers)`
`void`	`setSparsity(double sparsity)`
`void`	`setToDecode(boolean toDecode)`
`void`	`setUseAdaGrad(boolean useAdaGrad)`
`void`	`setUseHiddenActivationsForwardProp(boolean useHiddenActivationsForwardProp)`
`void`	`setUseRegularization(boolean useRegularization)`
`void`	`setWeightTransforms(Map<Integer,MatrixTransform> weightTransforms)`
`void`	`synchonrizeRng()` Synchronizes the rng, this is mean for use with scale out methods
`abstract void`	`trainNetwork(org.jblas.DoubleMatrix input, org.jblas.DoubleMatrix labels, Object[] otherParams)` Train the network running some unsupervised pretraining followed by SGD/finetune
`protected void`	`update(BaseMultiLayerNetwork network)` Assigns the parameters of this model to the ones specified by this network.
`void`	`write(OutputStream os)`

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

- Field Detail
  - learningRateUpdate
```
public double learningRateUpdate
```
  - errorTolerance
```
public double errorTolerance
```
  - gradientListeners
```
protected Map<Integer,List<NeuralNetworkGradientListener>> gradientListeners
```
  - multiLayerGradientListeners
```
protected List<MultiLayerGradientListener> multiLayerGradientListeners
```
  - dropOut
```
protected double dropOut
```
  - normalizeByInputRows
```
protected boolean normalizeByInputRows
```
  - optimizationAlgorithm
```
protected NeuralNetwork.OptimizationAlgorithm optimizationAlgorithm
```
    Which optimization algorithm to use: SGD or CG
  - lossFunction
```
protected NeuralNetwork.LossFunction lossFunction
```
    Which loss function to use: Squared loss, Reconstruction entropy, negative log likelihood
- Constructor Detail
  - BaseMultiLayerNetwork
```
protected BaseMultiLayerNetwork()
```
  - BaseMultiLayerNetwork
```
protected BaseMultiLayerNetwork(int nIns,
                     int[] hiddenLayerSizes,
                     int nOuts,
                     int nLayers,
                     org.apache.commons.math3.random.RandomGenerator rng)
```
  - BaseMultiLayerNetwork
```
protected BaseMultiLayerNetwork(int nIn,
                     int[] hiddenLayerSizes,
                     int nOuts,
                     int nLayers,
                     org.apache.commons.math3.random.RandomGenerator rng,
                     org.jblas.DoubleMatrix input,
                     org.jblas.DoubleMatrix labels)
```
- Method Detail
  - fanIn
```
public double fanIn()
```
    Returns the -fanIn to fanIn coefficient used for initializing the weights. The default is 1 / nIns
    
    Returns:
    the fan in coefficient
  - synchonrizeRng
```
public void synchonrizeRng()
```
    Synchronizes the rng, this is mean for use with scale out methods
  - resetAdaGrad
```
public void resetAdaGrad(double lr)
```
    Resets adagrad with the given learning rate. This is used for switching from the pretrain to finetune phase.
    
    Parameters:
    lr - the new master learning rate to use
  - getReconstructionCrossEntropy
```
public double getReconstructionCrossEntropy()
```
    Returns the sum of the reconstruction entropies divided by the number of layers
    
    Returns:
    the average reconstruction entropy across layers
  - asDecoder
```
public void asDecoder(BaseMultiLayerNetwork network)
```
    Set as decoder for another neural net designed for encoding (primary output is encoding input)
    
    Parameters:
    network - the network to decode
  - initializeLayers
```
public void initializeLayers(org.jblas.DoubleMatrix input)
```
    Base class for initializing the layers 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()
```
  - initializeNetwork
```
protected void initializeNetwork(NeuralNetwork network)
```
  - 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(DataSet data)
```
    Sets the input and labels from this dataset
    
    Parameters:
    data - the dataset to initialize with
  - getGradient
```
public MultiLayerGradient getGradient(Object[] params)
```
    Gets the multi layer gradient for this network. This includes calculating the gradients for each layer
    
    Parameters:
    params - the params to pass (k, corruption level,...)
    lr - the learning rate to use for logistic regression
    
    Returns:
    the multi layer gradient for the whole network
  - feedForward
```
public List<org.jblas.DoubleMatrix> feedForward()
```
    Compute activations from input to output of the output layer
    
    Returns:
    the list of activations for each layer
  - feedForward
```
public List<org.jblas.DoubleMatrix> feedForward(org.jblas.DoubleMatrix input)
```
    Compute activations from input to output of the output layer
    
    Returns:
    the list of activations for each layer
  - clone
```
public BaseMultiLayerNetwork clone()
```
    Overrides:
    
    clone in class Object
  - 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)
  - backPropStep
```
protected void backPropStep(BaseMultiLayerNetwork revert,
                double lr,
                int epoch)
```
    Do a back prop iteration. This involves computing the activations, tracking the last layers weights to revert to in case of convergence, the learning rate being used to train and the current epoch
    
    Parameters:
    lastEntropy - the last error to be had on the previous epoch
    revert - the best network so far
    lr - the learning rate to use for training
    epoch - the epoch to use
  - finetune
```
public void finetune(org.jblas.DoubleMatrix labels,
            double lr,
            int epochs)
```
    Run SGD based on the given labels
    
    Parameters:
    labels - the labels to use
    lr - the learning rate during training
    epochs - the number of times to iterate
  - predict
```
public org.jblas.DoubleMatrix predict(org.jblas.DoubleMatrix 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.jblas.DoubleMatrix reconstruct(org.jblas.DoubleMatrix x,
                                 int layerNum)
```
    Reconstructs the input. This is equivalent functionality to a deep autoencoder.
    
    Parameters:
    x - the input to reconstruct
    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
  - reconstruct
```
public org.jblas.DoubleMatrix reconstruct(org.jblas.DoubleMatrix x)
```
    Reconstruct from the final layer
    
    Parameters:
    x - the input to reconstruct
    
    Returns:
    the reconstructed input
  - 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)
  - loadFromFile
```
public static BaseMultiLayerNetwork loadFromFile(InputStream is)
```
    Load (using ObjectInputStream
    
    Parameters:
    is - the input stream to load from (usually a file)
  - update
```
protected 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 get parameters from
  - negativeLogLikelihood
```
public double negativeLogLikelihood()
```
    Negative log likelihood of the model
    
    Returns:
    the negative log likelihood of the model
  - trainNetwork
```
public abstract void trainNetwork(org.jblas.DoubleMatrix input,
                org.jblas.DoubleMatrix labels,
                Object[] otherParams)
```
    Train the network running some unsupervised pretraining followed by SGD/finetune
    
    Parameters:
    input - the input to train on
    labels - the labels for the training examples(a matrix of the following format: [0,1,0] where 0 represents the labels its not and 1 represents labels for the positive outcomes
    otherParams - the other parameters for child classes (algorithm specific parameters such as corruption level for SDA)
  - pretrain
```
public abstract void pretrain(org.jblas.DoubleMatrix input,
            Object[] otherParams)
```
    Pretrain the network with the given parameters
    
    Parameters:
    input - the input to train ons
    otherParams - the other parameters for child classes (algorithm specific parameters such as corruption level for SDA)
  - applyTransforms
```
protected void applyTransforms()
```
  - createLayer
```
public abstract NeuralNetwork createLayer(org.jblas.DoubleMatrix input,
                        int nVisible,
                        int nHidden,
                        org.jblas.DoubleMatrix W,
                        org.jblas.DoubleMatrix hbias,
                        org.jblas.DoubleMatrix vBias,
                        org.apache.commons.math3.random.RandomGenerator rng,
                        int index)
```
    Creates a layer depending on the index. The main reason this matters is for continuous variations such as the CDBN where the first layer needs to be an CRBM for continuous inputs. Please be sure to call super.initializeNetwork to handle the passing of baseline parameters such as fanin and rendering.
    
    Parameters:
    input - the input to the layer
    nVisible - the number of visible inputs
    nHidden - the number of hidden units
    W - the weight vector
    hbias - the hidden bias
    vBias - the visible bias
    rng - the rng to use (THiS IS IMPORTANT; YOU DO NOT WANT TO HAVE A MIS REFERENCED RNG OTHERWISE NUMBERS WILL BE MEANINGLESS)
    index - the index of the layer
    
    Returns:
    a neural network layer such as RBM
  - createNetworkLayers
```
public abstract NeuralNetwork[] createNetworkLayers(int numLayers)
```
  - createHiddenLayer
```
public HiddenLayer createHiddenLayer(int index,
                            int nIn,
                            int nOut,
                            ActivationFunction activation,
                            org.apache.commons.math3.random.RandomGenerator rng,
                            org.jblas.DoubleMatrix layerInput,
                            org.apache.commons.math3.distribution.RealDistribution dist)
```
    Creates a hidden layer with the given parameters. The default implementation is a binomial sampling hidden layer, but this can be overriden for other kinds of hidden units
    
    Parameters:
    nIn - the number of inputs
    nOut - the number of outputs
    activation - the activation function for the layer
    rng - the rng to use for sampling
    layerInput - the layer starting input
    dist - the probability distribution to use for generating weights
    
    Returns:
    a hidden layer with the given paremters
  - 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 layers as well as hidden layers and logistic layers
    
    Parameters:
    network - the network to merge with
    batchSize - the batch size (number of training examples) to average by
  - encode
```
public void encode(BaseMultiLayerNetwork network)
```
    Transposes this network to turn it in to ad encoder for the given auto encoder networkk
    
    Parameters:
    network - the network to decode
  - getLabels
```
public org.jblas.DoubleMatrix getLabels()
```
  - getLogLayer
```
public LogisticRegression getLogLayer()
```
  - setInput
```
public void setInput(org.jblas.DoubleMatrix input)
```
    Note that if input isn't null and the layers are null, this is a way of initializing the neural network
    
    Parameters:
    input -
  - isShouldBackProp
```
public boolean isShouldBackProp()
```
  - getOptimizationAlgorithm
```
public NeuralNetwork.OptimizationAlgorithm getOptimizationAlgorithm()
```
  - setOptimizationAlgorithm
```
public void setOptimizationAlgorithm(NeuralNetwork.OptimizationAlgorithm optimizationAlgorithm)
```
  - getLossFunction
```
public NeuralNetwork.LossFunction getLossFunction()
```
  - setLossFunction
```
public void setLossFunction(NeuralNetwork.LossFunction lossFunction)
```
  - getInput
```
public org.jblas.DoubleMatrix getInput()
```
  - getSigmoidLayers
```
public HiddenLayer[] getSigmoidLayers()
```
  - getLayers
```
public NeuralNetwork[] getLayers()
```
  - isForceNumEpochs
```
public boolean isForceNumEpochs()
```
  - getColumnSums
```
public org.jblas.DoubleMatrix getColumnSums()
```
  - setColumnSums
```
public void setColumnSums(org.jblas.DoubleMatrix columnSums)
```
  - getHiddenLayerSizes
```
public int[] getHiddenLayerSizes()
```
  - setHiddenLayerSizes
```
public void setHiddenLayerSizes(int[] hiddenLayerSizes)
```
  - getRng
```
public org.apache.commons.math3.random.RandomGenerator getRng()
```
  - setRng
```
public void setRng(org.apache.commons.math3.random.RandomGenerator rng)
```
  - getDist
```
public org.apache.commons.math3.distribution.RealDistribution getDist()
```
  - setDist
```
public void setDist(org.apache.commons.math3.distribution.RealDistribution dist)
```
  - getOptimizer
```
public MultiLayerNetworkOptimizer getOptimizer()
```
  - setOptimizer
```
public void setOptimizer(MultiLayerNetworkOptimizer optimizer)
```
  - getActivation
```
public ActivationFunction getActivation()
```
  - setActivation
```
public void setActivation(ActivationFunction activation)
```
  - isToDecode
```
public boolean isToDecode()
```
  - setToDecode
```
public void setToDecode(boolean toDecode)
```
  - isShouldInit
```
public boolean isShouldInit()
```
  - setShouldInit
```
public void setShouldInit(boolean shouldInit)
```
  - getFanIn
```
public double getFanIn()
```
  - setFanIn
```
public void setFanIn(double fanIn)
```
  - getRenderWeightsEveryNEpochs
```
public int getRenderWeightsEveryNEpochs()
```
  - setRenderWeightsEveryNEpochs
```
public void setRenderWeightsEveryNEpochs(int renderWeightsEveryNEpochs)
```
  - getWeightTransforms
```
public Map<Integer,MatrixTransform> getWeightTransforms()
```
  - setWeightTransforms
```
public void setWeightTransforms(Map<Integer,MatrixTransform> weightTransforms)
```
  - getSparsity
```
public double getSparsity()
```
  - setSparsity
```
public void setSparsity(double sparsity)
```
  - getLearningRateUpdate
```
public double getLearningRateUpdate()
```
  - setLearningRateUpdate
```
public void setLearningRateUpdate(double learningRateUpdate)
```
  - getErrorTolerance
```
public double getErrorTolerance()
```
  - setErrorTolerance
```
public void setErrorTolerance(double errorTolerance)
```
  - setLabels
```
public void setLabels(org.jblas.DoubleMatrix labels)
```
  - setForceNumEpochs
```
public void setForceNumEpochs(boolean forceNumEpochs)
```
  - getColumnMeans
```
public org.jblas.DoubleMatrix getColumnMeans()
```
  - setColumnMeans
```
public void setColumnMeans(org.jblas.DoubleMatrix columnMeans)
```
  - getColumnStds
```
public org.jblas.DoubleMatrix getColumnStds()
```
  - setColumnStds
```
public void setColumnStds(org.jblas.DoubleMatrix columnStds)
```
  - isUseAdaGrad
```
public boolean isUseAdaGrad()
```
  - setUseAdaGrad
```
public void setUseAdaGrad(boolean useAdaGrad)
```
  - isNormalizeByInputRows
```
public boolean isNormalizeByInputRows()
```
  - setNormalizeByInputRows
```
public void setNormalizeByInputRows(boolean normalizeByInputRows)
```
  - isUseHiddenActivationsForwardProp
```
public boolean isUseHiddenActivationsForwardProp()
```
  - setUseHiddenActivationsForwardProp
```
public void setUseHiddenActivationsForwardProp(boolean useHiddenActivationsForwardProp)
```
  - getDropOut
```
public double getDropOut()
```
  - setDropOut
```
public void setDropOut(double dropOut)
```
  - getHiddenBiasTransforms
```
public Map<Integer,MatrixTransform> getHiddenBiasTransforms()
```
  - getVisibleBiasTransforms
```
public Map<Integer,MatrixTransform> getVisibleBiasTransforms()
```
  - getnIns
```
public int getnIns()
```
  - setnIns
```
public void setnIns(int nIns)
```
  - getnOuts
```
public int getnOuts()
```
  - setnOuts
```
public void setnOuts(int nOuts)
```
  - getnLayers
```
public int getnLayers()
```
  - setnLayers
```
public void setnLayers(int nLayers)
```
  - getMomentum
```
public double getMomentum()
```
  - setMomentum
```
public void setMomentum(double momentum)
```
  - getL2
```
public double getL2()
```
  - setL2
```
public void setL2(double l2)
```
  - isUseRegularization
```
public boolean isUseRegularization()
```
  - setUseRegularization
```
public void setUseRegularization(boolean useRegularization)
```
  - setSigmoidLayers
```
public void setSigmoidLayers(HiddenLayer[] sigmoidLayers)
```
  - setLogLayer
```
public void setLogLayer(LogisticRegression logLayer)
```
  - setShouldBackProp
```
public void setShouldBackProp(boolean shouldBackProp)
```
  - setLayers
```
public void setLayers(NeuralNetwork[] layers)
```

Class BaseMultiLayerNetwork

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

learningRateUpdate

errorTolerance

gradientListeners

multiLayerGradientListeners

dropOut

normalizeByInputRows

optimizationAlgorithm

lossFunction

Constructor Detail

BaseMultiLayerNetwork

BaseMultiLayerNetwork

BaseMultiLayerNetwork

Method Detail

fanIn

synchonrizeRng

resetAdaGrad

getReconstructionCrossEntropy

asDecoder

initializeLayers

init

initializeNetwork

finetune

initialize

getGradient

feedForward

feedForward

clone

backProp

backPropStep

finetune

predict

reconstruct

reconstruct

write

load

loadFromFile

update

negativeLogLikelihood

trainNetwork

pretrain

applyTransforms

createLayer

createNetworkLayers

createHiddenLayer

merge

encode

getLabels

getLogLayer

setInput

isShouldBackProp

getOptimizationAlgorithm

setOptimizationAlgorithm

getLossFunction

setLossFunction

getInput

getSigmoidLayers

getLayers

isForceNumEpochs

getColumnSums

setColumnSums

getHiddenLayerSizes

setHiddenLayerSizes

getRng

setRng

getDist

setDist

getOptimizer

setOptimizer

getActivation

setActivation

isToDecode

setToDecode

isShouldInit