NeuralNetConfiguration (deeplearning4j-core 0.0.3.3.3.alpha1 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.Builder`
`static class`	`NeuralNetConfiguration.ListBuilder` Fluent interface for building a list of configurations

Field Summary

Fields
Modifier and Type	Field and Description
`protected String`	`activationFunction`
`protected boolean`	`applySparsity`
`protected int`	`batchSize`
`protected boolean`	`constrainGradientToUnitNorm`
`protected ConvolutionDownSampleLayer.ConvolutionType`	`convolutionType`
`protected double`	`corruptionLevel`
`protected Distribution`	`dist`
`protected double`	`dropOut`
`protected int`	`k`
`protected int`	`kernel`
`protected double`	`l2`
`protected Layer`	`layer`
`protected org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction`	`lossFunction`
`protected boolean`	`minimize`
`protected double`	`momentum`
`protected Map<Integer,Double>`	`momentumAfter`
`protected int`	`nIn`
`protected int`	`nOut`
`protected int`	`numIterations`
`protected int`	`numLineSearchIterations`
`protected OptimizationAlgorithm`	`optimizationAlgo`
`protected int`	`resetAdaGradIterations`
`protected Random`	`rng`
`protected StepFunction`	`stepFunction`
`protected boolean`	`useRegularization`
`protected List<String>`	`variables`
`protected WeightInit`	`weightInit`

Constructor Summary

Constructors
Constructor and Description
`NeuralNetConfiguration()`
NeuralNetConfiguration(double sparsity, boolean useAdaGrad, double lr, double corruptionLevel, int numIterations, double momentum, double l2, boolean useRegularization, Map<Integer,Double> momentumAfter, int resetAdaGradIterations, int numLineSearchIterations, double dropOut, boolean applySparsity, WeightInit weightInit, OptimizationAlgorithm optimizationAlgo, org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction lossFunction, boolean constrainGradientToUnitNorm, Random rng, Distribution dist, StepFunction stepFunction, Layer layer, List<String> variables, int nIn, int nOut, String activationFunction, RBM.VisibleUnit visibleUnit, RBM.HiddenUnit hiddenUnit, int k, int[] weightShape, int[] filterSize, int[] stride, int kernel, int batchSize, boolean minimize, ConvolutionDownSampleLayer.ConvolutionType convolutionType)
NeuralNetConfiguration(double sparsity, boolean useAdaGrad, double lr, int k, double corruptionLevel, int numIterations, double momentum, double l2, boolean useRegularization, Map<Integer,Double> momentumAfter, int resetAdaGradIterations, double dropOut, boolean applySparsity, WeightInit weightInit, OptimizationAlgorithm optimizationAlgo, org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction lossFunction, boolean constrainGradientToUnitNorm, Random rng, Distribution dist, int nIn, int nOut, String activationFunction, RBM.VisibleUnit visibleUnit, RBM.HiddenUnit hiddenUnit, int[] weightShape, int[] filterSize, int[] stride, int[] featureMapSize, int kernel, int batchSize, int numLineSearchIterations, boolean minimize, Layer layer, ConvolutionDownSampleLayer.ConvolutionType convolutionType, double l1)
`NeuralNetConfiguration(NeuralNetConfiguration neuralNetConfiguration)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addVariable(String variable)`
`NeuralNetConfiguration`	`clone()` Creates and returns a copy of this object.
`boolean`	`equals(Object o)`
`static NeuralNetConfiguration`	`fromJson(String json)` Create a neural net configuration from json
`String`	`getActivationFunction()`
`int`	`getBatchSize()`
`ConvolutionDownSampleLayer.ConvolutionType`	`getConvolutionType()` The convolution type to use with the convolution layer
`double`	`getCorruptionLevel()`
`Distribution`	`getDist()`
`double`	`getDropOut()`
`int[]`	`getFeatureMapSize()`
`int[]`	`getFilterSize()`
`RBM.HiddenUnit`	`getHiddenUnit()`
`int`	`getK()`
`int`	`getKernel()`
`double`	`getL1()`
`double`	`getL2()`
`Layer`	`getLayer()`
`org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction`	`getLossFunction()`
`double`	`getLr()`
`double`	`getMomentum()`
`Map<Integer,Double>`	`getMomentumAfter()`
`int`	`getnIn()`
`int`	`getnOut()`
`int`	`getNumIterations()`
`int`	`getNumLineSearchIterations()`
`OptimizationAlgorithm`	`getOptimizationAlgo()`
`int`	`getResetAdaGradIterations()`
`Random`	`getRng()`
`double`	`getSparsity()`
`StepFunction`	`getStepFunction()`
`int[]`	`getStride()`
`List<String>`	`getVariables()`
`RBM.VisibleUnit`	`getVisibleUnit()`
`WeightInit`	`getWeightInit()`
`int[]`	`getWeightShape()`
`int`	`hashCode()`
`boolean`	`isApplySparsity()`
`boolean`	`isConstrainGradientToUnitNorm()`
`boolean`	`isMinimize()`
`boolean`	`isUseAdaGrad()`
`boolean`	`isUseRegularization()`
`static com.fasterxml.jackson.databind.ObjectMapper`	`mapper()` Object mapper for serialization of configurations
`void`	`setActivationFunction(String activationFunction)`
`void`	`setApplySparsity(boolean applySparsity)`
`void`	`setBatchSize(int batchSize)`
`void`	`setConstrainGradientToUnitNorm(boolean constrainGradientToUnitNorm)`
`void`	`setConvolutionType(ConvolutionDownSampleLayer.ConvolutionType convolutionType)`
`void`	`setCorruptionLevel(double corruptionLevel)`
`void`	`setDist(Distribution dist)`
`void`	`setDropOut(double dropOut)`
`void`	`setFeatureMapSize(int[] featureMapSize)`
`void`	`setFilterSize(int[] filterSize)`
`void`	`setHiddenUnit(RBM.HiddenUnit hiddenUnit)`
`void`	`setK(int k)`
`void`	`setKernel(int kernel)`
`void`	`setL1(double l1)`
`void`	`setL2(double l2)`
`void`	`setLayer(Layer layer)`
`void`	`setLossFunction(org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction lossFunction)`
`void`	`setLr(double lr)`
`void`	`setMinimize(boolean minimize)`
`void`	`setMomentum(double momentum)`
`void`	`setMomentumAfter(Map<Integer,Double> momentumAfter)`
`void`	`setnIn(int nIn)`
`void`	`setnOut(int nOut)`
`void`	`setNumIterations(int numIterations)`
`void`	`setNumLineSearchIterations(int numLineSearchIterations)`
`void`	`setOptimizationAlgo(OptimizationAlgorithm optimizationAlgo)`
`void`	`setResetAdaGradIterations(int resetAdaGradIterations)`
`void`	`setRng(Random rng)`
`void`	`setSparsity(double sparsity)`
`void`	`setStepFunction(StepFunction stepFunction)`
`void`	`setStride(int[] stride)`
`void`	`setUseAdaGrad(boolean useAdaGrad)`
`void`	`setUseRegularization(boolean useRegularization)`
`void`	`setVariables(List<String> variables)`
`void`	`setVisibleUnit(RBM.VisibleUnit visibleUnit)`
`void`	`setWeightInit(WeightInit weightInit)`
`void`	`setWeightShape(int[] weightShape)`
`String`	`toJson()` Return this configuration as json
`String`	`toString()`
`List<String>`	`variables()`

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

Field Detail

corruptionLevel
```
protected double corruptionLevel
```

numIterations
```
protected int numIterations
```

momentum
```
protected double momentum
```

l2
```
protected double l2
```

useRegularization
```
protected boolean useRegularization
```

momentumAfter

protected Map<Integer,Double> momentumAfter

resetAdaGradIterations
```
protected int resetAdaGradIterations
```

numLineSearchIterations
```
protected int numLineSearchIterations
```

dropOut
```
protected double dropOut
```

applySparsity
```
protected boolean applySparsity
```

weightInit
```
protected WeightInit weightInit
```

optimizationAlgo

protected OptimizationAlgorithm optimizationAlgo

lossFunction

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

constrainGradientToUnitNorm

protected boolean constrainGradientToUnitNorm

rng
```
protected Random rng
```

dist
```
protected Distribution dist
```

stepFunction
```
protected StepFunction stepFunction
```

layer
```
protected Layer layer
```

variables
```
protected List<String> variables
```

nIn
```
protected int nIn
```

nOut
```
protected int nOut
```

activationFunction
```
protected String activationFunction
```

k
```
protected int k
```

kernel
```
protected int kernel
```

batchSize
```
protected int batchSize
```

minimize
```
protected boolean minimize
```

convolutionType

protected ConvolutionDownSampleLayer.ConvolutionType convolutionType

Constructor Detail

NeuralNetConfiguration
```
public NeuralNetConfiguration()
```

NeuralNetConfiguration

public NeuralNetConfiguration(double sparsity,
                              boolean useAdaGrad,
                              double lr,
                              double corruptionLevel,
                              int numIterations,
                              double momentum,
                              double l2,
                              boolean useRegularization,
                              Map<Integer,Double> momentumAfter,
                              int resetAdaGradIterations,
                              int numLineSearchIterations,
                              double dropOut,
                              boolean applySparsity,
                              WeightInit weightInit,
                              OptimizationAlgorithm optimizationAlgo,
                              org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction lossFunction,
                              boolean constrainGradientToUnitNorm,
                              Random rng,
                              Distribution dist,
                              StepFunction stepFunction,
                              Layer layer,
                              List<String> variables,
                              int nIn,
                              int nOut,
                              String activationFunction,
                              RBM.VisibleUnit visibleUnit,
                              RBM.HiddenUnit hiddenUnit,
                              int k,
                              int[] weightShape,
                              int[] filterSize,
                              int[] stride,
                              int kernel,
                              int batchSize,
                              boolean minimize,
                              ConvolutionDownSampleLayer.ConvolutionType convolutionType)

NeuralNetConfiguration

public NeuralNetConfiguration(double sparsity,
                              boolean useAdaGrad,
                              double lr,
                              int k,
                              double corruptionLevel,
                              int numIterations,
                              double momentum,
                              double l2,
                              boolean useRegularization,
                              Map<Integer,Double> momentumAfter,
                              int resetAdaGradIterations,
                              double dropOut,
                              boolean applySparsity,
                              WeightInit weightInit,
                              OptimizationAlgorithm optimizationAlgo,
                              org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction lossFunction,
                              boolean constrainGradientToUnitNorm,
                              Random rng,
                              Distribution dist,
                              int nIn,
                              int nOut,
                              String activationFunction,
                              RBM.VisibleUnit visibleUnit,
                              RBM.HiddenUnit hiddenUnit,
                              int[] weightShape,
                              int[] filterSize,
                              int[] stride,
                              int[] featureMapSize,
                              int kernel,
                              int batchSize,
                              int numLineSearchIterations,
                              boolean minimize,
                              Layer layer,
                              ConvolutionDownSampleLayer.ConvolutionType convolutionType,
                              double l1)

NeuralNetConfiguration

public NeuralNetConfiguration(NeuralNetConfiguration neuralNetConfiguration)

Method Detail
- getConvolutionType
```
public ConvolutionDownSampleLayer.ConvolutionType getConvolutionType()
```
  The convolution type to use with the convolution layer
  
  Returns:
  
  the convolution type to use with the convolution layer
- setConvolutionType
```
public void setConvolutionType(ConvolutionDownSampleLayer.ConvolutionType convolutionType)
```
- getNumLineSearchIterations
```
public int getNumLineSearchIterations()
```
- setNumLineSearchIterations
```
public void setNumLineSearchIterations(int numLineSearchIterations)
```
- getBatchSize
```
public int getBatchSize()
```
- setBatchSize
```
public void setBatchSize(int batchSize)
```
- getKernel
```
public int getKernel()
```
- setKernel
```
public void setKernel(int kernel)
```
- getLayer
```
public Layer getLayer()
```
- setLayer
```
public void setLayer(Layer layer)
```
- addVariable
```
public void addVariable(String variable)
```
- isMinimize
```
public boolean isMinimize()
```
- setMinimize
```
public void setMinimize(boolean minimize)
```
- variables
```
public List<String> variables()
```
- setVariables
```
public void setVariables(List<String> variables)
```
- getStepFunction
```
public StepFunction getStepFunction()
```
- setStepFunction
```
public void setStepFunction(StepFunction stepFunction)
```
- 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 double getCorruptionLevel()
```
- 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 String getActivationFunction()
```
- setActivationFunction
```
public void setActivationFunction(String activationFunction)
```
- getnIn
```
public int getnIn()
```
- setnIn
```
public void setnIn(int nIn)
```
- getnOut
```
public int getnOut()
```
- setnOut
```
public void setnOut(int nOut)
```
- getSparsity
```
public double getSparsity()
```
- isUseAdaGrad
```
public boolean isUseAdaGrad()
```
- setUseAdaGrad
```
public void setUseAdaGrad(boolean useAdaGrad)
```
- getLr
```
public double getLr()
```
- setLr
```
public void setLr(double lr)
```
- getMomentum
```
public double getMomentum()
```
- getL2
```
public double getL2()
```
- setL2
```
public void setL2(double l2)
```
- isUseRegularization
```
public boolean isUseRegularization()
```
- setUseRegularization
```
public void setUseRegularization(boolean useRegularization)
```
- getMomentumAfter
```
public Map<Integer,Double> getMomentumAfter()
```
- setMomentumAfter
```
public void setMomentumAfter(Map<Integer,Double> momentumAfter)
```
- getResetAdaGradIterations
```
public int getResetAdaGradIterations()
```
- setResetAdaGradIterations
```
public void setResetAdaGradIterations(int resetAdaGradIterations)
```
- getDropOut
```
public double getDropOut()
```
- isApplySparsity
```
public boolean isApplySparsity()
```
- setApplySparsity
```
public void setApplySparsity(boolean applySparsity)
```
- getWeightInit
```
public WeightInit getWeightInit()
```
- setWeightInit
```
public void setWeightInit(WeightInit weightInit)
```
- getOptimizationAlgo
```
public OptimizationAlgorithm getOptimizationAlgo()
```
- setOptimizationAlgo
```
public void setOptimizationAlgo(OptimizationAlgorithm optimizationAlgo)
```
- isConstrainGradientToUnitNorm
```
public boolean isConstrainGradientToUnitNorm()
```
- setConstrainGradientToUnitNorm
```
public void setConstrainGradientToUnitNorm(boolean constrainGradientToUnitNorm)
```
- getRng
```
public Random getRng()
```
- setRng
```
public void setRng(Random rng)
```
- getDist
```
public Distribution getDist()
```
- setDist
```
public void setDist(Distribution dist)
```
- getFilterSize
```
public int[] getFilterSize()
```
- setFilterSize
```
public void setFilterSize(int[] filterSize)
```
- getStride
```
public int[] getStride()
```
- setStride
```
public void setStride(int[] stride)
```
- equals
```
public boolean equals(Object o)
```
  Overrides:
  
  equals in class Object
- hashCode
```
public int hashCode()
```
  Overrides:
  
  hashCode in class Object
- toString
```
public String toString()
```
  Overrides:
  
  toString 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 overrideLayer the clone method can also throw this exception to indicate that an instance cannot be cloned.
  
  See Also:
  
  Cloneable
- toJson
```
public String toJson()
```
  Return this configuration as json
  
  Returns:
  
  this configuration represented as json
- fromJson
```
public static NeuralNetConfiguration fromJson(String json)
```
  Create a neural net configuration from json
  
  Parameters:
  
  json - the neural net configuration from json
  
  Returns:
- getVariables
```
public List<String> getVariables()
```
- getL1
```
public double getL1()
```
- setL1
```
public void setL1(double l1)
```
- getFeatureMapSize
```
public int[] getFeatureMapSize()
```
- setFeatureMapSize
```
public void setFeatureMapSize(int[] featureMapSize)
```
- setSparsity
```
public void setSparsity(double sparsity)
```
- setCorruptionLevel
```
public void setCorruptionLevel(double corruptionLevel)
```
- setMomentum
```
public void setMomentum(double momentum)
```
- setDropOut
```
public void setDropOut(double dropOut)
```
- mapper
```
public static com.fasterxml.jackson.databind.ObjectMapper mapper()
```
  Object mapper for serialization of configurations
  
  Returns:

Class NeuralNetConfiguration

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

corruptionLevel

numIterations

momentum

l2

useRegularization

momentumAfter

resetAdaGradIterations

numLineSearchIterations

dropOut

applySparsity

weightInit

optimizationAlgo

lossFunction

constrainGradientToUnitNorm

rng

dist

stepFunction

layer

variables

nIn

nOut

activationFunction

k

kernel

batchSize

minimize

convolutionType

Constructor Detail

NeuralNetConfiguration

NeuralNetConfiguration

NeuralNetConfiguration

NeuralNetConfiguration

Method Detail

getConvolutionType

setConvolutionType

getNumLineSearchIterations

setNumLineSearchIterations

getBatchSize

setBatchSize

getKernel

setKernel

getLayer

setLayer

addVariable

isMinimize

setMinimize

variables

setVariables

getStepFunction

setStepFunction

getWeightShape

setWeightShape

getNumIterations

setNumIterations

getK

setK

getCorruptionLevel

getHiddenUnit

setHiddenUnit

getVisibleUnit

setVisibleUnit

getLossFunction

setLossFunction

getActivationFunction

setActivationFunction

getnIn

setnIn

getnOut

setnOut

getSparsity

isUseAdaGrad

setUseAdaGrad

getLr