ComputationGraph (deeplearning4j-nn 0.6.0 API)

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

All Implemented Interfaces:

Serializable, Model
```
public class ComputationGraph
extends Object
implements Serializable, Model
```
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 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

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`	`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.
`ComputationGraph`	`clone()`
`void`	`computeGradientAndScore()` Update the score
`NeuralNetConfiguration`	`conf()` The configuration for the neural network
`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
`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(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()`
`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
`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 param)` 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
`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
`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
`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
`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`	`setConf(NeuralNetConfiguration conf)` Setter for the configuration
`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`	`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
`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
`void`	`validateInput()` Validate the input

Methods inherited from class java.lang.Object
equals, 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
```
  - 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
  - getConfiguration
```
public ComputationGraphConfiguration getConfiguration()
```
  - 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
  - init
```
public void init()
```
    Initialize the ComputationGraph network
  - 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 and output arrays for the ComputationGraph are both 1. For networks with more than one input or output, use pretrain(MultiDataSetIterator)
  - pretrain
```
public void pretrain(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator iter)
```
    Pretrain network with multiple inputs and/or outputs
  - 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)
  - 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
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.MultiDataSet multiDataSet)
```
    Fit the ComputationGraph using a MultiDataSet
  - fit
```
public void fit(org.nd4j.linalg.dataset.api.iterator.MultiDataSetIterator multi)
```
    Fit the ComputationGraph using a MultiDataSetIterator
  - 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)
  - 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
  - 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)
  - 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)
  - setListeners
```
public void setListeners(IterationListener... listeners)
```
    Set the IterationListeners for the ComputationGraph (and all layers in the network)
  - 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
    
    Returns:
    
    the parameters of the model
  - 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
  - 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 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
    
    Returns:
    
    this models optimizer
  - getParam
```
public org.nd4j.linalg.api.ndarray.INDArray getParam(String param)
```
    Description copied from interface: Model
    
    Get the parameter
    
    Specified by:
    
    getParam in interface Model
    
    Parameters:
    
    param - 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:
  - 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

Class ComputationGraph

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

configuration

initCalled

solver

flattenedParams

flattenedGradients

gradient

score

vertices

verticesMap

topologicalOrder

layers

Constructor Detail

ComputationGraph

Method Detail

getConfiguration

getNumLayers

getLayer

getLayers

getLayer

getVertices

getVertex

getNumInputArrays

getNumOutputArrays

setInput

setInputs

getInput

getInputs

getInputMaskArrays

getLabelMaskArrays

setLabel

setLabels

init

init

initGradientsView

pretrain

pretrain

fit

fit

fit

fit

fit

fit

topologicalSortOrder

computeGradientAndScore

feedForward

feedForward

feedForward

feedForward

output

outputSingle

output

outputSingle

backpropGradient

calcBackpropGradients

clone

calcL2

calcL1

setListeners

setListeners

getListeners

getUpdater

setUpdater

getOutputLayer

params

score

score

score

score

scoreExamples

scoreExamples

fit

update

update

score