BaseMultiLayerNetwork (deeplearning4j-core 0.0.0.2 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

double errorTolerance

NeuralNetwork[] layers

double learningRateUpdate

Fields
Modifier and Type	Field and Description
`double`	`errorTolerance`
`NeuralNetwork[]`	`layers`
`double`	`learningRateUpdate`

Constructor Summary

Constructors
Constructor and Description
`BaseMultiLayerNetwork()`
`BaseMultiLayerNetwork(int n_ins, int[] hidden_layer_sizes, int n_outs, int n_layers, org.apache.commons.math3.random.RandomGenerator rng)`
`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 boolean`	`backPropStep(Double lastEntropy, BaseMultiLayerNetwork revert, double lr, int epoch)` Do a back prop iteration.
`protected BaseMultiLayerNetwork`	`clone()`
`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(org.jblas.DoubleMatrix input)` Compute activations from input to output of the output layer
`void`	`finetune(double lr, int epochs)`
`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`	`getErrorTolerance()`
`double`	`getFanIn()`
`int[]`	`getHiddenLayerSizes()`
`org.jblas.DoubleMatrix`	`getInput()`
`double`	`getL2()`
`org.jblas.DoubleMatrix`	`getLabels()`
`NeuralNetwork[]`	`getLayers()`
`double`	`getLearningRateUpdate()`
`LogisticRegression`	`getLogLayer()`
`double`	`getMomentum()`
`int`	`getnIns()`
`int`	`getnLayers()`
`int`	`getnOuts()`
`MultiLayerNetworkOptimizer`	`getOptimizer()`
`int`	`getRenderWeightsEveryNEpochs()`
`org.apache.commons.math3.random.RandomGenerator`	`getRng()`
`HiddenLayer[]`	`getSigmoidLayers()`
`double`	`getSparsity()`
`Map<Integer,MatrixTransform>`	`getWeightTransforms()`
`void`	`initializeLayers(org.jblas.DoubleMatrix input)` Base class for initializing the layers based on the input.
`protected void`	`initializeNetwork(NeuralNetwork network)`
`boolean`	`isForceNumEpochs()`
`boolean`	`isShouldBackProp()`
`boolean`	`isShouldInit()`
`boolean`	`isToDecode()`
`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
`org.jblas.DoubleMatrix`	`reconstruct(org.jblas.DoubleMatrix x)`
`org.jblas.DoubleMatrix`	`reconstruct(org.jblas.DoubleMatrix x, int layerNum)` Reconstructs the input.
`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`	`setErrorTolerance(double errorTolerance)`
`void`	`setFanIn(double fanIn)`
`void`	`setForceNumEpochs(boolean forceNumEpochs)`
`void`	`setHiddenLayerSizes(int[] hiddenLayerSizes)`
`void`	`setInput(org.jblas.DoubleMatrix input)`
`void`	`setL2(double l2)`
`void`	`setLabels(org.jblas.DoubleMatrix labels)`
`void`	`setLayers(NeuralNetwork[] layers)`
`void`	`setLearningRateUpdate(double learningRateUpdate)`
`void`	`setLogLayer(LogisticRegression logLayer)`
`void`	`setMomentum(double momentum)`
`void`	`setnIns(int nIns)`
`void`	`setnLayers(int nLayers)`
`void`	`setnOuts(int nOuts)`
`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`	`setUseRegularization(boolean useRegularization)`
`void`	`setWeightTransforms(Map<Integer,MatrixTransform> weightTransforms)`
`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)` Serializes this to the output stream.

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

Field Detail

learningRateUpdate
```
public double learningRateUpdate
```

layers
```
public NeuralNetwork[] layers
```

errorTolerance
```
public double errorTolerance
```

Constructor Detail

BaseMultiLayerNetwork
```
public BaseMultiLayerNetwork()
```

BaseMultiLayerNetwork

public BaseMultiLayerNetwork(int n_ins,
                     int[] hidden_layer_sizes,
                     int n_outs,
                     int n_layers,
                     org.apache.commons.math3.random.RandomGenerator rng)

BaseMultiLayerNetwork

public 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
- 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
- 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)
```
- initializeNetwork
```
protected void initializeNetwork(NeuralNetwork network)
```
- finetune
```
public void finetune(double lr,
            int epochs)
```
- getLabels
```
public org.jblas.DoubleMatrix getLabels()
```
- getLogLayer
```
public LogisticRegression getLogLayer()
```
- setInput
```
public void setInput(org.jblas.DoubleMatrix input)
```
- getInput
```
public org.jblas.DoubleMatrix getInput()
```
- getSigmoidLayers
```
public HiddenLayer[] getSigmoidLayers()
```
- getLayers
```
public NeuralNetwork[] getLayers()
```
- 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
```
protected 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 boolean backPropStep(Double lastEntropy,
                   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
  
  Returns:
  whether the training should converge or not
- 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)
```
- write
```
public void write(OutputStream os)
```
  Serializes this to the output stream.
  
  Specified by:
  
  write in interface Persistable
  
  Parameters:
  os - the output stream to write to
- 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)
- applyTransforms
```
protected void applyTransforms()
```
- isShouldBackProp
```
public boolean isShouldBackProp()
```
- 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)
```
- 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
- 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)
```

Class BaseMultiLayerNetwork

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

learningRateUpdate

layers

errorTolerance

Constructor Detail

BaseMultiLayerNetwork

BaseMultiLayerNetwork

BaseMultiLayerNetwork

Method Detail

fanIn

asDecoder

initializeLayers

getnIns

setnIns

getnOuts

setnOuts

getnLayers

setnLayers

getMomentum

setMomentum

getL2

setL2

isUseRegularization

setUseRegularization

setSigmoidLayers

setLogLayer

setShouldBackProp

setLayers

initializeNetwork

finetune

getLabels

getLogLayer

setInput

getInput

getSigmoidLayers

getLayers

feedForward

clone

backProp

backPropStep

finetune

predict

reconstruct

reconstruct

write

load

loadFromFile

update

negativeLogLikelihood

trainNetwork

applyTransforms

isShouldBackProp

createLayer

createNetworkLayers

merge

encode

isForceNumEpochs

getColumnSums

setColumnSums

getHiddenLayerSizes

setHiddenLayerSizes

getRng

setRng

getDist

setDist

getOptimizer

setOptimizer

getActivation

setActivation

isToDecode

setToDecode

isShouldInit

setShouldInit

getFanIn