ComputationGraph (deeplearning4j-nn 0.9.1 API)

java.lang.Object
- org.deeplearning4j.nn.graph.ComputationGraph

All Implemented Interfaces:

Serializable, Model, NeuralNetwork
```
public class ComputationGraph
extends Object
implements Serializable, Model, NeuralNetwork
```
A ComputationGraph network is a neural network with arbitrary (directed acyclic graph) connection structure. A ComputationGraph may also have an arbitrary number of inputs and outputs.

Author:

Alex Black

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected ComputationGraphConfiguration`	`configuration`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`flattenedGradients`
`protected org.nd4j.linalg.api.ndarray.INDArray`	`flattenedParams`
`protected Gradient`	`gradient`
`protected boolean`	`initCalled`
`protected ThreadLocal<Long>`	`lastEtlTime`
`protected Layer[]`	`layers` A list of layers.
`protected double`	`score`
`protected Solver`	`solver`
`protected int[]`	`topologicalOrder` Indexes of graph vertices, in topological order.
`protected GraphVertex[]`	`vertices` All GraphVertex objects in the network.
`protected Map<String,GraphVertex>`	`verticesMap` Map of vertices by name
`static String`	`workspaceCache`
`static org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration`	`workspaceConfigurationCache`
`static org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration`	`workspaceConfigurationExternal`
`static org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration`	`workspaceConfigurationFeedForward`
`static org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration`	`workspaceConfigurationLSTM`
`static org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration`	`workspaceConfigurationTBPTT`
`static String`	`workspaceExternal`
`static String`	`workspaceFeedForward`
`static String`	`workspaceLSTM`
`static String`	`workspacePretrain`
`static String`	`workspaceTBPTT`

Constructor Summary

Constructors
Constructor and Description

ComputationGraph(ComputationGraphConfiguration configuration)

Constructors
Constructor and Description
`ComputationGraph(ComputationGraphConfiguration configuration)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`accumulateScore(double accum)` Sets a rolling tally for the score.
`void`	`addListeners(IterationListener... listeners)` This method ADDS additional IterationListener to existing listeners
`void`	`applyLearningRateScoreDecay()` Update learningRate using for this model.
`Gradient`	`backpropGradient(org.nd4j.linalg.api.ndarray.INDArray... epsilons)` Calculate the gradient of the network with respect to some external errors.
`int`	`batchSize()` The current inputs batch size
`protected void`	`calcBackpropGradients(boolean truncatedBPTT, org.nd4j.linalg.api.ndarray.INDArray... externalEpsilons)` Do backprop (gradient calculation)
`double`	`calcL1()` Calculate the L1 regularization term for all layers in the entire network.
`double`	`calcL2()` Calculate the L2 regularization term for all layers in the entire network.
`void`	`clear()` Clear input
`void`	`clearLayerMaskArrays()` Remove the mask arrays from all layers. See `setLayerMaskArrays(INDArray[], INDArray[])` for details on mask arrays.
`protected void`	`clearLayersStates()` This method just makes sure there's no state preserved within layers
`ComputationGraph`	`clone()`
`void`	`computeGradientAndScore()` Update the score
`NeuralNetConfiguration`	`conf()` The configuration for the neural network
`<T extends IEvaluation> T[]`	`doEvaluation(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, T... evaluations)` Perform evaluation on the given data (DataSetIterator) with the given `IEvaluation` instance
`<T extends IEvaluation> T[]`	`doEvaluation(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator, T... evaluations)` Perform evaluation on the given data (MultiDataSetIterator) with the given `IEvaluation` instance
`protected void`	`doTruncatedBPTT(org.nd4j.linalg.api.ndarray.INDArray[] inputs, org.nd4j.linalg.api.ndarray.INDArray[] labels, org.nd4j.linalg.api.ndarray.INDArray[] featureMasks, org.nd4j.linalg.api.ndarray.INDArray[] labelMasks)` Fit the network using truncated BPTT
`boolean`	`equals(Object obj)` Indicates whether some other object is "equal to" this one.
`Evaluation`	`evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)` Evaluate the network (classification performance - single output ComputationGraphs only)
`Evaluation`	`evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, List<String> labelsList)` Evaluate the network on the provided data set (single output ComputationGraphs only).
`Evaluation`	`evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, List<String> labelsList, int topN)` Evaluate the network (for classification) on the provided data set, with top N accuracy in addition to standard accuracy.
`Evaluation`	`evaluate(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator)` Evaluate the network (classification performance - single output ComputationGraphs only)
`Evaluation`	`evaluate(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator, List<String> labelsList)` Evaluate the network on the provided data set (single output ComputationGraphs only).
`Evaluation`	`evaluate(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator, List<String> labelsList, int topN)` Evaluate the network (for classification) on the provided data set, with top N accuracy in addition to standard accuracy.
`RegressionEvaluation`	`evaluateRegression(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)` Evaluate the (single output layer only) network for regression performance
`RegressionEvaluation`	`evaluateRegression(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, List<String> columnNames)` Evaluate the (single output layer only) network for regression performance
`RegressionEvaluation`	`evaluateRegression(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator)` Evaluate the (single output layer only) network for regression performance
`RegressionEvaluation`	`evaluateRegression(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator, List<String> columnNames)` Evaluate the (single output layer only) network for regression performance
`ROC`	`evaluateROC(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, int rocThresholdSteps)` Evaluate the network (must be a binary classifier) on the specified data, using the `ROC` class
`ROC`	`evaluateROC(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator, int rocThresholdSteps)` Evaluate the network (must be a binary classifier) on the specified data, using the `ROC` class
`ROCMultiClass`	`evaluateROCMultiClass(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator, int rocThresholdSteps)` Evaluate the network on the specified data, using the `ROCMultiClass` class
`ROCMultiClass`	`evaluateROCMultiClass(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator, int rocThresholdSteps)` Evaluate the network on the specified data, using the `ROCMultiClass` class
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward()` Conduct forward pass using the stored inputs, at test time
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(boolean train)` Conduct forward pass using the stored inputs
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(boolean train, boolean excludeOutputLayers)`
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(boolean train, boolean excludeOutputLayers, boolean includeNonLayerVertexActivations)`
`protected Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(boolean train, boolean excludeOutputLayers, boolean includeNonLayerVertexActivations, boolean publicApi)` PLEASE NEVER USE THIS METHOD IF YOU"RE NOT SURE WHAT YOU'll GET
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(org.nd4j.linalg.api.ndarray.INDArray[] input, boolean train)` Conduct forward pass using an array of inputs
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`feedForward(org.nd4j.linalg.api.ndarray.INDArray input, boolean train)` Conduct forward pass using a single input array.
`void`	`fit()` All models have a fit method
`void`	`fit(org.nd4j.linalg.dataset.api.DataSet dataSet)` Fit the ComputationGraph using a DataSet.
`void`	`fit(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)` Fit the ComputationGraph using a DataSetIterator.
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray data)` Fit the model to the given data
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray[] inputs, org.nd4j.linalg.api.ndarray.INDArray[] labels)` Fit the ComputationGraph given arrays of inputs and labels.
`void`	`fit(org.nd4j.linalg.api.ndarray.INDArray[] inputs, org.nd4j.linalg.api.ndarray.INDArray[] labels, org.nd4j.linalg.api.ndarray.INDArray[] featureMaskArrays, org.nd4j.linalg.api.ndarray.INDArray[] labelMaskArrays)` Fit the ComputationGraph using the specified inputs and labels (and mask arrays)
`void`	`fit(org.nd4j.linalg.dataset.api.MultiDataSet multiDataSet)` Fit the ComputationGraph using a MultiDataSet
`void`	`fit(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator multi)` Fit the ComputationGraph using a MultiDataSetIterator
`ComputationGraphConfiguration`	`getConfiguration()` This method returns configuration of this ComputationGraph
`org.nd4j.linalg.api.ndarray.INDArray`	`getGradientsViewArray()`
`org.nd4j.linalg.api.ndarray.INDArray`	`getInput(int inputNum)` Get the previously set input for the ComputationGraph
`org.nd4j.linalg.api.ndarray.INDArray[]`	`getInputMaskArrays()` Get the previously set feature/input mask arrays for the ComputationGraph
`org.nd4j.linalg.api.ndarray.INDArray[]`	`getInputs()` Get the previously set inputs for the ComputationGraph
`org.nd4j.linalg.api.ndarray.INDArray[]`	`getLabelMaskArrays()` Get the previously set label/output mask arrays for the ComputationGraph
`long`	`getLastEtlTime()` This method returns ETL time field value
`Layer`	`getLayer(int idx)` Get the layer by the number of that layer, in range 0 to getNumLayers()-1 NOTE: This is different from the internal GraphVertex index for the layer
`Layer`	`getLayer(String name)` Get a given layer by name.
`Layer[]`	`getLayers()` Get all layers in the ComputationGraph
`Collection<IterationListener>`	`getListeners()` Get the IterationListeners for the ComputationGraph
`int`	`getNumInputArrays()` The number of inputs to this network
`int`	`getNumLayers()` Returns the number of layers in the ComputationGraph
`int`	`getNumOutputArrays()` The number of output (arrays) for this network
`ConvexOptimizer`	`getOptimizer()` Returns this models optimizer
`Layer`	`getOutputLayer(int outputLayerIdx)` Get the specified output layer, by index.
`org.nd4j.linalg.api.ndarray.INDArray`	`getParam(String paramName)` Get the parameter
`ComputationGraphUpdater`	`getUpdater()` Get the ComputationGraphUpdater for the network
`GraphVertex`	`getVertex(String name)` Return a given GraphVertex by name, or null if no vertex with that name exists
`GraphVertex[]`	`getVertices()` Returns an array of all GraphVertex objects.
`Gradient`	`gradient()` Calculate a gradient
`org.nd4j.linalg.primitives.Pair<Gradient,Double>`	`gradientAndScore()` Get the gradient and score
`void`	`init()` Initialize the ComputationGraph network
`void`	`init(org.nd4j.linalg.api.ndarray.INDArray parameters, boolean cloneParametersArray)` Initialize the ComputationGraph, optionally with an existing parameters array.
`void`	`initGradientsView()` This method: initializes the flattened gradients array (used in backprop) and sets the appropriate subset in all layers.
`void`	`initParams()` Initialize the parameters
`org.nd4j.linalg.api.ndarray.INDArray`	`input()` The input/feature matrix for the model
`void`	`iterate(org.nd4j.linalg.api.ndarray.INDArray input)` Run one iteration
`protected void`	`migrate(org.nd4j.linalg.dataset.api.DataSet ds)`
`protected void`	`migrate(org.nd4j.linalg.dataset.api.MultiDataSet ds)`
`int`	`numParams()` the number of parameters for the model
`int`	`numParams(boolean backwards)` the number of parameters for the model
`org.nd4j.linalg.api.ndarray.INDArray[]`	`output(boolean train, org.nd4j.linalg.api.ndarray.INDArray... input)` Return an array of network outputs (predictions), given the specified network inputs Network outputs are for output layers only.
`org.nd4j.linalg.api.ndarray.INDArray[]`	`output(org.nd4j.linalg.api.ndarray.INDArray... input)` Return an array of network outputs (predictions) at test time, given the specified network inputs Network outputs are for output layers only.
`org.nd4j.linalg.api.ndarray.INDArray`	`outputSingle(boolean train, org.nd4j.linalg.api.ndarray.INDArray... input)` A convenience method that returns a single INDArray, instead of an INDArray[].
`org.nd4j.linalg.api.ndarray.INDArray`	`outputSingle(org.nd4j.linalg.api.ndarray.INDArray... input)` A convenience method that returns a single INDArray, instead of an INDArray[].
`org.nd4j.linalg.api.ndarray.INDArray`	`params()` Parameters of the model (if any)
`org.nd4j.linalg.api.ndarray.INDArray`	`params(boolean backwardOnly)` Get the parameters for the ComputationGraph
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`paramTable()` The param table
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`paramTable(boolean backpropParamsOnly)` Table of parameters by key, for backprop For many models (dense layers, etc) - all parameters are backprop parameters
`void`	`pretrain(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iter)` Pretrain network with a single input and single output.
`void`	`pretrain(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iter)` Pretrain network with multiple inputs and/or outputs
`void`	`pretrainLayer(String layerName, org.nd4j.linalg.dataset.api.iterator.DataSetIterator dataSetIterator)` Pretrain a specified layer with the given DataSetIterator
`void`	`pretrainLayer(String layerName, org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iter)` Pretrain a specified layer with the given MultiDataSetIterator
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`rnnActivateUsingStoredState(org.nd4j.linalg.api.ndarray.INDArray[] inputs, boolean training, boolean storeLastForTBPTT)` Similar to rnnTimeStep and feedForward() methods.
`void`	`rnnClearPreviousState()` Clear the previous state of the RNN layers (if any), used in `rnnTimeStep(INDArray...)`
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`rnnGetPreviousState(int layer)` Get the state of the RNN layer, as used in `rnnTimeStep(INDArray...)`.
`Map<String,org.nd4j.linalg.api.ndarray.INDArray>`	`rnnGetPreviousState(String layerName)` Get the state of the RNN layer, as used in `rnnTimeStep(INDArray...)`.
`Map<String,Map<String,org.nd4j.linalg.api.ndarray.INDArray>>`	`rnnGetPreviousStates()` Get a map of states for ALL RNN layers, as used in `rnnTimeStep(INDArray...)`.
`void`	`rnnSetPreviousState(int layer, Map<String,org.nd4j.linalg.api.ndarray.INDArray> state)` Set the state of the RNN layer, for use in `rnnTimeStep(INDArray...)`
`void`	`rnnSetPreviousState(String layerName, Map<String,org.nd4j.linalg.api.ndarray.INDArray> state)` Set the state of the RNN layer, for use in `rnnTimeStep(INDArray...)`
`void`	`rnnSetPreviousStates(Map<String,Map<String,org.nd4j.linalg.api.ndarray.INDArray>> previousStates)` Set the states for all RNN layers, for use in `rnnTimeStep(INDArray...)`
`org.nd4j.linalg.api.ndarray.INDArray[]`	`rnnTimeStep(org.nd4j.linalg.api.ndarray.INDArray... inputs)` If this ComputationGraph contains one or more RNN layers: conduct forward pass (prediction) but using previous stored state for any RNN layers.
`protected void`	`rnnUpdateStateWithTBPTTState()` Update the internal state of RNN layers after a truncated BPTT fit call
`double`	`score()` The score for the model
`double`	`score(org.nd4j.linalg.dataset.api.DataSet dataSet)` Sets the input and labels and returns a score for the prediction with respect to the true labels This is equivalent to `score(DataSet, boolean)` with training==true. NOTE: this version of the score function can only be used with ComputationGraph networks that have a single input and a single output.
`double`	`score(org.nd4j.linalg.dataset.api.DataSet dataSet, boolean training)` Sets the input and labels and returns a score for the prediction with respect to the true labels NOTE: this version of the score function can only be used with ComputationGraph networks that have a single input and a single output.
`double`	`score(org.nd4j.linalg.dataset.api.MultiDataSet dataSet)` Score the network given the MultiDataSet, at test time
`double`	`score(org.nd4j.linalg.dataset.api.MultiDataSet dataSet, boolean training)` Sets the input and labels and returns a score for the prediction with respect to the true labels
`org.nd4j.linalg.api.ndarray.INDArray`	`scoreExamples(org.nd4j.linalg.dataset.api.DataSet data, boolean addRegularizationTerms)` Calculate the score for each example in a DataSet individually.
`org.nd4j.linalg.api.ndarray.INDArray`	`scoreExamples(org.nd4j.linalg.dataset.api.MultiDataSet data, boolean addRegularizationTerms)` Calculate the score for each example in a DataSet individually.
`void`	`setBackpropGradientsViewArray(org.nd4j.linalg.api.ndarray.INDArray gradient)` Set the gradients array as a view of the full (backprop) network parameters NOTE: this is intended to be used internally in MultiLayerNetwork and ComputationGraph, not by users.
`void`	`setCacheMode(CacheMode mode)` This method sets specified CacheMode for all layers within network
`void`	`setConf(NeuralNetConfiguration conf)` Setter for the configuration
`void`	`setGradientsAccumulator(GradientsAccumulator accumulator)` This method allows you to specificy GradientsAccumulator instance to be used with this model PLEASE NOTE: Do not use this method unless you understand how to use GradientsAccumulator & updates sharing.
`void`	`setInput(int inputNum, org.nd4j.linalg.api.ndarray.INDArray input)` Set the specified input for the ComputationGraph
`void`	`setInputs(org.nd4j.linalg.api.ndarray.INDArray... inputs)` Set all inputs for the ComputationGraph network
`void`	`setLabel(int labelNum, org.nd4j.linalg.api.ndarray.INDArray label)` Set the specified label for the ComputationGraph
`void`	`setLabels(org.nd4j.linalg.api.ndarray.INDArray... labels)` Set all labels for the ComputationGraph network
`void`	`setLastEtlTime(long time)` This method allows to set ETL field time, useful for performance tracking
`void`	`setLayerMaskArrays(org.nd4j.linalg.api.ndarray.INDArray[] featureMaskArrays, org.nd4j.linalg.api.ndarray.INDArray[] labelMaskArrays)` Set the mask arrays for features and labels.
`void`	`setListeners(Collection<IterationListener> listeners)` Set the IterationListeners for the ComputationGraph (and all layers in the network)
`void`	`setListeners(IterationListener... listeners)` Set the IterationListeners for the ComputationGraph (and all layers in the network)
`void`	`setParam(String key, org.nd4j.linalg.api.ndarray.INDArray val)` Set the parameter with a new ndarray
`void`	`setParams(org.nd4j.linalg.api.ndarray.INDArray params)` Set the parameters for this model.
`void`	`setParamsViewArray(org.nd4j.linalg.api.ndarray.INDArray gradient)` Set the initial parameters array as a view of the full (backprop) network parameters NOTE: this is intended to be used internally in MultiLayerNetwork and ComputationGraph, not by users.
`void`	`setParamTable(Map<String,org.nd4j.linalg.api.ndarray.INDArray> paramTable)` Setter for the param table
`void`	`setScore(double score)`
`void`	`setUpdater(ComputationGraphUpdater updater)` Set the computationGraphUpdater for the network
`protected org.nd4j.linalg.api.ndarray.INDArray[]`	`silentOutput(boolean train, org.nd4j.linalg.api.ndarray.INDArray... input)`
`String`	`summary()` String detailing the architecture of the computation graph.
`int[]`	`topologicalSortOrder()` Calculate a topological sort order for the vertices in the graph.
`void`	`update(Gradient gradient)` Update layer weights and biases with gradient change
`void`	`update(org.nd4j.linalg.api.ndarray.INDArray gradient, String paramType)` Perform one update applying the gradient
`org.nd4j.linalg.api.ndarray.INDArray`	`updaterState()` This method returns updater state (if applicable), null otherwise
`void`	`validateInput()` Validate the input

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

- Field Detail
  - configuration
```
protected ComputationGraphConfiguration configuration
```
  - initCalled
```
protected boolean initCalled
```
  - solver
```
protected transient Solver solver
```
  - flattenedParams
```
protected org.nd4j.linalg.api.ndarray.INDArray flattenedParams
```
  - flattenedGradients
```
protected transient org.nd4j.linalg.api.ndarray.INDArray flattenedGradients
```
  - gradient
```
protected Gradient gradient
```
  - score
```
protected double score
```
  - workspaceCache
```
public static final String workspaceCache
```
    See Also:
    
    Constant Field Values
  - workspaceExternal
```
public static final String workspaceExternal
```
    See Also:
    
    Constant Field Values
  - workspaceFeedForward
```
public static final String workspaceFeedForward
```
    See Also:
    
    Constant Field Values
  - workspacePretrain
```
public static final String workspacePretrain
```
    See Also:
    
    Constant Field Values
  - workspaceTBPTT
```
public static final String workspaceTBPTT
```
    See Also:
    
    Constant Field Values
  - workspaceLSTM
```
public static final String workspaceLSTM
```
    See Also:
    
    Constant Field Values
  - workspaceConfigurationFeedForward
```
public static final org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration workspaceConfigurationFeedForward
```
  - workspaceConfigurationTBPTT
```
public static final org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration workspaceConfigurationTBPTT
```
  - workspaceConfigurationLSTM
```
public static final org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration workspaceConfigurationLSTM
```
  - workspaceConfigurationExternal
```
public static final org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration workspaceConfigurationExternal
```
  - workspaceConfigurationCache
```
public static final org.nd4j.linalg.api.memory.conf.WorkspaceConfiguration workspaceConfigurationCache
```
  - lastEtlTime
```
protected transient ThreadLocal<Long> lastEtlTime
```
  - vertices
```
protected GraphVertex[] vertices
```
    All GraphVertex objects in the network.
  - verticesMap
```
protected Map<String,GraphVertex> verticesMap
```
    Map of vertices by name
  - topologicalOrder
```
protected int[] topologicalOrder
```
    Indexes of graph vertices, in topological order. The topological order defines the order in which forward pass (and hence also backward pass, which is the opposite to this) is conducted in the network.
  - layers
```
protected Layer[] layers
```
    A list of layers. Each of these layers is present in a GraphVertex, but are here for easy reference. This array also defines the order in which the getLayer(int) method returns layers.
- Constructor Detail
  - ComputationGraph
```
public ComputationGraph(ComputationGraphConfiguration configuration)
```
- Method Detail
  - setLastEtlTime
```
public void setLastEtlTime(long time)
```
    This method allows to set ETL field time, useful for performance tracking
    
    Parameters:
    
    time -
  - getLastEtlTime
```
public long getLastEtlTime()
```
    This method returns ETL time field value
    
    Returns:
  - setCacheMode
```
public void setCacheMode(CacheMode mode)
```
    This method sets specified CacheMode for all layers within network
    
    Parameters:
    
    mode -
  - getConfiguration
```
public ComputationGraphConfiguration getConfiguration()
```
    This method returns configuration of this ComputationGraph
    
    Returns:
  - getNumLayers
```
public int getNumLayers()
```
    Returns the number of layers in the ComputationGraph
  - getLayer
```
public Layer getLayer(int idx)
```
    Get the layer by the number of that layer, in range 0 to getNumLayers()-1 NOTE: This is different from the internal GraphVertex index for the layer
  - getLayers
```
public Layer[] getLayers()
```
    Get all layers in the ComputationGraph
  - getLayer
```
public Layer getLayer(String name)
```
    Get a given layer by name.
  - getVertices
```
public GraphVertex[] getVertices()
```
    Returns an array of all GraphVertex objects.
  - getVertex
```
public GraphVertex getVertex(String name)
```
    Return a given GraphVertex by name, or null if no vertex with that name exists
  - getNumInputArrays
```
public int getNumInputArrays()
```
    The number of inputs to this network
  - getNumOutputArrays
```
public int getNumOutputArrays()
```
    The number of output (arrays) for this network
  - setInput
```
public void setInput(int inputNum,
                     org.nd4j.linalg.api.ndarray.INDArray input)
```
    Set the specified input for the ComputationGraph
  - setInputs
```
public void setInputs(org.nd4j.linalg.api.ndarray.INDArray... inputs)
```
    Set all inputs for the ComputationGraph network
  - getInput
```
public org.nd4j.linalg.api.ndarray.INDArray getInput(int inputNum)
```
    Get the previously set input for the ComputationGraph
  - getInputs
```
public org.nd4j.linalg.api.ndarray.INDArray[] getInputs()
```
    Get the previously set inputs for the ComputationGraph
  - getInputMaskArrays
```
public org.nd4j.linalg.api.ndarray.INDArray[] getInputMaskArrays()
```
    Get the previously set feature/input mask arrays for the ComputationGraph
  - getLabelMaskArrays
```
public org.nd4j.linalg.api.ndarray.INDArray[] getLabelMaskArrays()
```
    Get the previously set label/output mask arrays for the ComputationGraph
  - setLabel
```
public void setLabel(int labelNum,
                     org.nd4j.linalg.api.ndarray.INDArray label)
```
    Set the specified label for the ComputationGraph
  - setLabels
```
public void setLabels(org.nd4j.linalg.api.ndarray.INDArray... labels)
```
    Set all labels for the ComputationGraph network
  - setGradientsAccumulator
```
public void setGradientsAccumulator(GradientsAccumulator accumulator)
```
    This method allows you to specificy GradientsAccumulator instance to be used with this model PLEASE NOTE: Do not use this method unless you understand how to use GradientsAccumulator & updates sharing. PLEASE NOTE: Do not use this method on standalone model
    
    Parameters:
    
    accumulator -
  - init
```
public void init()
```
    Initialize the ComputationGraph network
    
    Specified by:
    
    init in interface Model
    
    Specified by:
    
    init in interface NeuralNetwork
  - init
```
public void init(org.nd4j.linalg.api.ndarray.INDArray parameters,
                 boolean cloneParametersArray)
```
    Initialize the ComputationGraph, optionally with an existing parameters array. If an existing parameters array is specified, it will be used (and the values will not be modified) in the network; if no parameters array is specified, parameters will be initialized randomly according to the network configuration.
    
    Parameters:
    
    parameters - Network parameter. May be null. If null: randomly initialize.
    
    cloneParametersArray - Whether the parameter array (if any) should be cloned, or used directly
  - initGradientsView
```
public void initGradientsView()
```
    This method: initializes the flattened gradients array (used in backprop) and sets the appropriate subset in all layers. As a general rule, this shouldn't ever need to be called manually when doing training via fit(DataSet), fit(DataSetIterator) or fit(MultiDataSet) methods
  - pretrain
```
public void pretrain(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iter)
```
    Pretrain network with a single input and single output. DataSetIterators can only be used if the number of input arrays for the ComputationGraph is 1. For networks with more than one input use pretrain(MultiDataSetIterator)
  - pretrain
```
public void pretrain(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iter)
```
    Pretrain network with multiple inputs and/or outputs
  - pretrainLayer
```
public void pretrainLayer(String layerName,
                          org.nd4j.linalg.dataset.api.iterator.DataSetIterator dataSetIterator)
```
    Pretrain a specified layer with the given DataSetIterator
    
    Parameters:
    
    layerName - Layer name
    
    dataSetIterator - Data
  - pretrainLayer
```
public void pretrainLayer(String layerName,
                          org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iter)
```
    Pretrain a specified layer with the given MultiDataSetIterator
    
    Parameters:
    
    layerName - Layer name
    
    iter - Training data
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.DataSet dataSet)
```
    Fit the ComputationGraph using a DataSet. Note that this method can only be used with ComputationGraphs with 1 input and 1 output. For networks with more than one input or output, use fit(MultiDataSetIterator)
    
    Specified by:
    
    fit in interface NeuralNetwork
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)
```
    Fit the ComputationGraph using a DataSetIterator. Note that this method can only be used with ComputationGraphs with 1 input and 1 output
    
    Specified by:
    
    fit in interface NeuralNetwork
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.MultiDataSet multiDataSet)
```
    Fit the ComputationGraph using a MultiDataSet
    
    Specified by:
    
    fit in interface NeuralNetwork
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator multi)
```
    Fit the ComputationGraph using a MultiDataSetIterator
    
    Specified by:
    
    fit in interface NeuralNetwork
  - migrate
```
protected void migrate(org.nd4j.linalg.dataset.api.MultiDataSet ds)
```
  - migrate
```
protected void migrate(org.nd4j.linalg.dataset.api.DataSet ds)
```
  - fit
```
public void fit(org.nd4j.linalg.api.ndarray.INDArray[] inputs,
                org.nd4j.linalg.api.ndarray.INDArray[] labels)
```
    Fit the ComputationGraph given arrays of inputs and labels.
    
    Parameters:
    
    inputs - The network inptus
    
    labels - The labels
  - fit
```
public void fit(org.nd4j.linalg.api.ndarray.INDArray[] inputs,
                org.nd4j.linalg.api.ndarray.INDArray[] labels,
                org.nd4j.linalg.api.ndarray.INDArray[] featureMaskArrays,
                org.nd4j.linalg.api.ndarray.INDArray[] labelMaskArrays)
```
    Fit the ComputationGraph using the specified inputs and labels (and mask arrays)
    
    Parameters:
    
    inputs - The network inputs (features)
    
    labels - The network labels
    
    featureMaskArrays - Mask arrays for inputs/features. Typically used for RNN training. May be null.
    
    labelMaskArrays - Mas arrays for the labels/outputs. Typically used for RNN training. May be null.
  - topologicalSortOrder
```
public int[] topologicalSortOrder()
```
    Calculate a topological sort order for the vertices in the graph. Note that this is used for (a) working out what order to do forward pass, (b) what order to do backprop (i.e., reverse of this) (c) order to flatten parameters (and gradients) Specifically, gradients/params/forward pass are executed on vertex[topologicalSortOrder[i]], for i=0..nVertices-1
  - computeGradientAndScore
```
public void computeGradientAndScore()
```
    Description copied from interface: Model
    
    Update the score
    
    Specified by:
    
    computeGradientAndScore in interface Model
  - feedForward
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> feedForward(org.nd4j.linalg.api.ndarray.INDArray input,
                                                                    boolean train)
```
    Conduct forward pass using a single input array. Note that this method can only be used with ComputationGraphs with a single input array.
    
    Parameters:
    
    input - The input array
    
    train - If true: do forward pass at training time
    
    Returns:
    
    A map of activations for each layer (not each GraphVertex). Keys = layer name, values = layer activations
  - feedForward
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> feedForward(org.nd4j.linalg.api.ndarray.INDArray[] input,
                                                                    boolean train)
```
    Conduct forward pass using an array of inputs
    
    Parameters:
    
    input - An array of ComputationGraph inputs
    
    train - If true: do forward pass at training time; false: do forward pass at test time
    
    Returns:
    
    A map of activations for each layer (not each GraphVertex). Keys = layer name, values = layer activations
  - feedForward
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> feedForward()
```
    Conduct forward pass using the stored inputs, at test time
    
    Returns:
    
    A map of activations for each layer (not each GraphVertex). Keys = layer name, values = layer activations
  - feedForward
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> feedForward(boolean train)
```
    Conduct forward pass using the stored inputs
    
    Parameters:
    
    train - If true: do forward pass at training time; false: do forward pass at test time
    
    Returns:
    
    A map of activations for each layer (not each GraphVertex). Keys = layer name, values = layer activations
  - feedForward
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> feedForward(boolean train,
                                                                    boolean excludeOutputLayers)
```
  - feedForward
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> feedForward(boolean train,
                                                                    boolean excludeOutputLayers,
                                                                    boolean includeNonLayerVertexActivations)
```
    Parameters:
    
    train - True: training time. False: test time
    
    excludeOutputLayers - Should we exclude the output layers during forward pass? (usually: false)
    
    includeNonLayerVertexActivations - Include non-layer vertices in the output may?
    
    Returns:
    
    Map of activations. Key: vertex name. Value: activations.
  - feedForward
```
protected Map<String,org.nd4j.linalg.api.ndarray.INDArray> feedForward(boolean train,
                                                                       boolean excludeOutputLayers,
                                                                       boolean includeNonLayerVertexActivations,
                                                                       boolean publicApi)
```
    PLEASE NEVER USE THIS METHOD IF YOU"RE NOT SURE WHAT YOU'll GET
    
    Parameters:
    
    train -
    
    excludeOutputLayers -
    
    includeNonLayerVertexActivations -
    
    publicApi -
    
    Returns:
  - output
```
public org.nd4j.linalg.api.ndarray.INDArray[] output(org.nd4j.linalg.api.ndarray.INDArray... input)
```
    Return an array of network outputs (predictions) at test time, given the specified network inputs Network outputs are for output layers only.
    
    Parameters:
    
    input - Inputs to the network
    
    Returns:
    
    Output activations (order: same as defined in network configuration)
  - outputSingle
```
public org.nd4j.linalg.api.ndarray.INDArray outputSingle(org.nd4j.linalg.api.ndarray.INDArray... input)
```
    A convenience method that returns a single INDArray, instead of an INDArray[]. Useful for ComputationGraphs that have only a single output. Otherwise identical to output(INDArray...)
    
    Parameters:
    
    input - Inputs to the network
    
    Returns:
    
    Output activations array
  - output
```
public org.nd4j.linalg.api.ndarray.INDArray[] output(boolean train,
                                                     org.nd4j.linalg.api.ndarray.INDArray... input)
```
    Return an array of network outputs (predictions), given the specified network inputs Network outputs are for output layers only.
    
    Parameters:
    
    train - If true: do forward pass at training time; false: do forward pass at test time
    
    input - Inputs to the network
    
    Returns:
    
    Output activations (order: same as defined in network configuration)
  - silentOutput
```
protected org.nd4j.linalg.api.ndarray.INDArray[] silentOutput(boolean train,
                                                              org.nd4j.linalg.api.ndarray.INDArray... input)
```
  - outputSingle
```
public org.nd4j.linalg.api.ndarray.INDArray outputSingle(boolean train,
                                                         org.nd4j.linalg.api.ndarray.INDArray... input)
```
    A convenience method that returns a single INDArray, instead of an INDArray[]. Useful for ComputationGraphs that have only a single output. Otherwise identical to output(boolean, INDArray...)
    
    Parameters:
    
    train - If true: do forward pass at training time; false: do forward pass at test time
    
    input - Inputs to the network
    
    Returns:
    
    Output activations array
  - backpropGradient
```
public Gradient backpropGradient(org.nd4j.linalg.api.ndarray.INDArray... epsilons)
```
    Calculate the gradient of the network with respect to some external errors. Note that this is typically used for things like reinforcement learning, not typical networks that include an OutputLayer or RnnOutputLayer
    
    Parameters:
    
    epsilons - Epsilons (errors) at the output. Same order with which the output layers are defined in configuration setOutputs(String...)
    
    Returns:
    
    Gradient for the network
  - calcBackpropGradients
```
protected void calcBackpropGradients(boolean truncatedBPTT,
                                     org.nd4j.linalg.api.ndarray.INDArray... externalEpsilons)
```
    Do backprop (gradient calculation)
    
    Parameters:
    
    truncatedBPTT - false: normal backprop. true: calculate gradients using truncated BPTT for RNN layers
    
    externalEpsilons - null usually (for typical supervised learning). If not null (and length > 0) then assume that the user has provided some errors externally, as they would do for example in reinforcement learning situations.
  - clone
```
public ComputationGraph clone()
```
    Overrides:
    
    clone in class Object
  - calcL2
```
public double calcL2()
```
    Calculate the L2 regularization term for all layers in the entire network. This is the sum of the L2 terms for each layer individually
  - calcL1
```
public double calcL1()
```
    Calculate the L1 regularization term for all layers in the entire network. This is the sum of the L1 terms for each layer individually
  - setListeners
```
public void setListeners(Collection<IterationListener> listeners)
```
    Set the IterationListeners for the ComputationGraph (and all layers in the network)
    
    Specified by:
    
    setListeners in interface Model
  - setListeners
```
public void setListeners(IterationListener... listeners)
```
    Set the IterationListeners for the ComputationGraph (and all layers in the network)
    
    Specified by:
    
    setListeners in interface Model
  - addListeners
```
public void addListeners(IterationListener... listeners)
```
    This method ADDS additional IterationListener to existing listeners
    
    Specified by:
    
    addListeners in interface Model
    
    Parameters:
    
    listener -
  - getListeners
```
public Collection<IterationListener> getListeners()
```
    Get the IterationListeners for the ComputationGraph
  - getUpdater
```
public ComputationGraphUpdater getUpdater()
```
    Get the ComputationGraphUpdater for the network
  - setUpdater
```
public void setUpdater(ComputationGraphUpdater updater)
```
    Set the computationGraphUpdater for the network
  - getOutputLayer
```
public Layer getOutputLayer(int outputLayerIdx)
```
    Get the specified output layer, by index. The index of the output layer may be 0 to getNumOutputArrays()-1
  - params
```
public org.nd4j.linalg.api.ndarray.INDArray params(boolean backwardOnly)
```
    Get the parameters for the ComputationGraph
    
    Parameters:
    
    backwardOnly - If true: backprop parameters only (i.e., no visible layer biases used in layerwise pretraining layers)
  - score
```
public double score(org.nd4j.linalg.dataset.api.DataSet dataSet)
```
    Sets the input and labels and returns a score for the prediction with respect to the true labels
    This is equivalent to score(DataSet, boolean) with training==true.
    NOTE: this version of the score function can only be used with ComputationGraph networks that have a single input and a single output.
    
    Parameters:
    
    dataSet - the data to score
    
    Returns:
    
    the score for the given input,label pairs
    
    See Also:
    
    score(DataSet, boolean)
  - score
```
public double score(org.nd4j.linalg.dataset.api.DataSet dataSet,
                    boolean training)
```
    Sets the input and labels and returns a score for the prediction with respect to the true labels
    NOTE: this version of the score function can only be used with ComputationGraph networks that have a single input and a single output. Use score(MultiDataSet, boolean) for multiple input/output networks
    
    Parameters:
    
    dataSet - the data to score
    
    training - whether score is being calculated at training time (true) or test time (false)
    
    Returns:
    
    the score for the given input,label pairs
    
    See Also:
    
    score(DataSet, boolean)
  - score
```
public double score(org.nd4j.linalg.dataset.api.MultiDataSet dataSet)
```
    Score the network given the MultiDataSet, at test time
  - score
```
public double score(org.nd4j.linalg.dataset.api.MultiDataSet dataSet,
                    boolean training)
```
    Sets the input and labels and returns a score for the prediction with respect to the true labels
    
    Parameters:
    
    dataSet - the data to score
    
    training - whether score is being calculated at training time (true) or test time (false)
    
    Returns:
    
    the score for the given input,label pairs
  - scoreExamples
```
public org.nd4j.linalg.api.ndarray.INDArray scoreExamples(org.nd4j.linalg.dataset.api.DataSet data,
                                                          boolean addRegularizationTerms)
```
    Calculate the score for each example in a DataSet individually. Unlike score(DataSet) and score(DataSet, boolean) this method does not average/sum over examples. This method allows for examples to be scored individually (at test time only), which may be useful for example for autoencoder architectures and the like.
    Each row of the output (assuming addRegularizationTerms == true) is equivalent to calling score(DataSet) with a single example.
    
    Parameters:
    
    data - The data to score
    
    addRegularizationTerms - If true: add l1/l2 regularization terms (if any) to the score. If false: don't add regularization terms
    
    Returns:
    
    An INDArray (column vector) of size input.numRows(); the ith entry is the score (loss value) of the ith example
  - scoreExamples
```
public org.nd4j.linalg.api.ndarray.INDArray scoreExamples(org.nd4j.linalg.dataset.api.MultiDataSet data,
                                                          boolean addRegularizationTerms)
```
    Calculate the score for each example in a DataSet individually. Unlike score(MultiDataSet) and score(MultiDataSet, boolean) this method does not average/sum over examples. This method allows for examples to be scored individually (at test time only), which may be useful for example for autoencoder architectures and the like.
    Each row of the output (assuming addRegularizationTerms == true) is equivalent to calling score(MultiDataSet) with a single example.
    
    Parameters:
    
    data - The data to score
    
    addRegularizationTerms - If true: add l1/l2 regularization terms (if any) to the score. If false: don't add regularization terms
    
    Returns:
    
    An INDArray (column vector) of size input.numRows(); the ith entry is the score (loss value) of the ith example
  - fit
```
public void fit()
```
    Description copied from interface: Model
    
    All models have a fit method
    
    Specified by:
    
    fit in interface Model
  - update
```
public void update(org.nd4j.linalg.api.ndarray.INDArray gradient,
                   String paramType)
```
    Description copied from interface: Model
    
    Perform one update applying the gradient
    
    Specified by:
    
    update in interface Model
    
    Parameters:
    
    gradient - the gradient to apply
  - update
```
public void update(Gradient gradient)
```
    Description copied from interface: Model
    
    Update layer weights and biases with gradient change
    
    Specified by:
    
    update in interface Model
  - score
```
public double score()
```
    Description copied from interface: Model
    
    The score for the model
    
    Specified by:
    
    score in interface Model
    
    Returns:
    
    the score for the model
  - setScore
```
public void setScore(double score)
```
  - accumulateScore
```
public void accumulateScore(double accum)
```
    Description copied from interface: Model
    
    Sets a rolling tally for the score. This is useful for mini batch learning when you are accumulating error across a dataset.
    
    Specified by:
    
    accumulateScore in interface Model
    
    Parameters:
    
    accum - the amount to accum
  - params
```
public org.nd4j.linalg.api.ndarray.INDArray params()
```
    Description copied from interface: Model
    
    Parameters of the model (if any)
    
    Specified by:
    
    params in interface Model
    
    Specified by:
    
    params in interface NeuralNetwork
    
    Returns:
    
    the parameters of the model
  - updaterState
```
public org.nd4j.linalg.api.ndarray.INDArray updaterState()
```
    Description copied from interface: NeuralNetwork
    
    This method returns updater state (if applicable), null otherwise
    
    Specified by:
    
    updaterState in interface NeuralNetwork
    
    Returns:
  - numParams
```
public int numParams()
```
    Description copied from interface: Model
    
    the number of parameters for the model
    
    Specified by:
    
    numParams in interface Model
    
    Returns:
    
    the number of parameters for the model
  - numParams
```
public int numParams(boolean backwards)
```
    Description copied from interface: Model
    
    the number of parameters for the model
    
    Specified by:
    
    numParams in interface Model
    
    Returns:
    
    the number of parameters for the model
  - setParams
```
public void setParams(org.nd4j.linalg.api.ndarray.INDArray params)
```
    Description copied from interface: Model
    
    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
  - setParamsViewArray
```
public void setParamsViewArray(org.nd4j.linalg.api.ndarray.INDArray gradient)
```
    Description copied from interface: Model
    
    Set the initial parameters array as a view of the full (backprop) network parameters NOTE: this is intended to be used internally in MultiLayerNetwork and ComputationGraph, not by users.
    
    Specified by:
    
    setParamsViewArray in interface Model
    
    Parameters:
    
    gradient - a 1 x nParams row vector that is a view of the larger (MLN/CG) parameters array
  - getGradientsViewArray
```
public org.nd4j.linalg.api.ndarray.INDArray getGradientsViewArray()
```
    Specified by:
    
    getGradientsViewArray in interface Model
  - setBackpropGradientsViewArray
```
public void setBackpropGradientsViewArray(org.nd4j.linalg.api.ndarray.INDArray gradient)
```
    Description copied from interface: Model
    
    Set the gradients array as a view of the full (backprop) network parameters NOTE: this is intended to be used internally in MultiLayerNetwork and ComputationGraph, not by users.
    
    Specified by:
    
    setBackpropGradientsViewArray in interface Model
    
    Parameters:
    
    gradient - a 1 x nParams row vector that is a view of the larger (MLN/CG) gradients array
  - applyLearningRateScoreDecay
```
public void applyLearningRateScoreDecay()
```
    Description copied from interface: Model
    
    Update learningRate using for this model. Use the learningRateScoreBasedDecay to adapt the score if the Eps termination condition is met
    
    Specified by:
    
    applyLearningRateScoreDecay in interface Model
  - fit
```
public void fit(org.nd4j.linalg.api.ndarray.INDArray data)
```
    Description copied from interface: Model
    
    Fit the model to the given data
    
    Specified by:
    
    fit in interface Model
    
    Parameters:
    
    data - the data to fit the model to
  - iterate
```
public void iterate(org.nd4j.linalg.api.ndarray.INDArray input)
```
    Description copied from interface: Model
    
    Run one iteration
    
    Specified by:
    
    iterate in interface Model
    
    Parameters:
    
    input - the input to iterate on
  - gradient
```
public Gradient gradient()
```
    Description copied from interface: Model
    
    Calculate a gradient
    
    Specified by:
    
    gradient in interface Model
    
    Returns:
    
    the gradient for this model
  - gradientAndScore
```
public org.nd4j.linalg.primitives.Pair<Gradient,Double> gradientAndScore()
```
    Description copied from interface: Model
    
    Get the gradient and score
    
    Specified by:
    
    gradientAndScore in interface Model
    
    Returns:
    
    the gradient and score
  - batchSize
```
public int batchSize()
```
    Description copied from interface: Model
    
    The current inputs batch size
    
    Specified by:
    
    batchSize in interface Model
    
    Returns:
    
    the current inputs batch size
  - conf
```
public NeuralNetConfiguration conf()
```
    Description copied from interface: Model
    
    The configuration for the neural network
    
    Specified by:
    
    conf in interface Model
    
    Returns:
    
    the configuration for the neural network
  - setConf
```
public void setConf(NeuralNetConfiguration conf)
```
    Description copied from interface: Model
    
    Setter for the configuration
    
    Specified by:
    
    setConf in interface Model
  - input
```
public org.nd4j.linalg.api.ndarray.INDArray input()
```
    Description copied from interface: Model
    
    The input/feature matrix for the model
    
    Specified by:
    
    input in interface Model
    
    Returns:
    
    the input/feature matrix for the model
  - validateInput
```
public void validateInput()
```
    Description copied from interface: Model
    
    Validate the input
    
    Specified by:
    
    validateInput in interface Model
  - getOptimizer
```
public ConvexOptimizer getOptimizer()
```
    Description copied from interface: Model
    
    Returns this models optimizer
    
    Specified by:
    
    getOptimizer in interface Model
    
    Specified by:
    
    getOptimizer in interface NeuralNetwork
    
    Returns:
    
    this models optimizer
  - getParam
```
public org.nd4j.linalg.api.ndarray.INDArray getParam(String paramName)
```
    Description copied from interface: Model
    
    Get the parameter
    
    Specified by:
    
    getParam in interface Model
    
    Parameters:
    
    paramName - the key of the parameter
    
    Returns:
    
    the parameter vector/matrix with that particular key
  - initParams
```
public void initParams()
```
    Description copied from interface: Model
    
    Initialize the parameters
    
    Specified by:
    
    initParams in interface Model
  - paramTable
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> paramTable()
```
    Description copied from interface: Model
    
    The param table
    
    Specified by:
    
    paramTable in interface Model
    
    Returns:
  - paramTable
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> paramTable(boolean backpropParamsOnly)
```
    Description copied from interface: Model
    
    Table of parameters by key, for backprop For many models (dense layers, etc) - all parameters are backprop parameters
    
    Specified by:
    
    paramTable in interface Model
    
    Parameters:
    
    backpropParamsOnly - If true, return backprop params only. If false: return all params (equivalent to paramsTable())
  - setParamTable
```
public void setParamTable(Map<String,org.nd4j.linalg.api.ndarray.INDArray> paramTable)
```
    Description copied from interface: Model
    
    Setter for the param table
    
    Specified by:
    
    setParamTable in interface Model
  - setParam
```
public void setParam(String key,
                     org.nd4j.linalg.api.ndarray.INDArray val)
```
    Description copied from interface: Model
    
    Set the parameter with a new ndarray
    
    Specified by:
    
    setParam in interface Model
    
    Parameters:
    
    key - the key to se t
    
    val - the new ndarray
  - clear
```
public void clear()
```
    Description copied from interface: Model
    
    Clear input
    
    Specified by:
    
    clear in interface Model
  - rnnTimeStep
```
public org.nd4j.linalg.api.ndarray.INDArray[] rnnTimeStep(org.nd4j.linalg.api.ndarray.INDArray... inputs)
```
    If this ComputationGraph contains one or more RNN layers: conduct forward pass (prediction) but using previous stored state for any RNN layers. The activations for the final step are also stored in the RNN layers for use next time rnnTimeStep() is called.
    This method can be used to generate output one or more steps at a time instead of always having to do forward pass from t=0. Example uses are for streaming data, and for generating samples from network output one step at a time (where samples are then fed back into the network as input)
    If no previous state is present in RNN layers (i.e., initially or after calling rnnClearPreviousState()), the default initialization (usually 0) is used.
    Supports mini-batch (i.e., multiple predictions/forward pass in parallel) as well as for single examples.
    
    Parameters:
    
    inputs - Input to network. May be for one or multiple time steps. For single time step: input has shape [miniBatchSize,inputSize] or [miniBatchSize,inputSize,1]. miniBatchSize=1 for single example.
    For multiple time steps: [miniBatchSize,inputSize,inputTimeSeriesLength]
    
    Returns:
    
    Output activations. If output is RNN layer (such as RnnOutputLayer): if all inputs have shape [miniBatchSize,inputSize] i.e., is 2d, then outputs have shape [miniBatchSize,outputSize] (i.e., also 2d) instead of [miniBatchSize,outputSize,1].
    Otherwise output is 3d [miniBatchSize,outputSize,inputTimeSeriesLength] when using RnnOutputLayer (or unmodified otherwise).
  - rnnGetPreviousState
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> rnnGetPreviousState(int layer)
```
    Get the state of the RNN layer, as used in rnnTimeStep(INDArray...).
    
    Parameters:
    
    layer - Number/index of the layer.
    
    Returns:
    
    Hidden state, or null if layer is not an RNN layer
  - rnnGetPreviousState
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> rnnGetPreviousState(String layerName)
```
    Get the state of the RNN layer, as used in rnnTimeStep(INDArray...).
    
    Parameters:
    
    layerName - name of the layer
    
    Returns:
    
    Hidden state, or null if layer is not an RNN layer
  - rnnGetPreviousStates
```
public Map<String,Map<String,org.nd4j.linalg.api.ndarray.INDArray>> rnnGetPreviousStates()
```
    Get a map of states for ALL RNN layers, as used in rnnTimeStep(INDArray...). Layers that are not RNN layers will not have an entry in the returned map
    
    Returns:
    
    Map of states (keyed by layer name) or null if layer is not an RNN layer
    
    See Also:
    
    rnnSetPreviousStates(Map)
  - rnnSetPreviousState
```
public void rnnSetPreviousState(int layer,
                                Map<String,org.nd4j.linalg.api.ndarray.INDArray> state)
```
    Set the state of the RNN layer, for use in rnnTimeStep(INDArray...)
    
    Parameters:
    
    layer - The number/index of the layer.
    
    state - The state to set the specified layer to
  - rnnSetPreviousState
```
public void rnnSetPreviousState(String layerName,
                                Map<String,org.nd4j.linalg.api.ndarray.INDArray> state)
```
    Set the state of the RNN layer, for use in rnnTimeStep(INDArray...)
    
    Parameters:
    
    layerName - The name of the layer.
    
    state - The state to set the specified layer to
  - rnnSetPreviousStates
```
public void rnnSetPreviousStates(Map<String,Map<String,org.nd4j.linalg.api.ndarray.INDArray>> previousStates)
```
    Set the states for all RNN layers, for use in rnnTimeStep(INDArray...)
    
    Parameters:
    
    previousStates - The previous time step states for all layers (key: layer name. Value: layer states)
    
    See Also:
    
    rnnGetPreviousStates()
  - rnnClearPreviousState
```
public void rnnClearPreviousState()
```
    Clear the previous state of the RNN layers (if any), used in rnnTimeStep(INDArray...)
  - doTruncatedBPTT
```
protected void doTruncatedBPTT(org.nd4j.linalg.api.ndarray.INDArray[] inputs,
                               org.nd4j.linalg.api.ndarray.INDArray[] labels,
                               org.nd4j.linalg.api.ndarray.INDArray[] featureMasks,
                               org.nd4j.linalg.api.ndarray.INDArray[] labelMasks)
```
    Fit the network using truncated BPTT
  - rnnActivateUsingStoredState
```
public Map<String,org.nd4j.linalg.api.ndarray.INDArray> rnnActivateUsingStoredState(org.nd4j.linalg.api.ndarray.INDArray[] inputs,
                                                                                    boolean training,
                                                                                    boolean storeLastForTBPTT)
```
    Similar to rnnTimeStep and feedForward() methods. Difference here is that this method:
    (a) like rnnTimeStep does forward pass using stored state for RNN layers, and
    (b) unlike rnnTimeStep does not modify the RNN layer state
    Therefore multiple calls to this method with the same input should have the same output.
    Typically used during training only. Use rnnTimeStep for prediction/forward pass at test time.
    
    Parameters:
    
    inputs - Input to network
    
    training - Whether training or not
    
    storeLastForTBPTT - set to true if used as part of truncated BPTT training
    
    Returns:
    
    Activations for each layer (including input, as per feedforward() etc)
  - setLayerMaskArrays
```
public void setLayerMaskArrays(org.nd4j.linalg.api.ndarray.INDArray[] featureMaskArrays,
                               org.nd4j.linalg.api.ndarray.INDArray[] labelMaskArrays)
```
    Set the mask arrays for features and labels. Mask arrays are typically used in situations such as one-to-many and many-to-one learning with recurrent neural networks, as well as for supporting time series of varying lengths within the same minibatch.
    For example, with RNN data sets with input of shape [miniBatchSize,nIn,timeSeriesLength] and outputs of shape [miniBatchSize,nOut,timeSeriesLength], the features and mask arrays will have shape [miniBatchSize,timeSeriesLength] and contain values 0 or 1 at each element (to specify whether a given input/example is present - or merely padding - at a given time step).
    NOTE: This method is not usually used directly. Instead, the various feedForward and fit methods handle setting of masking internally.
    
    Parameters:
    
    featureMaskArrays - Mask array for features (input)
    
    labelMaskArrays - Mask array for labels (output)
    
    See Also:
    
    clearLayerMaskArrays()
  - clearLayerMaskArrays
```
public void clearLayerMaskArrays()
```
    Remove the mask arrays from all layers.
    See setLayerMaskArrays(INDArray[], INDArray[]) for details on mask arrays.
  - rnnUpdateStateWithTBPTTState
```
protected void rnnUpdateStateWithTBPTTState()
```
    Update the internal state of RNN layers after a truncated BPTT fit call
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)
```
    Evaluate the network (classification performance - single output ComputationGraphs only)
    
    Parameters:
    
    iterator - Iterator to evaluate on
    
    Returns:
    
    Evaluation object; results of evaluation on all examples in the data set
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator)
```
    Evaluate the network (classification performance - single output ComputationGraphs only)
    
    Parameters:
    
    iterator - Iterator to evaluate on
    
    Returns:
    
    Evaluation object; results of evaluation on all examples in the data set
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                           List<String> labelsList)
```
    Evaluate the network on the provided data set (single output ComputationGraphs only). Used for evaluating the performance of classifiers
    
    Parameters:
    
    iterator - Data to undertake evaluation on
    
    Returns:
    
    Evaluation object, summarizing the results of the evaluation on the provided DataSetIterator
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator,
                           List<String> labelsList)
```
    Evaluate the network on the provided data set (single output ComputationGraphs only). Used for evaluating the performance of classifiers
    
    Parameters:
    
    iterator - Data to undertake evaluation on
    
    Returns:
    
    Evaluation object, summarizing the results of the evaluation on the provided DataSetIterator
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                           List<String> labelsList,
                           int topN)
```
    Evaluate the network (for classification) on the provided data set, with top N accuracy in addition to standard accuracy. For 'standard' accuracy evaluation only, use topN = 1
    
    Parameters:
    
    iterator - Iterator (data) to evaluate on
    
    labelsList - List of labels. May be null.
    
    topN - N value for top N accuracy evaluation
    
    Returns:
    
    Evaluation object, summarizing the results of the evaluation on the provided DataSetIterator
  - evaluate
```
public Evaluation evaluate(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator,
                           List<String> labelsList,
                           int topN)
```
    Evaluate the network (for classification) on the provided data set, with top N accuracy in addition to standard accuracy. For 'standard' accuracy evaluation only, use topN = 1
    
    Parameters:
    
    iterator - Iterator (data) to evaluate on
    
    labelsList - List of labels. May be null.
    
    topN - N value for top N accuracy evaluation
    
    Returns:
    
    Evaluation object, summarizing the results of the evaluation on the provided DataSetIterator
  - evaluateRegression
```
public RegressionEvaluation evaluateRegression(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator)
```
    Evaluate the (single output layer only) network for regression performance
    
    Parameters:
    
    iterator - Data to evaluate on
    
    Returns:
    
    Regression evaluation
  - evaluateRegression
```
public RegressionEvaluation evaluateRegression(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator)
```
    Evaluate the (single output layer only) network for regression performance
    
    Parameters:
    
    iterator - Data to evaluate on
    
    Returns:
    
    Regression evaluation
  - evaluateRegression
```
public RegressionEvaluation evaluateRegression(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                                               List<String> columnNames)
```
    Evaluate the (single output layer only) network for regression performance
    
    Parameters:
    
    iterator - Data to evaluate on
    
    columnNames - Column names for the regression evaluation. May be null.
    
    Returns:
    
    Regression evaluation
  - evaluateRegression
```
public RegressionEvaluation evaluateRegression(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator,
                                               List<String> columnNames)
```
    Evaluate the (single output layer only) network for regression performance
    
    Parameters:
    
    iterator - Data to evaluate on
    
    Returns:
    
    Regression evaluation
  - evaluateROC
```
public ROC evaluateROC(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                       int rocThresholdSteps)
```
    Evaluate the network (must be a binary classifier) on the specified data, using the ROC class
    
    Parameters:
    
    iterator - Data to evaluate on
    
    rocThresholdSteps - Number of threshold steps to use with ROC
    
    Returns:
    
    ROC evaluation on the given dataset
  - evaluateROC
```
public ROC evaluateROC(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator,
                       int rocThresholdSteps)
```
    Evaluate the network (must be a binary classifier) on the specified data, using the ROC class
    
    Parameters:
    
    iterator - Data to evaluate on
    
    rocThresholdSteps - Number of threshold steps to use with ROC
    
    Returns:
    
    ROC evaluation on the given dataset
  - evaluateROCMultiClass
```
public ROCMultiClass evaluateROCMultiClass(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                                           int rocThresholdSteps)
```
    Evaluate the network on the specified data, using the ROCMultiClass class
    
    Parameters:
    
    iterator - Data to evaluate on
    
    rocThresholdSteps - Number of threshold steps to use with ROCMultiClass
    
    Returns:
    
    Multi-class ROC evaluation on the given dataset
  - evaluateROCMultiClass
```
public ROCMultiClass evaluateROCMultiClass(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator,
                                           int rocThresholdSteps)
```
    Evaluate the network on the specified data, using the ROCMultiClass class
    
    Parameters:
    
    iterator - Data to evaluate on
    
    rocThresholdSteps - Number of threshold steps to use with ROCMultiClass
    
    Returns:
    
    Multi-class ROC evaluation on the given dataset
  - doEvaluation
```
public <T extends IEvaluation> T[] doEvaluation(org.nd4j.linalg.dataset.api.iterator.DataSetIterator iterator,
                                                T... evaluations)
```
    Perform evaluation on the given data (DataSetIterator) with the given IEvaluation instance
    
    Specified by:
    
    doEvaluation in interface NeuralNetwork
    
    Type Parameters:
    
    T - Type of the IEvaluation instance
    
    Parameters:
    
    iterator - Test data to evaluate on
    
    evaluation - IEvaluation insntance
    
    Returns:
    
    The input IEvaluation instance, after performing evaluation on the test data
  - doEvaluation
```
public <T extends IEvaluation> T[] doEvaluation(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iterator,
                                                T... evaluations)
```
    Perform evaluation on the given data (MultiDataSetIterator) with the given IEvaluation instance
    
    Specified by:
    
    doEvaluation in interface NeuralNetwork
    
    Type Parameters:
    
    T - Type of the IEvaluation instance
    
    Parameters:
    
    iterator - Test data to evaluate on
    
    evaluations - IEvaluation insntance
    
    Returns:
    
    The input IEvaluation instance, after performing evaluation on the test data
  - summary
```
public String summary()
```
    String detailing the architecture of the computation graph. Vertices are printed in a topological sort order. Columns are Vertex Names with layer/vertex type, nIn, nOut, Total number of parameters and the Shapes of the parameters And the inputs to the vertex Will also give information about frozen layers/vertices, if any.
    
    Returns:
    
    Summary as a string
  - clearLayersStates
```
protected void clearLayersStates()
```
    This method just makes sure there's no state preserved within layers
  - equals
```
public boolean equals(Object obj)
```
    Indicates whether some other object is "equal to" this one.
    The equals method implements an equivalence relation on non-null object references:
    - It is reflexive: for any non-null reference value x, x.equals(x) should return true.
    - It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
    - It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
    - It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
    - For any non-null reference value x, x.equals(null) should return false.
    The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).
    Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    obj - the reference object with which to compare.
    
    Returns:
    
    true if this object is the same as the obj argument; false otherwise.
    
    See Also:
    
    Object.hashCode(), HashMap

Class ComputationGraph

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

configuration

initCalled

solver

flattenedParams

flattenedGradients

gradient

score

workspaceCache

workspaceExternal

workspaceFeedForward

workspacePretrain

workspaceTBPTT

workspaceLSTM

workspaceConfigurationFeedForward

workspaceConfigurationTBPTT

workspaceConfigurationLSTM

workspaceConfigurationExternal

workspaceConfigurationCache

lastEtlTime

vertices

verticesMap

topologicalOrder

layers

Constructor Detail

ComputationGraph

Method Detail

setLastEtlTime

getLastEtlTime

setCacheMode

getConfiguration

getNumLayers

getLayer

getLayers

getLayer

getVertices

getVertex

getNumInputArrays

getNumOutputArrays

setInput

setInputs

getInput

getInputs

getInputMaskArrays

getLabelMaskArrays

setLabel

setLabels

setGradientsAccumulator

init

init

initGradientsView

pretrain

pretrain

pretrainLayer

pretrainLayer

fit

fit

fit

fit

migrate

migrate

fit

fit

topologicalSortOrder

computeGradientAndScore

feedForward

feedForward

feedForward

feedForward

feedForward

feedForward

feedForward

output

outputSingle

output