NeuralNetConfiguration (deeplearning4j-core 0.0.3.2 API)

java.lang.Object
- org.deeplearning4j.nn.conf.NeuralNetConfiguration

All Implemented Interfaces:

Serializable, Cloneable
```
public class NeuralNetConfiguration
extends Object
implements Serializable, Cloneable
```
A Serializable configuration for neural nets that covers per layer parameters

Author:

Adam Gibson

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class NeuralNetConfiguration.ActivationType

static class NeuralNetConfiguration.Builder

Nested Classes
Modifier and Type	Class and Description
`static class`	`NeuralNetConfiguration.ActivationType`
`static class`	`NeuralNetConfiguration.Builder`

Field Summary

Fields
Modifier and Type	Field and Description
`protected org.nd4j.linalg.api.activation.ActivationFunction`	`activationFunction`
`protected boolean`	`applySparsity`
`protected boolean`	`concatBiases`
`protected boolean`	`constrainGradientToUnitNorm`
`protected float`	`corruptionLevel`
`protected org.apache.commons.math3.distribution.RealDistribution`	`dist`
`protected float`	`dropOut`
`protected int`	`k`
`protected float`	`l2`
`protected org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction`	`lossFunction`
`protected float`	`momentum`
`protected Map<Integer,Float>`	`momentumAfter`
`protected int`	`nIn`
`protected int`	`nOut`
`protected int`	`numIterations`
`protected NeuralNetwork.OptimizationAlgorithm`	`optimizationAlgo`
`protected int`	`renderWeightsEveryNumEpochs`
`protected int`	`resetAdaGradIterations`
`protected org.apache.commons.math3.random.RandomGenerator`	`rng`
`protected long`	`seed`
`protected boolean`	`useRegularization`
`protected WeightInit`	`weightInit`

Constructor Summary

Constructors
Constructor and Description
`NeuralNetConfiguration()`
NeuralNetConfiguration(float sparsity, boolean useAdaGrad, float lr, int k, float corruptionLevel, int numIterations, float momentum, float l2, boolean useRegularization, Map<Integer,Float> momentumAfter, int resetAdaGradIterations, float dropOut, boolean applySparsity, WeightInit weightInit, NeuralNetwork.OptimizationAlgorithm optimizationAlgo, org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction lossFunction, int renderWeightsEveryNumEpochs, boolean concatBiases, boolean constrainGradientToUnitNorm, org.apache.commons.math3.random.RandomGenerator rng, org.apache.commons.math3.distribution.RealDistribution dist, long seed, int nIn, int nOut, org.nd4j.linalg.api.activation.ActivationFunction activationFunction, RBM.VisibleUnit visibleUnit, RBM.HiddenUnit hiddenUnit, NeuralNetConfiguration.ActivationType activationType, int[] weightShape, int[] filterSize, int numFeatureMaps, int[] stride, int[] featureMapSize, int numInFeatureMaps)
`NeuralNetConfiguration(NeuralNetConfiguration neuralNetConfiguration)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`NeuralNetConfiguration`	`clone()` Creates and returns a copy of this object.
`boolean`	`equals(Object o)`
`org.nd4j.linalg.api.activation.ActivationFunction`	`getActivationFunction()`
`NeuralNetConfiguration.ActivationType`	`getActivationType()`
`float`	`getCorruptionLevel()`
`org.apache.commons.math3.distribution.RealDistribution`	`getDist()`
`float`	`getDropOut()`
`int[]`	`getFeatureMapSize()`
`int[]`	`getFilterSize()`
`int`	`getFinetuneEpochs()`
`float`	`getFinetuneLearningRate()`
`RBM.HiddenUnit`	`getHiddenUnit()`
`int`	`getK()`
`float`	`getL2()`
`org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction`	`getLossFunction()`
`float`	`getLr()`
`float`	`getMomentum()`
`Map<Integer,Float>`	`getMomentumAfter()`
`int`	`getnIn()`
`int`	`getnOut()`
`int`	`getNumFeatureMaps()`
`int`	`getNumInFeatureMaps()`
`int`	`getNumIterations()`
`NeuralNetwork.OptimizationAlgorithm`	`getOptimizationAlgo()`
`int`	`getPretrainEpochs()`
`int`	`getRenderWeightsEveryNumEpochs()`
`int`	`getResetAdaGradIterations()`
`org.apache.commons.math3.random.RandomGenerator`	`getRng()`
`long`	`getSeed()`
`float`	`getSparsity()`
`int[]`	`getStride()`
`RBM.VisibleUnit`	`getVisibleUnit()`
`WeightInit`	`getWeightInit()`
`int[]`	`getWeightShape()`
`int`	`hashCode()`
`boolean`	`isApplySparsity()`
`boolean`	`isConcatBiases()`
`boolean`	`isConstrainGradientToUnitNorm()`
`boolean`	`isUseAdaGrad()`
`boolean`	`isUseRegularization()`
`void`	`setActivationFunction(org.nd4j.linalg.api.activation.ActivationFunction activationFunction)`
`void`	`setActivationType(NeuralNetConfiguration.ActivationType activationType)`
`void`	`setApplySparsity(boolean applySparsity)`
`void`	`setConcatBiases(boolean concatBiases)`
`void`	`setConstrainGradientToUnitNorm(boolean constrainGradientToUnitNorm)`
`void`	`setCorruptionLevel(float corruptionLevel)`
`void`	`setDist(org.apache.commons.math3.distribution.RealDistribution dist)`
`void`	`setDropOut(float dropOut)`
`void`	`setFeatureMapSize(int[] featureMapSize)`
`void`	`setFilterSize(int[] filterSize)`
`void`	`setFinetuneEpochs(int finetuneEpochs)`
`void`	`setFinetuneLearningRate(float finetuneLearningRate)`
`void`	`setHiddenUnit(RBM.HiddenUnit hiddenUnit)`
`void`	`setK(int k)`
`void`	`setL2(float l2)`
`void`	`setLossFunction(org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction lossFunction)`
`void`	`setLr(float lr)`
`void`	`setMomentum(float momentum)`
`void`	`setMomentumAfter(Map<Integer,Float> momentumAfter)`
`void`	`setnIn(int nIn)`
`void`	`setnOut(int nOut)`
`void`	`setNumFeatureMaps(int numFeatureMaps)`
`void`	`setNumInFeatureMaps(int numInFeatureMaps)`
`void`	`setNumIterations(int numIterations)`
`void`	`setOptimizationAlgo(NeuralNetwork.OptimizationAlgorithm optimizationAlgo)`
`void`	`setPretrainEpochs(int pretrainEpochs)`
`void`	`setPretrainLearningRate(float pretrainLearningRate)`
`void`	`setRenderWeightsEveryNumEpochs(int renderWeightsEveryNumEpochs)`
`void`	`setResetAdaGradIterations(int resetAdaGradIterations)`
`void`	`setRng(org.apache.commons.math3.random.RandomGenerator rng)`
`void`	`setSeed(long seed)`
`void`	`setSparsity(float sparsity)`
`void`	`setStride(int[] stride)`
`void`	`setUseAdaGrad(boolean useAdaGrad)`
`void`	`setUseRegularization(boolean useRegularization)`
`void`	`setVisibleUnit(RBM.VisibleUnit visibleUnit)`
`void`	`setWeightInit(WeightInit weightInit)`
`void`	`setWeightShape(int[] weightShape)`
`String`	`toString()`

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

Field Detail

k
```
protected int k
```

corruptionLevel
```
protected float corruptionLevel
```

numIterations
```
protected int numIterations
```

momentum
```
protected float momentum
```

l2
```
protected float l2
```

useRegularization
```
protected boolean useRegularization
```

momentumAfter

protected Map<Integer,Float> momentumAfter

resetAdaGradIterations
```
protected int resetAdaGradIterations
```

dropOut
```
protected float dropOut
```

applySparsity
```
protected boolean applySparsity
```

weightInit
```
protected WeightInit weightInit
```

optimizationAlgo

protected NeuralNetwork.OptimizationAlgorithm optimizationAlgo

lossFunction

protected org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction lossFunction

renderWeightsEveryNumEpochs

protected int renderWeightsEveryNumEpochs

concatBiases
```
protected boolean concatBiases
```

constrainGradientToUnitNorm

protected boolean constrainGradientToUnitNorm

seed
```
protected long seed
```

rng

protected transient org.apache.commons.math3.random.RandomGenerator rng

dist

protected transient org.apache.commons.math3.distribution.RealDistribution dist

nIn
```
protected int nIn
```

nOut
```
protected int nOut
```

activationFunction

protected org.nd4j.linalg.api.activation.ActivationFunction activationFunction

Constructor Detail

NeuralNetConfiguration
```
public NeuralNetConfiguration()
```

NeuralNetConfiguration

public NeuralNetConfiguration(float sparsity,
                              boolean useAdaGrad,
                              float lr,
                              int k,
                              float corruptionLevel,
                              int numIterations,
                              float momentum,
                              float l2,
                              boolean useRegularization,
                              Map<Integer,Float> momentumAfter,
                              int resetAdaGradIterations,
                              float dropOut,
                              boolean applySparsity,
                              WeightInit weightInit,
                              NeuralNetwork.OptimizationAlgorithm optimizationAlgo,
                              org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction lossFunction,
                              int renderWeightsEveryNumEpochs,
                              boolean concatBiases,
                              boolean constrainGradientToUnitNorm,
                              org.apache.commons.math3.random.RandomGenerator rng,
                              org.apache.commons.math3.distribution.RealDistribution dist,
                              long seed,
                              int nIn,
                              int nOut,
                              org.nd4j.linalg.api.activation.ActivationFunction activationFunction,
                              RBM.VisibleUnit visibleUnit,
                              RBM.HiddenUnit hiddenUnit,
                              NeuralNetConfiguration.ActivationType activationType,
                              int[] weightShape,
                              int[] filterSize,
                              int numFeatureMaps,
                              int[] stride,
                              int[] featureMapSize,
                              int numInFeatureMaps)

NeuralNetConfiguration

public NeuralNetConfiguration(NeuralNetConfiguration neuralNetConfiguration)

Method Detail

getNumInFeatureMaps
```
public int getNumInFeatureMaps()
```

setNumInFeatureMaps

public void setNumInFeatureMaps(int numInFeatureMaps)

getFeatureMapSize
```
public int[] getFeatureMapSize()
```

setFeatureMapSize

public void setFeatureMapSize(int[] featureMapSize)

getWeightShape
```
public int[] getWeightShape()
```

setWeightShape

public void setWeightShape(int[] weightShape)

getNumIterations
```
public int getNumIterations()
```

setNumIterations

public void setNumIterations(int numIterations)

getK
```
public int getK()
```

setK
```
public void setK(int k)
```

getCorruptionLevel
```
public float getCorruptionLevel()
```

setCorruptionLevel

public void setCorruptionLevel(float corruptionLevel)

getHiddenUnit
```
public RBM.HiddenUnit getHiddenUnit()
```

setHiddenUnit

public void setHiddenUnit(RBM.HiddenUnit hiddenUnit)

getVisibleUnit

public RBM.VisibleUnit getVisibleUnit()

setVisibleUnit

public void setVisibleUnit(RBM.VisibleUnit visibleUnit)

getLossFunction

public org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction getLossFunction()

setLossFunction

public void setLossFunction(org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction lossFunction)

getActivationFunction

public org.nd4j.linalg.api.activation.ActivationFunction getActivationFunction()

setActivationFunction

public void setActivationFunction(org.nd4j.linalg.api.activation.ActivationFunction activationFunction)

getnIn
```
public int getnIn()
```

setnIn
```
public void setnIn(int nIn)
```

getnOut
```
public int getnOut()
```

setnOut
```
public void setnOut(int nOut)
```

getSparsity
```
public float getSparsity()
```

setSparsity

public void setSparsity(float sparsity)

isUseAdaGrad
```
public boolean isUseAdaGrad()
```

setUseAdaGrad

public void setUseAdaGrad(boolean useAdaGrad)

getLr
```
public float getLr()
```

setLr
```
public void setLr(float lr)
```

getMomentum
```
public float getMomentum()
```

setMomentum

public void setMomentum(float momentum)

getL2
```
public float getL2()
```

setL2
```
public void setL2(float l2)
```

isUseRegularization
```
public boolean isUseRegularization()
```

setUseRegularization

public void setUseRegularization(boolean useRegularization)

getMomentumAfter

public Map<Integer,Float> getMomentumAfter()

setMomentumAfter

public void setMomentumAfter(Map<Integer,Float> momentumAfter)

getResetAdaGradIterations

public int getResetAdaGradIterations()

setResetAdaGradIterations

public void setResetAdaGradIterations(int resetAdaGradIterations)

getDropOut
```
public float getDropOut()
```

setDropOut

public void setDropOut(float dropOut)

isApplySparsity
```
public boolean isApplySparsity()
```

setApplySparsity

public void setApplySparsity(boolean applySparsity)

getWeightInit
```
public WeightInit getWeightInit()
```

setWeightInit

public void setWeightInit(WeightInit weightInit)

getOptimizationAlgo

public NeuralNetwork.OptimizationAlgorithm getOptimizationAlgo()

setOptimizationAlgo

public void setOptimizationAlgo(NeuralNetwork.OptimizationAlgorithm optimizationAlgo)

getRenderWeightsEveryNumEpochs

public int getRenderWeightsEveryNumEpochs()

setRenderWeightsEveryNumEpochs

public void setRenderWeightsEveryNumEpochs(int renderWeightsEveryNumEpochs)

isConcatBiases
```
public boolean isConcatBiases()
```

setConcatBiases

public void setConcatBiases(boolean concatBiases)

isConstrainGradientToUnitNorm

public boolean isConstrainGradientToUnitNorm()

setConstrainGradientToUnitNorm

public void setConstrainGradientToUnitNorm(boolean constrainGradientToUnitNorm)

getRng

public org.apache.commons.math3.random.RandomGenerator getRng()

setRng

public void setRng(org.apache.commons.math3.random.RandomGenerator rng)

getSeed
```
public long getSeed()
```

setSeed
```
public void setSeed(long seed)
```

getDist

public org.apache.commons.math3.distribution.RealDistribution getDist()

setDist

public void setDist(org.apache.commons.math3.distribution.RealDistribution dist)

getActivationType

public NeuralNetConfiguration.ActivationType getActivationType()

setActivationType

public void setActivationType(NeuralNetConfiguration.ActivationType activationType)

getFilterSize
```
public int[] getFilterSize()
```

setFilterSize

public void setFilterSize(int[] filterSize)

getNumFeatureMaps
```
public int getNumFeatureMaps()
```

setNumFeatureMaps

public void setNumFeatureMaps(int numFeatureMaps)

getStride
```
public int[] getStride()
```

setStride
```
public void setStride(int[] stride)
```

getPretrainEpochs
```
public int getPretrainEpochs()
```

setPretrainEpochs

public void setPretrainEpochs(int pretrainEpochs)

setPretrainLearningRate

public void setPretrainLearningRate(float pretrainLearningRate)

getFinetuneLearningRate

public float getFinetuneLearningRate()

setFinetuneLearningRate

public void setFinetuneLearningRate(float finetuneLearningRate)

getFinetuneEpochs
```
public int getFinetuneEpochs()
```

setFinetuneEpochs

public void setFinetuneEpochs(int finetuneEpochs)

toString
```
public String toString()
```
Overrides:

toString in class Object

equals
```
public boolean equals(Object o)
```
Overrides:

equals in class Object

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

clone
```
public NeuralNetConfiguration clone()
```
Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object. The general intent is that, for any object x, the expression:
```
 x.clone() != x
```
will be true, and that the expression:
```
 x.clone().getClass() == x.getClass()
```
will be true, but these are not absolute requirements. While it is typically the case that:
```
 x.clone().equals(x)
```
will be true, this is not an absolute requirement. By convention, the returned object should be obtained by calling super.clone. If a class and all of its superclasses (except Object) obey this convention, it will be the case that x.clone().getClass() == x.getClass(). By convention, the object returned by this method should be independent of this object (which is being cloned). To achieve this independence, it may be necessary to modify one or more fields of the object returned by super.clone before returning it. Typically, this means copying any mutable objects that comprise the internal "deep structure" of the object being cloned and replacing the references to these objects with references to the copies. If a class contains only primitive fields or references to immutable objects, then it is usually the case that no fields in the object returned by super.clone need to be modified. The method clone for class Object performs a specific cloning operation. First, if the class of this object does not implement the interface Cloneable, then a CloneNotSupportedException is thrown. Note that all arrays are considered to implement the interface Cloneable and that the return type of the clone method of an array type T[] is T[] where T is any reference or primitive type. Otherwise, this method creates a new instance of the class of this object and initializes all its fields with exactly the contents of the corresponding fields of this object, as if by assignment; the contents of the fields are not themselves cloned. Thus, this method performs a "shallow copy" of this object, not a "deep copy" operation. The class Object does not itself implement the interface Cloneable, so calling the clone method on an object whose class is Object will result in throwing an exception at run time.
Overrides:

clone in class Object

Returns:

a clone of this instance.

Throws:

CloneNotSupportedException - if the object's class does not support the Cloneable interface. Subclasses that override the clone method can also throw this exception to indicate that an instance cannot be cloned.

See Also:

Cloneable

Class NeuralNetConfiguration

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

k

corruptionLevel

numIterations

momentum

l2

useRegularization

momentumAfter

resetAdaGradIterations

dropOut

applySparsity

weightInit

optimizationAlgo

lossFunction

renderWeightsEveryNumEpochs

concatBiases

constrainGradientToUnitNorm

seed

rng

dist

nIn

nOut

activationFunction

Constructor Detail

NeuralNetConfiguration

NeuralNetConfiguration

NeuralNetConfiguration

Method Detail

getNumInFeatureMaps

setNumInFeatureMaps

getFeatureMapSize

setFeatureMapSize

getWeightShape

setWeightShape

getNumIterations

setNumIterations

getK

setK

getCorruptionLevel

setCorruptionLevel

getHiddenUnit

setHiddenUnit

getVisibleUnit

setVisibleUnit

getLossFunction

setLossFunction

getActivationFunction

setActivationFunction

getnIn

setnIn

getnOut

setnOut

getSparsity

setSparsity

isUseAdaGrad

setUseAdaGrad

getLr

setLr

getMomentum

setMomentum

getL2

setL2

isUseRegularization

setUseRegularization

getMomentumAfter

setMomentumAfter

getResetAdaGradIterations

setResetAdaGradIterations

getDropOut

setDropOut

isApplySparsity

setApplySparsity

getWeightInit

setWeightInit