SameDiff (nd4j-api 1.0.0-beta5 API)

java.lang.Object
- org.nd4j.autodiff.samediff.ops.SDBaseOps
- - org.nd4j.autodiff.samediff.SameDiff

```
public class SameDiff
extends SDBaseOps
```
SameDiff is the entrypoint for ND4J's automatic differentiation functionality.
You define a graph symbolically.
That graph accumulates operations.
In order to execute the graph, you run one of the execution methods, such as output(Map, String...)

Field Summary

Fields
Modifier and Type	Field and Description
`SDBitwise`	`bitwise` Op creator object for bitwise operations
`SDCNN`	`cnn` Op creator object for convolutional neural network operations
`protected static String`	`GRAD_FN_KEY`
`SDImage`	`image` Op creator object for image operations
`SDLoss`	`loss` Op creator object for loss function operations
`SDMath`	`math` Op creator object for math operations
`SDNN`	`nn` Op creator object for general neural network operations
`SDRandom`	`random` Op creator object for random number generation operations
`SDRNN`	`rnn` Op creator object for recurrent neural network operations

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addArgsFor(SDVariable[] variables, DifferentialFunction function)` Adds incoming arguments for the specified differential function to the graph
`void`	`addArgsFor(String[] variables, DifferentialFunction function)` Adds incoming arguments for the specified differential function to the graph
`void`	`addArgumentInterceptor(ArgumentInterceptor interceptor)` Add a new argument interceptor to the interceptor stack
`void`	`addListeners(Collection<? extends Listener> listeners)` See `addListeners(Listener...)`.
`void`	`addListeners(Listener... listeners)` Add SameDiff-wide `Listener` instances.
`void`	`addLossVariable(SDVariable variable)` See `addLossVariable(String)`
`void`	`addLossVariable(String variableName)` Mark the specified variable as a loss function variable.
`void`	`addOutgoingFor(SDVariable[] variables, DifferentialFunction function)` Adds outgoing arguments to the graph for the specified DifferentialFunction Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
`void`	`addOutgoingFor(String[] varNames, DifferentialFunction function)` Adds outgoing arguments to the graph for the specified DifferentialFunction Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
`void`	`addPropertyToResolve(DifferentialFunction forFunction, String arrayName)` Adds a property that needs to be resolve for later.
`SDVariable`	`addVariable(SDVariable variable)` Add the specified variable to this SameDiff instance
`void`	`addVariableMappingForField(DifferentialFunction function, String fieldName, String varName)` Adds a field name -> variable name mapping for a given function. This is used for model import where there is an unresolved variable at the time of calling any `GraphMapper.importGraph(File)` .
`boolean`	`arrayAlreadyExistsForVarName(String varName)` Returns true if the given vertex id and `INDArray` already exist.
`ByteBuffer`	`asFlatBuffers(boolean includeUpdaterState)` This method exports the current SameDiff instance into FlatBuffers format, returning the array ops and all arrays as a ByteBuffer containing the FlatBuffers format data Uses the default `ExecutorConfiguration` with output mode as `OutputMode.VARIABLE_SPACE`, execution mode as `ExecutionMode.SEQUENTIAL`, with profiling disabled and gather timings enabled.
`ByteBuffer`	`asFlatBuffers(ExecutorConfiguration configuration, boolean includeUpdaterState)` This method exports the current SameDiff instance into FlatBuffers format, returning the array ops and all arrays as a ByteBuffer containing the FlatBuffers format data
`ByteBuffer`	`asFlatBuffers(long graphId, ExecutorConfiguration configuration, boolean includeUpdaterState)` This method exports the current SameDiff instance into FlatBuffers format, returning the array ops and all arrays as a ByteBuffer containing the FlatBuffers format data
`void`	`asFlatFile(File file)` This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later This includes the updater state, if applicable.
`void`	`asFlatFile(File file, boolean withUpdaterState)` See `asFlatFile(File, ExecutorConfiguration, boolean)`.
`void`	`asFlatFile(File file, ExecutorConfiguration configuration, boolean includeUpdaterState)` This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later
`FlatGraph`	`asFlatGraph(boolean includeUpdaterState)` See `asFlatGraph(long, ExecutorConfiguration, boolean)`.
`FlatGraph`	`asFlatGraph(long graphId, ExecutorConfiguration configuration, boolean includeUpdaterState)` This method returns FlatGraph structure
`protected int`	`asFlatNode(String name, SameDiff scope, com.google.flatbuffers.FlatBufferBuilder bufferBuilder)`
`String`	`asFlatPrint()` This method returns a text representation of the "flattened" graph.
`void`	`assignArray(INDArray arr, SDVariable variable)` Update the constant or variable type SDVariable with the values from the specified array.
`void`	`associateArrayWithVariable(INDArray arr, SDVariable variable)` Associate the array with the given variable.
`void`	`associateArrayWithVariable(INDArray arr, String variable)` Associate the array with the given variable.
`protected void`	`associateSameDiffWithOpsAndVariables()` Associate the current SameDiff instance with all ops and variables.
`BatchOutputConfig`	`batchOutput()` Set up for a single batch inference operation using OutputConfig.
`protected Map<String,INDArray>`	`batchOutputHelper(Map<String,INDArray> placeholders, List<Listener> listeners, String... outputs)`
`SDBitwise`	`bitwise()` Op creator object for bitwise operations
`double`	`calcRegularizationScore()` Calculate the regularization (L1, L2 and/or WeightDecay) component of the loss function for the current parameters..
`Map<String,DataType>`	`calculateOutputDataTypes()` Calculate data types for the variables in the graph
`Map<String,DataType>`	`calculateOutputDataTypes(boolean dynamicUpdate)` Calculate data types for the variables in the graph
`void`	`clearOpInputs()` Clear the input arrays to each op.
`void`	`clearPlaceholders(boolean allThreads)` Clear the placeholder arrays from the SameDiff instance
`SDCNN`	`cnn()` Op creator object for convolutional neural network operations
`SDVariable`	`constant(double value)` Create a new double scalar constant (rank 0) with the specified value. Constants are not modified by training/backprop.
`SDVariable`	`constant(float value)` Create a new float scalar constant (rank 0) with the specified value Constants are not modified by training/backprop.
`SDVariable`	`constant(INDArray constant)` Create an SDVariable with a fixed/constant value, with a generated name Constants are not modified by training/backprop.
`SDVariable`	`constant(int value)` Create a new integer scalar constant (rank 0) with the specified value
`SDVariable`	`constant(long value)` Create a new long scalar constant (rank 0) with the specified value
`SDVariable`	`constant(SDVariable value, long... shape)` Deprecated.
`SDVariable`	`constant(String name, DataType dataType, Number value)` Create a new scalar constant (rank 0) with the specified value and datatype
`SDVariable`	`constant(String name, double value)` Create a new double scalar constant (rank 0) with the specified value
`SDVariable`	`constant(String name, float value)` Create a new float scalar constant (rank 0) with the specified value
`SDVariable`	`constant(String name, INDArray constant)` Create an SDVariable with a fixed/constant value Constants are not modified by training/backprop.
`SDVariable`	`constant(String name, int value)` Create a new integer scalar constant (rank 0) with the specified value
`SDVariable`	`constant(String name, long value)` Create a new long scalar constant (rank 0) with the specified value
`SDVariable`	`constant(String name, SDVariable value, long... shape)` Deprecated.
`void`	`convertDataTypes(Map<String,DataType> dataTypeMap)` Convert the datatypes of the specified constants, placeholders and variables. After conversion, the downstream datatypes are changed.
`SDVariable`	`convertToConstant(SDVariable variable)` Convert the specified variable to a constant.
`void`	`convertToConstants(List<SDVariable> variables)` Convert all of the specified variables to constants.
`SDVariable`	`convertToVariable(SDVariable constant)` Convert the specified variable to a VARIABLE type SDVariable. This can only be done for constants and placeholders, not ARRAY type variables (which are usually network activations).
`void`	`convertToVariables(List<SDVariable> constants)` Convert the specified variables to VARIABLE type SDVariables. This can only be done for constants and placeholders, not ARRAY type variables (which are usually network activations).
`static SameDiff`	`create()` Create a new (empty) SameDiff instance without any functions or variables
`static SameDiff`	`create(SameDiff originalSameDiff)` Create a new SameDiff instance from an existing instance.
`void`	`createGradFunction()` Create the gradient function (for calculating gradients via `execBackwards(Map, Operation, String[])`) if it is not already defined.
`void`	`createGradFunction(String... variablesRequiringGradients)` As per `createGradFunction()`, but this method allows a set of variables requiring gradients to be specified.
`String`	`currentNameScope()`
`Collection<String>`	`definedFunctionNames()` The set of defined SameDiff function names.
`void`	`defineFunction(String function, SameDiffFunctionDefinition functionDefinition)`
`void`	`defineFunction(String function, SameDiffFunctionDefinition functionDefinition, Map<String,INDArray> inputs)`
`SameDiff`	`defineFunction(String function, SameDiffFunctionDefinition functionDefinition, SDVariable[] variables)`
`protected Map<String,INDArray>`	`directExecHelper(Map<String,INDArray> placeholders, At at, MultiDataSet batch, Collection<String> requiredActivations, List<Listener> activeListeners, String... outputs)` Do inference for the given variables for a single batch, with training information
`SameDiff`	`disableDebugging()` Clears debugging state and disables debug mode.
`SameDiff`	`dup()` Clone/duplicate the SameDiff instance, including arrays etc.
`SameDiff`	`enableDebugMode()` Enables tracing of graphs automatically.
`boolean`	`equals(Object o)`
`EvaluationConfig`	`evaluate()` Set up for a evaluation operation using EvaluationConfig.
`void`	`evaluate(DataSetIterator iterator, Map<String,IEvaluation> variableEvals, Listener... listeners)` Evaluation for multiple-output networks. See `evaluate(MultiDataSetIterator, Map, Map, Listener[])`.
`void`	`evaluate(DataSetIterator iterator, String outputVariable, IEvaluation... evaluations)` See `evaluate(DataSetIterator, String, List, IEvaluation[])`.
`void`	`evaluate(DataSetIterator iterator, String outputVariable, List<Listener> listeners, IEvaluation... evaluations)` Evaluate the performance of a single variable's prediction. For example, if the variable to evaluatate was called "softmax" you would use:
`void`	`evaluate(MultiDataSetIterator iterator, Map<String,List<IEvaluation>> variableEvals, Map<String,Integer> predictionLabelMapping, Listener... listeners)` Perform evaluation using classes such as `Evaluation` for classifier outputs and `RegressionEvaluation` for regression outputs. Example: classifier evaluation Predictions variable name: "softmaxOutput" Evaluations to perform: `Evaluation` Data: single input, single output MultiDataSets Code:
`void`	`evaluate(MultiDataSetIterator iterator, String outputVariable, int labelIndex, IEvaluation... evaluations)` See `evaluate(MultiDataSetIterator, String, int, List, IEvaluation[])`.
`void`	`evaluate(MultiDataSetIterator iterator, String outputVariable, int labelIndex, List<Listener> listeners, IEvaluation... evaluations)` Evaluate the performance of a single variable's prediction. For example, if the variable to evaluatate was called "softmax" you would use:
`void`	`evaluateMultiple(DataSetIterator iterator, Map<String,List<IEvaluation>> variableEvals, Listener... listeners)` Evaluation for multiple output networks - one or more.
`Map<String,INDArray>`	`exec(Map<String,INDArray> placeholders, List<String> outputs)` Deprecated. See `output(Map, List)` and `batchOutput()`
`Map<String,INDArray>`	`exec(Map<String,INDArray> placeholders, String... outputs)` Deprecated. See `output(Map, String...)` and `batchOutput()`
`Map<String,INDArray>`	`execAll(Map<String,INDArray> placeholders)` Deprecated. See `outputAll(Map)` and `batchOutput()`
`INDArray`	`execAndEndResult()` Deprecated.
`void`	`execBackwards(Map<String,INDArray> placeholders)` See `execBackwards(Map, Operation)`.
`Map<String,INDArray>`	`execBackwards(Map<String,INDArray> placeholders, List<String> variableGradNamesList)` See `execBackwards(Map, List, Operation)`.
`Map<String,INDArray>`	`execBackwards(Map<String,INDArray> placeholders, List<String> variableGradNamesList, Operation operation)` As per `execBackwards(Map, Operation, MultiDataSet, Collection, List)`, but the set of gradients to calculate can be specified manually. For example, to calculate the gradient for placeholder variable "myPlaceholder", use `execBackwards(placeholders, Arrays.asList(myPlaceholder.gradient().getVarName())`.
`protected Map<String,INDArray>`	`execBackwards(Map<String,INDArray> placeholders, List<String> variableGradNamesList, Operation operation, MultiDataSet batch, Collection<String> requiredActivations, List<Listener> activeListeners)`
`void`	`execBackwards(Map<String,INDArray> placeholders, Operation op)` Create (if required) and then calculate the variable gradients (backward pass) for this graph. After execution, the gradient arrays can be accessed using `myVariable.getGradient().getArr()` Note: This method by default calculates VARIABLE type SDVariable gradients only (as well as any other gradients needed to calculate the variable gradients).
`protected void`	`execBackwards(Map<String,INDArray> placeholders, Operation op, MultiDataSet batch, Collection<String> requiredActivations, List<Listener> activeListeners)`
`Map<String,INDArray>`	`execBackwards(Map<String,INDArray> placeholders, Operation op, String... variableGradNamesList)` See `execBackwards(Map, List, Operation)`
`Map<String,INDArray>`	`execBackwards(Map<String,INDArray> placeholders, String... variableGradNamesList)` See `execBackwards(Map, Operation, String...)`.
`INDArray`	`execSingle(Map<String,INDArray> placeholders, String output)` Deprecated. See `outputSingle(Map, String)` and `batchOutput()`
`DifferentialFunctionFactory`	`f()` Returns this samediff instance's `DifferentialFunctionFactory`
`FitConfig`	`fit()` Set up for a fit operation using `FitConfig`.
`History`	`fit(DataSetIterator iter, int numEpochs, DataSetIterator validationIter, int validationFrequency, Listener... listeners)` Fit the SameDiff instance based on DataSetIterator for the specified number of epochs. This method can only be used for singe input, single output SameDiff instances as DataSet only supports a single input and a single output. Note that a `TrainingConfig` must be set via `setTrainingConfig(TrainingConfig)` before training can be performed.
`History`	`fit(DataSetIterator iter, int numEpochs, Listener... listeners)` See `fit(DataSetIterator, int, DataSetIterator, int, Listener...)`, does not preform validation.
`History`	`fit(DataSet dataSet, Listener... listeners)` Fit the SameDiff instance based on a single DataSet (i.e., a single minibatch for one iteration). This method can only be used for singe input, single output SameDiff instances as DataSet only supports a single input and a single output. Note that a `TrainingConfig` must be set via `setTrainingConfig(TrainingConfig)` before training can be performed.
`protected History`	`fit(MultiDataSetIterator iter, int numEpochs, boolean incrementEpochCount, MultiDataSetIterator validationData, int validationFrequency, Listener... listeners)`
`History`	`fit(MultiDataSetIterator iter, int numEpochs, Listener... listeners)` See `fit(MultiDataSetIterator, int, MultiDataSetIterator, int, Listener...)`, does not preform validation.
`History`	`fit(MultiDataSetIterator iter, int numEpochs, MultiDataSetIterator validationIter, int validationFrequency, Listener... listeners)` Fit the SameDiff instance based on MultiDataSetIterator for the specified number of epochs. This method can both singe input, single output and multi-input, multi-output SameDiff instances Note that a `TrainingConfig` must be set via `setTrainingConfig(TrainingConfig)` before training can be performed.
`History`	`fit(MultiDataSet dataSet, Listener... listeners)` Fit the SameDiff instance based on a single MultiDataSet (i.e., a single minibatch for one iteration). Note that a `TrainingConfig` must be set via `setTrainingConfig(TrainingConfig)` before training can be performed.
`protected History`	`fitHelper(MultiDataSetIterator iter, int numEpochs, boolean incrementEpochCount, MultiDataSetIterator validationData, int validationFrequency, List<Listener> listeners)`
`static SameDiff`	`fromFlatBuffers(ByteBuffer bbIn)` Create a `SameDiff` instance from a byte buffers instance.
`static SameDiff`	`fromFlatBuffers(ByteBuffer bbIn, boolean loadUpdaterState)` Create a `SameDiff` instance from a byte buffers instance.
`static SameDiff`	`fromFlatFile(File file)` Create a `SameDiff` instance from a file, including the updater state The method to save the file is `save(File, boolean)`
`static SameDiff`	`fromFlatFile(File file, boolean loadUpdaterState)` Create a `SameDiff` instance from a file, optionally also loading the updater state The method to save the file is `save(File, boolean)`
`String`	`generateDistinctCustomVariableName(String base)` Returns an unused variable name of the format <base>_#.
`String`	`generateNewVarName(String base, int argIndex)` See `generateNewVarName(String, int, boolean)` existingOp is true.
`String`	`generateNewVarName(String base, int argIndex, boolean existingOp)` Generate a new, distinct variable name of the form <base>_#[:#].
`SDVariable[]`	`generateOutputVariableForOp(DifferentialFunction function)` Generate the variables based on the given input op and return the output variable names.
`SDVariable[]`	`generateOutputVariableForOp(DifferentialFunction function, String baseName, boolean isImport)` Generate the variables based on the given input op and return the output variable names.
`INDArray`	`getArrForVarName(String varName)` Get an `INDArray` for a given vertex id, or null if none exists
`String`	`getBaseNameForFunction(DifferentialFunction function)` Returns the base name for the given function if any (may return null)
`SameDiff`	`getFunction(String functionName)` Get a SameDiff function instance given the name of the function
`SDVariable`	`getGradForVariable(String varName)` Get the gradient for the variable with the specified name. The gradient variable is the variable that represents the derivative of the loss function with respect to the output of this variable.
`String[]`	`getInputsForOp(DifferentialFunction function)` Returns the name(s) of the inputs for the given function
`SDVariable[]`	`getInputVariablesForOp(DifferentialFunction function)` Get the input variable(s) for the specified differential function
`List<Listener>`	`getListeners()` Gets the current SameDiff-wide listeners.
`List<String>`	`getLossVariables()` Get the names of variables (if any) that have been marked as loss variables to be minimized. Variables can be marked as loss variables in a few different ways: (a) Losses are automatically added when creating loss functions via `sd()` (b) Via `setLossVariables(String...)`, @link #addLossVariable(String)} or `SDVariable.markAsLoss()` (c) Via `TrainingConfig#setLossVariables(List)`
`DifferentialFunction`	`getOpById(String id)` Get the function by the `DifferentialFunction#getOwnName()`
`String`	`getOpName(String base)` See `getOpName(String, boolean)` force is false
`String`	`getOpName(String base, boolean force)` Generate a new, distinct op name of the form <base>_#.
`List<SameDiffOp>`	`getOpsInScope(NameScope scope)` Gets all operations in a given name scope.
`List<SameDiffOp>`	`getOpsInScope(String scope)` See `getOpsInScope(NameScope)`.
`long[]`	`getOriginalShapeForPlaceHolder(String varName)` Deprecated.
`String[]`	`getOutputsForOp(DifferentialFunction function)` Returns the name(s) of the outputs for the given function
`SDVariable[]`	`getOutputVariablesForOp(DifferentialFunction function)` Get the output variable(s) for the specified differential function
`LongShapeDescriptor`	`getShapeDescriptorForVarName(String varName)` See `getShapeForVarName(String)`, but returns the shape descriptor.
`long[]`	`getShapeForVarName(String varName)` Get the shape for the given vertex id.
`SDVariable`	`getVariable(String name)` Get the variable based on the opName
`DifferentialFunction`	`getVariableOutputOp(String variableName)` Get the differential function (if any) that this variable is the output for
`List<SDVariable>`	`getVariablesInScope(NameScope scope)` Gets all variables in a given name scope.
`List<SDVariable>`	`getVariablesInScope(String scope)` See `getVariablesInScope(NameScope)`.
`String`	`getVarNameForFieldAndFunction(DifferentialFunction function, String fieldName)` Get the variable name to use for resolving a given field for a given function during import time.
`SDVariable`	`grad(String varName)` Get the gradient for the variable with the specified variable name.
`boolean`	`hasArgs(DifferentialFunction function)` Returns true if this function already has defined arguments
`boolean`	`hasGradientFunction()` Returns true if the gradient function has been created - i.e., `createGradFunction()` or `createGradFunction(String...)` has been called at all
`int`	`hashCode()`
`boolean`	`hasVariable(String name)`
`If`	`ifStatement(SameDiffConditional conditional, SameDiffFunctionDefinition conditionBody, SameDiffFunctionDefinition trueBody, SameDiffFunctionDefinition falseBody, SDVariable[] inputVars)` Deprecated. Use `SDBaseOps.ifCond(String, String, SameDiffNoArgSingleLambda, SameDiffNoArgSingleLambda, SameDiffNoArgSingleLambda)`
`SDImage`	`image()` Op creator object for image operations
`static SameDiff`	`importFrozenTF(File graphFile)` Import a frozen Tensorflow graph to a new SameDiff graph.
`static SameDiff`	`importFrozenTF(GraphDef graphDef)` See `importFrozenTF(File)`
`static SameDiff`	`importFrozenTF(InputStream graph)` See `importFrozenTF(File)`
`protected void`	`initializeTraining()` Perform setup for training.
`List<String>`	`inputs()` Returns the inputs (placeholders) for the SameDiff graph
`SDVariable`	`invoke(Op op, SDVariable x)` Invoke an op by opName
`SDVariable`	`invoke(Op op, SDVariable x, SDVariable y)` Deprecated.
`SDVariable`	`invokeFunctionOn(String functionName, SameDiff with)`
`SDVariable`	`invokeGraphOn(SameDiff sameDiff)`
`boolean`	`isPlaceHolder(String varName)` Returns true if this vertex id is a place holder variable or not A place holder variable is one where the array shape(s) are currently known and can't yet be calculated
`static SameDiff`	`load(File file, boolean loadUpdaterState)` Load the SameDiff instance previously saved with `save(File, boolean)`
`static SameDiff`	`load(InputStream is, boolean loadUpdaterState)` As per `load(File, boolean)` but the SameDiff instance
`SDLoss`	`loss()` Op creator object for loss function operations
`SDMath`	`math()` Op creator object for math operations
`protected String`	`nameWithScope(String name)`
`String`	`newBlockName(String baseName)` For internal use only.
`SDNN`	`nn()` Op creator object for general neural network operations
`long`	`numElements()` Count the number of elements in all arrays, according to `SDVariable.getShape()`
`SDVariable`	`one(String name, DataType dataType, int... shape)` Create a new variable with the specified shape, with all values initialized to 1.0
`SDVariable`	`one(String name, DataType dataType, long... shape)` Create a new variable with the specified shape, with all values initialized to 1.0
`SDVariable`	`one(String name, int... shape)` See `one(String, DataType, int...)`.
`SDVariable`	`one(String name, long... shape)` See `one(String, DataType, long...)`.
`boolean`	`opExists(String id)` Returns true if the given function id exists
`DifferentialFunction[]`	`ops()` Get an array of differential functions that have been defined for this SameDiff instance
`OutputConfig`	`output()` Set up for an inference operation using OutputConfig.
`Map<String,INDArray>`	`output(DataSetIterator iterator, List<Listener> listeners, String... outputs)` Do inference on a network with a single input. For example, if the variable to infer was called "softmax" you would use:
`Map<String,INDArray>`	`output(DataSetIterator dataSet, String... outputs)` See `output(DataSetIterator, List, String...)`.
`Map<String,INDArray>`	`output(DataSet dataSet, String... outputs)` Do a single batch inference on a network with a single input. For example, if the variable to infer was called "softmax" you would use:
`Map<String,INDArray>`	`output(Map<String,INDArray> placeholders, List<Listener> listeners, String... outputs)` Do inference for the given variables for a single batch.
`Map<String,INDArray>`	`output(Map<String,INDArray> placeholders, List<String> outputs)` Do inference for the given variables for a single batch.
`Map<String,INDArray>`	`output(Map<String,INDArray> placeholders, String... outputs)` Do inference for the given variables for a single batch.
`Map<String,INDArray>`	`output(MultiDataSetIterator iterator, List<Listener> listeners, String... outputs)` Perform inference. Example: classifier inference Predictions variable name: "softmaxOutput" Evaluations to perform: `Evaluation` Data: single output MultiDataSets Code:
`Map<String,INDArray>`	`output(MultiDataSetIterator dataSet, String... outputs)` See `output(MultiDataSetIterator, List, String...)`.
`Map<String,INDArray>`	`output(MultiDataSet dataSet, String... outputs)` Do a single batch inference on a network. For example, if the variable to infer was called "softmax" you would use:
`Map<String,INDArray>`	`outputAll(Map<String,INDArray> placeholders)` Do inference for all variables for a single batch.
`List<Map<String,INDArray>>`	`outputBatches(DataSetIterator iterator, List<Listener> listeners, String... outputs)` See `output(DataSetIterator, List, String...)`, but without the concatenation of batches.
`List<Map<String,INDArray>>`	`outputBatches(DataSetIterator iterator, String... outputs)` See `output(DataSetIterator, String...)`, but without the concatenation of batches.
`List<Map<String,INDArray>>`	`outputBatches(MultiDataSetIterator iterator, List<Listener> listeners, String... outputs)` Perform inference. Example: classifier inference Predictions variable name: "softmaxOutput" Evaluations to perform: `Evaluation` Data: single output MultiDataSets Code:
`List<Map<String,INDArray>>`	`outputBatches(MultiDataSetIterator iterator, String... outputs)` See `outputBatches(MultiDataSetIterator, List, String...)`.
`List<String>`	`outputs()` Outputs are those variables (not placeholders, constants, etc) that are the output of a function that aren't the input to any other ops.
`INDArray`	`outputSingle(Map<String,INDArray> placeholders, String output)` Do inference for a single variable for a single batch.
`static org.nd4j.linalg.primitives.Pair<String,Integer>`	`parseVariable(String varName)` Note: INTENDED FOR DEVELOPER USE This method extract base variable name and output index (if exists) from raw variable name.
`void`	`pauseArgumentInterceptor()` Pause the top (most recently added) argument interceptor
`void`	`pauseArgumentInterceptor(ArgumentInterceptor interceptor)` Pause the given argument interceptor
`SDVariable`	`placeHolder(String name, DataType dataType, long... shape)` Create a a placeholder variable.
`List<String>`	`propertiesToResolveForFunction(DifferentialFunction function)` Return the properties to resolve for the given function.
`void`	`putOpForId(String id, DifferentialFunction function)` Put the function for the given id
`void`	`putOrUpdateShapeForVarName(String varName, long[] shape, boolean clearArrayOnShapeMismatch)` Deprecated.
`void`	`putShapeForVarName(String varName, long[] shape)` Deprecated.
`void`	`putShapeForVarName(String varName, LongShapeDescriptor shape)` Sets the shape descriptor for a variable.
`void`	`putSubFunction(String name, SameDiff nameSpace)` Associate a `SameDiff` namespace as a sub function.
`SDRandom`	`random()` Op creator object for random number generation operations
`void`	`removeArgFromOp(String varName, DifferentialFunction function)` Remove an argument for a function.
`void`	`removeArgumentInterceptor()` Remote the top (most recently added) argument interceptor
`void`	`removePropertyToResolve(DifferentialFunction forFunction, String arrayName)` Remove a property to resolve added with `addPropertyToResolve(DifferentialFunction, String)`
`void`	`renameVariable(String from, String to)` Rename the specified variable to the new name.
`void`	`replaceArgFor(int i, SDVariable newArg, DifferentialFunction function)` Replaces the argument at i with newArg for function Does not use (or remove) ArgumentInterceptor stuff
`void`	`resolveVariablesWith(Map<String,INDArray> arrays)` Resolve all ndarrays by updating the variables for each array specified in the given map.
`SDRNN`	`rnn()` Op creator object for recurrent neural network operations
`void`	`save(File file, boolean saveUpdaterState)` Save the SameDiff instance to a file.
`void`	`save(OutputStream outputStream, boolean saveUpdater)` As per `save(File, boolean)` but the serialized SameDiff instance is written to the output stream instead.
`SDVariable`	`scalar(String name, DataType dataType, Number value)` Create a new scalar (rank 0) SDVariable with the specified value and datatype
`SDVariable`	`scalar(String name, double value)` Create a new double scalar (rank 0) SDVariable with the specified value
`SDVariable`	`scalar(String name, float value)` Create a new float scalar (rank 0) SDVariable with the specified value
`SDVariable`	`scalar(String name, int value)` Create a new integer scalar (rank 0) SDVariable with the specified value
`SDVariable`	`scalar(String name, long value)` Create a new long scalar (rank 0) SDVariable with the specified value
`protected SameDiff`	`sd()`
`void`	`setArrayForVariable(String varName, INDArray arr)` Set the stored `INDArray` for a variable.
`void`	`setBaseNameForFunctionInstanceId(String baseName, DifferentialFunction function)` Sets a base name for the function id.
`void`	`setForwardVariableForVarName(String varName, SDVariable forwardVariable)`
`void`	`setGradientForVariableName(String variableName, SDVariable variable)` Assign a SDVariable to represent the gradient of the SDVariable with the specified name
`void`	`setListeners(Collection<? extends Listener> listeners)` See `setListeners(Listener...)`.
`void`	`setListeners(Listener... listeners)` Set the current SameDiff-wide `Listener` instances.
`void`	`setLossVariables(SDVariable... lossVariables)` See `setLossVariables(String...)`
`void`	`setLossVariables(String... lossVariableNames)` Clear/remove any existing loss variables, and set the loss variables to the specified variable names. See `addLossVariable(String)` for more details
`void`	`setOriginalPlaceHolderShape(String variableName, long[] shape)` Set the original shape for a given place holder. This is used to track original shapes of place holder variables. The reason we track original shapes is to validate possible candidate arrays coming in (especially with -1 as the expected shapes).
`void`	`setTrainingConfig(TrainingConfig trainingConfig)` Set the training configuration (`TrainingConfig`) for the SameDiff instance.
`<X extends SDVariable> X`	`setupFunction(X function)` Attempts to insert the `DifferentialFunction` reference in to this `SameDiff` instance.
`boolean`	`shapeAlreadyExistsForVarName(String varName)` Returns true if the given vertex id and shape already exist.
`String`	`summary()` Generate and return a String representation of the current SameDiff instance Reports variables, ops, SameDiff function instances, and (where possible) array shapes. For ops, the input and output variables are reported. For variables, the ops that they are inputs to - or outputs of - are also reported
`TensorArray`	`tensorArray(DataType dataType)` Create a new TensorArray.
`void`	`unpauseArgumentInterceptor()` Unpause the top (most recently added) argument interceptor
`void`	`unpauseArgumentInterceptor(ArgumentInterceptor interceptor)` Unpause the top given argument interceptor
`void`	`updateVariableName(String varName, String withName)` Update the opName for the variable with the given vertex id
`SDVariable`	`updateVariableNameAndReference(SDVariable varToUpdate, String newVarName)` Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.
`SDVariable[]`	`updateVariableNamesAndReferences(SDVariable[] variablesToUpdate, String[] newVariableNames)` Updates the variable name property on the passed in variables, its reference in samediff, and returns the variable.
`SDVariable`	`var(DataType dataType, int... shape)` Creates a `SDVariable` with the specified shape and a generated name Any array will be generated with all zeros for the values This method creates a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.
`SDVariable`	`var(DataType dataType, long... shape)` Creates a `SDVariable` with the specified shape and a generated name Any array will be generated with all zeros for the values This method creates a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.
`SDVariable`	`var(INDArray arr)` Create an `SDVariable` with a generated name, and assocate the specified array with it. This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.
`SDVariable`	`var(SDVariable v)` Initialize a `SDVariable` reference tying this variable to this samediff instance.
`SDVariable`	`var(String name, DataType dataType, int... shape)` Creates a `SDVariable` with the given shape and name Any array will be generated with all zeros for the values
`SDVariable`	`var(String name, DataType dataType, long... shape)` Creates a `SDVariable` with the given shape and name Any array will be generated with all zeros for the values This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.
`SDVariable`	`var(String name, INDArray arr)` Create an `SDVariable` with the specified name, and associate the specified array with it This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.
`SDVariable`	`var(String name, int... shape)` Creates a `SDVariable` with the given shape and name Any array will be generated with all zeros for the values.
`SDVariable`	`var(String name, long... shape)` Creates a `SDVariable` with the given shape and name Any array will be generated with all zeros for the values.
`SDVariable`	`var(String name, LongShapeDescriptor shapeDesc)` Creates a `SDVariable` with the given shape and name Any array will be generated with all zeros for the values This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.
`SDVariable`	`var(String name, LongShapeDescriptor shape, WeightInitScheme weightInitScheme)` Creates a `SDVariable` with the given shape and name The underlying array will be initialized using the specified weight initilization scheme This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.
`SDVariable`	`var(String name, VariableType variableType, WeightInitScheme weightInitScheme, DataType dataType, long... shape)` Variable initialization with a specified `WeightInitScheme` This method creates VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.
`SDVariable`	`var(String name, WeightInitScheme weightInitScheme, DataType dataType, long... shape)` Variable initialization with a specified `WeightInitScheme` This method creates VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.
`SDVariable`	`var(WeightInitScheme weightInitScheme, DataType dataType, long... shape)` Creates a `SDVariable` with the specified shape and a generated name.
`boolean`	`variableHasGradient(String varName)` Determine if the specified variable has a gradient with respect to the current loss.
`Map<String,SDVariable>`	`variableMap()` Return a copy of the internal variable map
`List<SDVariable>`	`variables()` The list of all variables in the graph
`While`	`whileStatement(SameDiffConditional sameDiffConditional, SameDiffFunctionDefinition conditionBody, SameDiffFunctionDefinition loopBody, SDVariable[] inputVars)` Deprecated. Use `SDBaseOps.whileLoop(String[], String, SDVariable[], SameDiffSingleLambda, SameDiffLambda)`
`NameScope`	`withNameScope(String nameScope)` Create a name scope.
`SDVariable`	`zero(String name, DataType dataType, int... shape)` Create a new variable with the specified shape, with all values initialized to 0
`SDVariable`	`zero(String name, DataType dataType, long... shape)` Create a new variable with the specified shape, with all values initialized to 0
`SDVariable`	`zero(String name, int... shape)` See `zero(String, DataType, int...)`.
`SDVariable`	`zero(String name, long... shape)` See `zero(String, DataType, long...)`.

Methods inherited from class org.nd4j.autodiff.samediff.ops.SDBaseOps
all, all, any, any, argmax, argmax, argmax, argmax, argmin, argmin, argmin, argmin, assign, assign, assign, assign, batchMmul, batchMmul, batchMmul, castTo, castTo, concat, concat, cumprod, cumprod, cumsum, cumsum, dot, dot, dynamicPartition, dynamicPartition, dynamicStitch, dynamicStitch, eq, eq, eq, eq, expandDims, expandDims, fill, fill, gather, gather, gather, gather, gatherNd, gatherNd, gradientBackwardsMarker, gradientBackwardsMarker, gt, gt, gt, gt, gte, gte, gte, gte, identity, identity, ifCond, ifCond, ifCond, invertPermutation, invertPermutation, isNumericTensor, isNumericTensor, linspace, linspace, linspace, lt, lt, lt, lt, lte, lte, lte, lte, matchCondition, matchCondition, matchConditionCount, matchConditionCount, matchConditionCount, max, max, max, max, max, mean, mean, mean, mean, min, min, min, min, min, mmul, mmul, mmul, mmul, neq, neq, neq, neq, norm1, norm1, norm2, norm2, normmax, normmax, oneHot, oneHot, oneHot, oneHot, oneHot, oneHot, onesLike, onesLike, onesLike, parallel_stack, parallel_stack, permute, permute, permute, prod, prod, prod, range, range, range, rank, rank, repeat, repeat, replaceWhere, replaceWhere, replaceWhere, replaceWhere, reshape, reshape, reshape, reshape, reshape, reshape, reverse, reverse, reverseSequence, reverseSequence, reverseSequence, reverseSequence, scalarFloorMod, scalarFloorMod, scalarMax, scalarMax, scalarMin, scalarMin, scalarSet, scalarSet, scatterAdd, scatterAdd, scatterDiv, scatterDiv, scatterMax, scatterMax, scatterMin, scatterMin, scatterMul, scatterMul, scatterSub, scatterSub, scatterUpdate, scatterUpdate, segmentMax, segmentMax, segmentMean, segmentMean, segmentMin, segmentMin, segmentProd, segmentProd, segmentSum, segmentSum, sequenceMask, sequenceMask, sequenceMask, sequenceMask, sequenceMask, sequenceMask, shape, shape, size, size, sizeAt, sizeAt, slice, slice, slice, slice, squaredNorm, squaredNorm, squaredNorm, squaredNorm, squeeze, squeeze, stack, stack, standardDeviation, standardDeviation, standardDeviation, stridedSlice, stridedSlice, stridedSlice, stridedSlice, stridedSlice, stridedSlice, stridedSlice, stridedSlice, sum, sum, sum, sum, tensorMmul, tensorMmul, tile, tile, tile, tile, transpose, transpose, unsortedSegmentMax, unsortedSegmentMax, unsortedSegmentMean, unsortedSegmentMean, unsortedSegmentMin, unsortedSegmentMin, unsortedSegmentProd, unsortedSegmentProd, unsortedSegmentSqrtN, unsortedSegmentSqrtN, unsortedSegmentSum, unsortedSegmentSum, unstack, unstack, unstack, unstack, variance, variance, variance, whileLoop, whileLoop, whileLoop, zerosLike, zerosLike

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

- Field Detail
  - GRAD_FN_KEY
```
protected static final String GRAD_FN_KEY
```
    See Also:
    
    Constant Field Values
  - math
```
public final SDMath math
```
    Op creator object for math operations
  - random
```
public final SDRandom random
```
    Op creator object for random number generation operations
  - nn
```
public final SDNN nn
```
    Op creator object for general neural network operations
  - cnn
```
public final SDCNN cnn
```
    Op creator object for convolutional neural network operations
  - rnn
```
public final SDRNN rnn
```
    Op creator object for recurrent neural network operations
  - loss
```
public final SDLoss loss
```
    Op creator object for loss function operations
  - image
```
public final SDImage image
```
    Op creator object for image operations
  - bitwise
```
public final SDBitwise bitwise
```
    Op creator object for bitwise operations
- Method Detail
  - math
```
public SDMath math()
```
    Op creator object for math operations
  - random
```
public SDRandom random()
```
    Op creator object for random number generation operations
  - nn
```
public SDNN nn()
```
    Op creator object for general neural network operations
  - cnn
```
public SDCNN cnn()
```
    Op creator object for convolutional neural network operations
  - rnn
```
public SDRNN rnn()
```
    Op creator object for recurrent neural network operations
  - loss
```
public SDLoss loss()
```
    Op creator object for loss function operations
  - image
```
public SDImage image()
```
    Op creator object for image operations
  - bitwise
```
public SDBitwise bitwise()
```
    Op creator object for bitwise operations
  - updateVariableName
```
public void updateVariableName(String varName,
                               String withName)
```
    Update the opName for the variable with the given vertex id
    
    Parameters:
    
    varName - the vertex id to update
    
    withName - thew new opName
  - disableDebugging
```
public SameDiff disableDebugging()
```
    Clears debugging state and disables debug mode.
  - enableDebugMode
```
public SameDiff enableDebugMode()
```
    Enables tracing of graphs automatically.
  - f
```
public DifferentialFunctionFactory f()
```
    Returns this samediff instance's DifferentialFunctionFactory
    
    Specified by:
    
    f in class SDBaseOps
    
    Returns:
    
    DifferentialFunctionFactory
  - setListeners
```
public void setListeners(Listener... listeners)
```
    Set the current SameDiff-wide Listener instances. Note that this will overwrite the current listener list. If you want to use additional listeners for a single operation, use the listener arguments in those methods (e.g. fit() and FitConfig.listeners(Listener...)).
    
    Parameters:
    
    listeners - Listeners
  - setListeners
```
public void setListeners(Collection<? extends Listener> listeners)
```
    See setListeners(Listener...).
  - addListeners
```
public void addListeners(Listener... listeners)
```
    Add SameDiff-wide Listener instances. If you want to use additional listeners for a single operation, use the listener arguments in those methods (e.g. fit() and FitConfig.listeners(Listener...)).
    
    Parameters:
    
    listeners - Listeners
  - addListeners
```
public void addListeners(Collection<? extends Listener> listeners)
```
    See addListeners(Listener...).
  - getListeners
```
public List<Listener> getListeners()
```
    Gets the current SameDiff-wide listeners.
  - currentNameScope
```
public String currentNameScope()
```
    Returns:
    
    The current name scope, if any (null otherwise). See withNameScope(String) for more details.
  - nameWithScope
```
protected String nameWithScope(String name)
```
    Returns:
    
    The name with the current name scope (if any) appended. See withNameScope(String)
  - withNameScope
```
public NameScope withNameScope(String nameScope)
```
    Create a name scope. Name scopes append a prefix to the names of any variables and ops created while they are open.
```
  
  SameDiff sd = SameDiff.create();
  SDVariable x = sd.var("x", DataType.FLOAT, 5);
  SDVariable y;
  try(NameScope ns = sd.withNameScope("myScope"){
      y = sd.var("y", DataType.FLOAT, 5);
  }
  SDVariable z = sd.var("z", DataType.FLOAT, 5);

  String xName = x.getVarName();      //RESULT: "x"
  String yName = y.getVarName();      //RESULT: "myScope/y"
  String zName = z.getVarName();      //RESULT: "z"
  
 
```
    Note that name scopes can also be nested:
```
  
  SameDiff sd = SameDiff.create();
  SDVariable x;
  try(NameScope ns = sd.withNameScope("first"){
      try(NameScope ns2 = sd.withNameScope("second"){
          x = sd.var("x", DataType.FLOAT, 5);
      }
  }
  String xName = x.getVarName();      //RESULT: "first/second/x"
  
 
```
    Parameters:
    
    nameScope - Name of the name scope to open/create
    
    Returns:
    
    The NameScope object
  - getOpsInScope
```
public List<SameDiffOp> getOpsInScope(NameScope scope)
```
    Gets all operations in a given name scope.
  - getOpsInScope
```
public List<SameDiffOp> getOpsInScope(String scope)
```
    See getOpsInScope(NameScope).
  - getVariablesInScope
```
public List<SDVariable> getVariablesInScope(NameScope scope)
```
    Gets all variables in a given name scope.
  - getVariablesInScope
```
public List<SDVariable> getVariablesInScope(String scope)
```
    See getVariablesInScope(NameScope).
  - invokeGraphOn
```
public SDVariable invokeGraphOn(SameDiff sameDiff)
```
    Parameters:
    
    sameDiff -
    
    Returns:
  - opExists
```
public boolean opExists(String id)
```
    Returns true if the given function id exists
    
    Parameters:
    
    id - the function id to test for
    
    Returns:
    
    true if the function id exists, false otherwise
  - getVariableOutputOp
```
public DifferentialFunction getVariableOutputOp(String variableName)
```
    Get the differential function (if any) that this variable is the output for
    
    Parameters:
    
    variableName - Name of the variable
    
    Returns:
    
    The differential function that this variable is an output of, or null if it is not the output of a function
  - getOpById
```
public DifferentialFunction getOpById(@NonNull
                                      String id)
```
    Get the function by the DifferentialFunction#getOwnName()
    
    Parameters:
    
    id - the id of the function
    
    Returns:
    
    the function for the given id if it exists
  - putOpForId
```
public void putOpForId(String id,
                       DifferentialFunction function)
```
    Put the function for the given id
    
    Parameters:
    
    id - the id of the function
    
    function - the function
  - getInputsForOp
```
public String[] getInputsForOp(DifferentialFunction function)
```
    Returns the name(s) of the inputs for the given function
    
    Parameters:
    
    function - the function to get the inputs for
    
    Returns:
    
    the input ids for a given function
  - getOutputsForOp
```
public String[] getOutputsForOp(DifferentialFunction function)
```
    Returns the name(s) of the outputs for the given function
    
    Parameters:
    
    function - the function to get the outputs for
    
    Returns:
    
    the outputs ids for a given function
  - getOutputVariablesForOp
```
public SDVariable[] getOutputVariablesForOp(DifferentialFunction function)
```
    Get the output variable(s) for the specified differential function
    
    Parameters:
    
    function - the function reference to get the output variable(s) for
    
    Returns:
    
    the output variables for the given function
  - getInputVariablesForOp
```
public SDVariable[] getInputVariablesForOp(DifferentialFunction function)
```
    Get the input variable(s) for the specified differential function
    
    Parameters:
    
    function - the function reference to get the input variable(s) for
    
    Returns:
    
    the input variables for the given function
  - setArrayForVariable
```
public void setArrayForVariable(@NonNull
                                String varName,
                                @NonNull
                                INDArray arr)
```
    Set the stored INDArray for a variable. Only works if the variable is of type VariableType.CONSTANT, VariableType.PLACEHOLDER, or VariableType.VARIABLE.
  - getShapeForVarName
```
public long[] getShapeForVarName(String varName)
```
    Get the shape for the given vertex id. Note that if an array is defined, it will use the shape of the array instead.
    A shape *and* an array should not be defined at the same time. This wastes memory. The internal map used for tracking shapes for particular vertex ids should also delete redundant shapes stored to avoid redundant sources of information.
    
    Parameters:
    
    varName - the vertex id to get the shape for
    
    Returns:
    
    the shape for the given vertex if any.
  - getShapeDescriptorForVarName
```
public LongShapeDescriptor getShapeDescriptorForVarName(String varName)
```
    See getShapeForVarName(String), but returns the shape descriptor.
  - putShapeForVarName
```
@Deprecated
public void putShapeForVarName(String varName,
                                            long[] shape)
```
    Deprecated.
    
    Associate a vertex id with the given shape.
    
    Parameters:
    
    varName - the vertex id to associate
    
    shape - the shape to associate with
    
    See Also:
    
    putShapeForVarName(String, long[]), putOrUpdateShapeForVarName(String, long[], boolean)
  - putShapeForVarName
```
public void putShapeForVarName(String varName,
                               LongShapeDescriptor shape)
```
    Sets the shape descriptor for a variable.
  - putOrUpdateShapeForVarName
```
@Deprecated
public void putOrUpdateShapeForVarName(String varName,
                                                    long[] shape,
                                                    boolean clearArrayOnShapeMismatch)
```
    Deprecated.
    
    Put or update the shape for the given variable name. Optionally supports clearing the specified variable's INDArray if it's shape does not match the new shape
    
    Parameters:
    
    varName - Variable name
    
    shape - Shape to put
    
    clearArrayOnShapeMismatch - If false: no change to arrays. If true: if an INDArray is defined for the specified variable name, it will be removed from the graph (to be later re-generated) if its shape does not match the specified shape
  - shapeAlreadyExistsForVarName
```
public boolean shapeAlreadyExistsForVarName(String varName)
```
    Returns true if the given vertex id and shape already exist.
    
    Parameters:
    
    varName - the vertex id
    
    Returns:
    
    true if the ndarray and vertex id already exist
  - arrayAlreadyExistsForVarName
```
public boolean arrayAlreadyExistsForVarName(String varName)
```
    Returns true if the given vertex id and INDArray already exist.
    
    Parameters:
    
    varName - the vertex id
    
    Returns:
    
    true if a vertex with the given INDArray exists, and it has an INDArray associated with it
  - getArrForVarName
```
public INDArray getArrForVarName(@NonNull
                                 String varName)
```
    Get an INDArray for a given vertex id, or null if none exists
    
    Parameters:
    
    varName - Variable name to get the array for
    
    Returns:
    
    Array, or null if none exists
  - associateArrayWithVariable
```
public void associateArrayWithVariable(INDArray arr,
                                       @NonNull
                                       String variable)
```
    Associate the array with the given variable.
    
    Parameters:
    
    arr - the array to get the variable for
    
    variable - the name of the variable to associate the array with
  - associateArrayWithVariable
```
public void associateArrayWithVariable(INDArray arr,
                                       SDVariable variable)
```
    Associate the array with the given variable.
    
    Parameters:
    
    arr - the array to get the variable for
    
    variable - the variable to associate the array with
  - assignArray
```
public void assignArray(@NonNull
                        INDArray arr,
                        @NonNull
                        SDVariable variable)
```
    Update the constant or variable type SDVariable with the values from the specified array. Note that unlike associateArrayWithVariable(INDArray, String) this method will take the values from the argument array and assign it to the current array. The actual array (INDArray object) will not be stored or otherwise used within the SameDiff instance.
    
    Parameters:
    
    arr - Array values to set
    
    variable - Variable to update the array of. Must be CONSTANT or VARIBLE type SDVariable
  - putSubFunction
```
public void putSubFunction(String name,
                           SameDiff nameSpace)
```
    Associate a SameDiff namespace as a sub function.
    
    Parameters:
    
    name - the opName of the function
    
    nameSpace - the namespace
  - variableMap
```
public Map<String,SDVariable> variableMap()
```
    Return a copy of the internal variable map
    
    Returns:
    
    Map of variables by name
  - invoke
```
@Deprecated
public SDVariable invoke(Op op,
                                      SDVariable x,
                                      SDVariable y)
```
    Deprecated.
    
    Invoke an op by opName
    
    Parameters:
    
    op - the op
    
    x - the first input
    
    y - the second input
    
    Returns:
    
    the result variable
  - definedFunctionNames
```
public Collection<String> definedFunctionNames()
```
    The set of defined SameDiff function names. SameDiff function instances should not be confused with DifferentialFunction ops; an example of a SameDiff function instance is the gradient "grad" function
    
    Returns:
    
    Set of defined SameDiff function instance names
  - invoke
```
public SDVariable invoke(Op op,
                         SDVariable x)
```
    Invoke an op by opName
    
    Parameters:
    
    op - the op
    
    x - the first input
    
    Returns:
    
    the result variable
  - addPropertyToResolve
```
public void addPropertyToResolve(DifferentialFunction forFunction,
                                 String arrayName)
```
    Adds a property that needs to be resolve for later. These variables are typically values that are arrays that are named but have an unknown value till execution time.
    This is very common for model import.
    
    Parameters:
    
    forFunction - the function to add the property to resolve for
    
    arrayName - the array name
  - removePropertyToResolve
```
public void removePropertyToResolve(DifferentialFunction forFunction,
                                    String arrayName)
```
    Remove a property to resolve added with addPropertyToResolve(DifferentialFunction, String)
    
    Parameters:
    
    forFunction - the function to add the property to resolve for
    
    arrayName - the array name
  - propertiesToResolveForFunction
```
public List<String> propertiesToResolveForFunction(DifferentialFunction function)
```
    Return the properties to resolve for the given function. This is typically used right before execution in model import in DifferentialFunction.resolvePropertiesFromSameDiffBeforeExecution()
    
    Parameters:
    
    function - the function get the properties to resolve for
    
    Returns:
    
    the properties to resolve for the given function
  - addVariableMappingForField
```
public void addVariableMappingForField(DifferentialFunction function,
                                       String fieldName,
                                       String varName)
```
    Adds a field name -> variable name mapping for a given function.
    This is used for model import where there is an unresolved variable at the time of calling any GraphMapper.importGraph(File) .
    This data structure is typically accessed during DifferentialFunction.resolvePropertiesFromSameDiffBeforeExecution()
    When a function attempts to resolve variables right before execution, there needs to be a way of knowing which variable in a samediff graph should map to a function's particular field name
    
    Parameters:
    
    function - the function to map
    
    fieldName - the field name for the function to map
    
    varName - the variable name of the array to get from samediff
  - getVarNameForFieldAndFunction
```
public String getVarNameForFieldAndFunction(DifferentialFunction function,
                                            String fieldName)
```
    Get the variable name to use for resolving a given field for a given function during import time. This method is u sed during DifferentialFunction.resolvePropertiesFromSameDiffBeforeExecution()
    
    Parameters:
    
    function - the function to get the variable name for
    
    fieldName - the field name to resolve for
    
    Returns:
    
    the resolve variable name if any
  - setBaseNameForFunctionInstanceId
```
public void setBaseNameForFunctionInstanceId(String baseName,
                                             DifferentialFunction function)
```
    Sets a base name for the function id. This is used for when calling #generateOutputVariableForOp(DifferentialFunction, String) for ensuring original names for model import map to current samediff names when names are generated.
    
    Parameters:
    
    baseName - the base name to add
    
    function - the function to declare a base name for.
  - getBaseNameForFunction
```
public String getBaseNameForFunction(DifferentialFunction function)
```
    Returns the base name for the given function if any (may return null)
    
    Parameters:
    
    function - the function to get the base name for
    
    Returns:
    
    the base name for the given function (if any) based on the function's instance id.
  - setupFunction
```
public <X extends SDVariable> X setupFunction(X function)
```
    Attempts to insert the DifferentialFunction reference in to this SameDiff instance. If the given array field with the given index already exists, it will do a reference check to ensure that the 2 array fields are the same. If not, an exception is thrown.
    If the instances are the same (by semantics, not reference) then it will just return the original instance. This is to ensure that instances that are created are unique and reference checked.
    
    Parameters:
    
    function - the array field to attempt to create
    
    Returns:
    
    Original instance
  - addOutgoingFor
```
public void addOutgoingFor(SDVariable[] variables,
                           DifferentialFunction function)
```
    Adds outgoing arguments to the graph for the specified DifferentialFunction Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
    
    Parameters:
    
    variables - Variables - arguments for the specified differential function
    
    function - Differential function
  - addOutgoingFor
```
public void addOutgoingFor(String[] varNames,
                           DifferentialFunction function)
```
    Adds outgoing arguments to the graph for the specified DifferentialFunction Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
    
    Parameters:
    
    varNames - Name of the variables that are outputs of the specified differential function
    
    function - Differential function
  - addArgumentInterceptor
```
public void addArgumentInterceptor(@NonNull
                                   ArgumentInterceptor interceptor)
```
    Add a new argument interceptor to the interceptor stack
    For internal use only.
    When a op is added with arguments, most recent argument interceptor is called on it. If ops are added in that interceptor, the next most recent will be called on their args, and so on.
    
    Parameters:
    
    interceptor - the argument interceptor to add
  - removeArgumentInterceptor
```
public void removeArgumentInterceptor()
```
    Remote the top (most recently added) argument interceptor
    For internal use only.
  - pauseArgumentInterceptor
```
public void pauseArgumentInterceptor()
```
    Pause the top (most recently added) argument interceptor
    For internal use only.
  - pauseArgumentInterceptor
```
public void pauseArgumentInterceptor(@NonNull
                                     ArgumentInterceptor interceptor)
```
    Pause the given argument interceptor
    For internal use only.
    
    Parameters:
    
    interceptor - the argument interceptor to pause
  - unpauseArgumentInterceptor
```
public void unpauseArgumentInterceptor()
```
    Unpause the top (most recently added) argument interceptor
    For internal use only.
  - unpauseArgumentInterceptor
```
public void unpauseArgumentInterceptor(@NonNull
                                       ArgumentInterceptor interceptor)
```
    Unpause the top given argument interceptor
    For internal use only.
    
    Parameters:
    
    interceptor - the argument interceptor to unpause
  - addArgsFor
```
public void addArgsFor(String[] variables,
                       DifferentialFunction function)
```
    Adds incoming arguments for the specified differential function to the graph
    
    Parameters:
    
    variables - Name of the variables that are arguments (inputs) to the specified function
    
    function - Function
  - addArgsFor
```
public void addArgsFor(SDVariable[] variables,
                       DifferentialFunction function)
```
    Adds incoming arguments for the specified differential function to the graph
    
    Parameters:
    
    variables - variables that are arguments (inputs) to the specified function
    
    function - Function
  - replaceArgFor
```
public void replaceArgFor(int i,
                          @NonNull
                          SDVariable newArg,
                          @NonNull
                          DifferentialFunction function)
```
    Replaces the argument at i with newArg for function Does not use (or remove) ArgumentInterceptor stuff
  - hasArgs
```
public boolean hasArgs(DifferentialFunction function)
```
    Returns true if this function already has defined arguments
    
    Parameters:
    
    function - the function to check
    
    Returns:
    
    true if the function has args, false otherwise
  - clearPlaceholders
```
public void clearPlaceholders(boolean allThreads)
```
    Clear the placeholder arrays from the SameDiff instance
    
    Parameters:
    
    allThreads - If true: clear the placeholders for all threads. False: clear only for current thread
  - clearOpInputs
```
public void clearOpInputs()
```
    Clear the input arrays to each op. This is usually not required, under normal SameDiff use
  - ops
```
public DifferentialFunction[] ops()
```
    Get an array of differential functions that have been defined for this SameDiff instance
    
    Returns:
    
    Array of differential functions
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - create
```
public static SameDiff create(SameDiff originalSameDiff)
```
    Create a new SameDiff instance from an existing instance. Note that state (variables and functions) is shared between the two SameDiff instance
    
    Parameters:
    
    originalSameDiff - Original SameDiff instance
    
    Returns:
    
    Copy
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - create
```
public static SameDiff create()
```
    Create a new (empty) SameDiff instance without any functions or variables
    
    Returns:
    
    New SameDiff instance
  - dup
```
public SameDiff dup()
```
    Clone/duplicate the SameDiff instance, including arrays etc. The returned SameDiff instance should have no shared state with the original instance
    
    Returns:
    
    The cloned SameDiff instance
  - numElements
```
public long numElements()
```
    Count the number of elements in all arrays, according to SDVariable.getShape()
    
    Returns:
    
    Number of array elements for all variables
  - inputs
```
public List<String> inputs()
```
    Returns the inputs (placeholders) for the SameDiff graph
    
    Returns:
    
    the inputs for this graph
  - outputs
```
public List<String> outputs()
```
    Outputs are those variables (not placeholders, constants, etc) that are the output of a function that aren't the input to any other ops. Usually these are the output of the last function(s) in the SameDiff instance.
    
    Returns:
    
    The (inferred) outputs of the SameDiff instance, in no particular order
  - variables
```
public List<SDVariable> variables()
```
    The list of all variables in the graph
    
    Returns:
    
    All variables in the graph
  - getLossVariables
```
public List<String> getLossVariables()
```
    Get the names of variables (if any) that have been marked as loss variables to be minimized.
    Variables can be marked as loss variables in a few different ways:
    (a) Losses are automatically added when creating loss functions via sd()
    (b) Via setLossVariables(String...), @link #addLossVariable(String)} or SDVariable.markAsLoss()
    (c) Via TrainingConfig#setLossVariables(List)
  - setLossVariables
```
public void setLossVariables(@NonNull
                             String... lossVariableNames)
```
    Clear/remove any existing loss variables, and set the loss variables to the specified variable names.
    See addLossVariable(String) for more details
    
    Parameters:
    
    lossVariableNames - Names of variables to be loss function variables
  - setLossVariables
```
public void setLossVariables(@NonNull
                             SDVariable... lossVariables)
```
    See setLossVariables(String...)
  - addLossVariable
```
public void addLossVariable(@NonNull
                            String variableName)
```
    Mark the specified variable as a loss function variable. This means that this variable will be minimized via backprop during training.
    This will add the variable as a loss to any others - i.e., if multiple variables are marked as losses, their values will be summed to give the total network loss.
    Note that only floating point (Float16/32/64) variables may be marked as a loss.
    Note also that only ARRAY type SDVariables can be marked as losses to be minimized. That is, we cannot mark the value of a constant, variable or placeholder to be minimized as doing so would not make sense.
  - addLossVariable
```
public void addLossVariable(@NonNull
                            SDVariable variable)
```
    See addLossVariable(String)
  - setTrainingConfig
```
public void setTrainingConfig(TrainingConfig trainingConfig)
```
    Set the training configuration (TrainingConfig) for the SameDiff instance. A TrainingConfig must be set before the SameDiff instance can be trained via the fit methods
    
    Parameters:
    
    trainingConfig - Training configuration
  - fit
```
public History fit(@NonNull
                   DataSet dataSet,
                   @NonNull
                   Listener... listeners)
```
    Fit the SameDiff instance based on a single DataSet (i.e., a single minibatch for one iteration).
    This method can only be used for singe input, single output SameDiff instances as DataSet only supports a single input and a single output.
    Note that a TrainingConfig must be set via setTrainingConfig(TrainingConfig) before training can be performed.
    
    Parameters:
    
    dataSet - The DataSet (single minibatch) to peform training on
    
    listeners - Additional listeners to use during this operation
    
    Returns:
    
    a History object containing the history information for this training operation (evaluations specified in the TrainingConfig, loss values, and timing information).
  - fit
```
public History fit(@NonNull
                   MultiDataSet dataSet,
                   @NonNull
                   Listener... listeners)
```
    Fit the SameDiff instance based on a single MultiDataSet (i.e., a single minibatch for one iteration).
    Note that a TrainingConfig must be set via setTrainingConfig(TrainingConfig) before training can be performed.
    
    Parameters:
    
    dataSet - The MultiDataSet (single minibatch) to peform training on
    
    listeners - Additional listeners to use during this operation
    
    Returns:
    
    a History object containing the history information for this training operation (evaluations specified in the TrainingConfig, loss values, and timing information).
  - fit
```
public History fit(@NonNull
                   DataSetIterator iter,
                   int numEpochs,
                   DataSetIterator validationIter,
                   int validationFrequency,
                   @NonNull
                   Listener... listeners)
```
    Fit the SameDiff instance based on DataSetIterator for the specified number of epochs.
    This method can only be used for singe input, single output SameDiff instances as DataSet only supports a single input and a single output.
    Note that a TrainingConfig must be set via setTrainingConfig(TrainingConfig) before training can be performed.
    A special case of fit().
    
    Parameters:
    
    iter - The iterator to train the SameDiff instance with
    
    numEpochs - The number of epochs for training. Must be > 0
    
    validationIter - The DataSetIterator to use for validation (null to skip validation)
    
    validationFrequency - The frequency with which to run validation. 1 is every epoch, 2 is every other, etc.
    
    listeners - Additional listeners to use during this operation
    
    Returns:
    
    a History object containing the history information for this training operation (evaluations specified in the TrainingConfig, loss values, and timing information).
  - fit
```
public History fit(@NonNull
                   DataSetIterator iter,
                   int numEpochs,
                   @NonNull
                   Listener... listeners)
```
    See fit(DataSetIterator, int, DataSetIterator, int, Listener...), does not preform validation.
    A special case of fit().
    
    Parameters:
    
    iter - The iterator to train the SameDiff instance with
    
    numEpochs - The number of epochs for training. Must be > 0
    
    listeners - Additional listeners to use during this operation
    
    Returns:
    
    a History object containing the history information for this training operation (evaluations specified in the TrainingConfig, loss values, and timing information).
  - fit
```
public History fit(@NonNull
                   MultiDataSetIterator iter,
                   int numEpochs,
                   MultiDataSetIterator validationIter,
                   int validationFrequency,
                   @NonNull
                   Listener... listeners)
```
    Fit the SameDiff instance based on MultiDataSetIterator for the specified number of epochs.
    This method can both singe input, single output and multi-input, multi-output SameDiff instances
    Note that a TrainingConfig must be set via setTrainingConfig(TrainingConfig) before training can be performed.
    A special case of fit().
    
    Parameters:
    
    iter - The iterator to train the SameDiff instance with
    
    numEpochs - The number of epochs for training. Must be > 0
    
    validationIter - The MultiDataSetIterator to use for validation (null to skip validation)
    
    validationFrequency - The frequency with which to run validation. 1 is every epoch, 2 is every other, etc.
    
    listeners - Additional listeners to use during this operation
    
    Returns:
    
    a History object containing the history information for this training operation (evaluations specified in the TrainingConfig, loss values, and timing information).
  - fit
```
public History fit(@NonNull
                   MultiDataSetIterator iter,
                   int numEpochs,
                   @NonNull
                   Listener... listeners)
```
    See fit(MultiDataSetIterator, int, MultiDataSetIterator, int, Listener...), does not preform validation.
    A special case of fit().
    
    Parameters:
    
    iter - The iterator to train the SameDiff instance with
    
    numEpochs - The number of epochs for training. Must be > 0
    
    listeners - Additional listeners to use during this operation
    
    Returns:
    
    a History object containing the history information for this training operation (evaluations specified in the TrainingConfig, loss values, and timing information).
  - fit
```
public FitConfig fit()
```
    Set up for a fit operation using FitConfig.
    Supports the setting of training data (MultiDataSetIterator or DataSetIterator), number of epochs, validation data (MultiDataSetIterator or DataSetIterator), validation frequency, and additional listeners.
    
    Example: train on data for 5 epochs, validating on valData every 2nd epoch
```
     
     SameDiff sd = ...;
     MultiDataSet data = ...;
     MultiDataSet valData = ...;

     History hist = sd.fit()
         .train(data, 5)
         .validate(valData, 2)
         .exec();
     
 
```
  - fit
```
protected History fit(@NonNull
                      MultiDataSetIterator iter,
                      int numEpochs,
                      boolean incrementEpochCount,
                      MultiDataSetIterator validationData,
                      int validationFrequency,
                      @NonNull
                      Listener... listeners)
```
  - fitHelper
```
protected History fitHelper(@NonNull
                            MultiDataSetIterator iter,
                            int numEpochs,
                            boolean incrementEpochCount,
                            MultiDataSetIterator validationData,
                            int validationFrequency,
                            @NonNull
                            List<Listener> listeners)
```
  - calcRegularizationScore
```
public double calcRegularizationScore()
```
    Calculate the regularization (L1, L2 and/or WeightDecay) component of the loss function for the current parameters.. Note that the training configuration must be set (via setTrainingConfig(TrainingConfig)) before this method can be called
    
    Returns:
    
    The regularization component of the score/loss function
  - initializeTraining
```
protected void initializeTraining()
```
    Perform setup for training. Does the following: 1. Infer the set of trainable parameters - unless specified manually by the user 2. Set up the updaters
  - evaluate
```
public void evaluate(@NonNull
                     DataSetIterator iterator,
                     @NonNull
                     String outputVariable,
                     @NonNull
                     List<Listener> listeners,
                     @NonNull
                     IEvaluation... evaluations)
```
    Evaluate the performance of a single variable's prediction.
    For example, if the variable to evaluatate was called "softmax" you would use:
```
  Evaluation e = new Evaluation();
 sameDiff.evaluate(iterator, "softmax", e);
 
```
    A special case of evaluate().
    Parameters:
    
    iterator - Iterator as source of data to evaluate
    
    outputVariable - The variable to evaluate
    
    listeners - Additional listeners to use during this operation.
    
    evaluations - The evaluations to perform
  - evaluate
```
public void evaluate(@NonNull
                     DataSetIterator iterator,
                     @NonNull
                     String outputVariable,
                     @NonNull
                     IEvaluation... evaluations)
```
    See evaluate(DataSetIterator, String, List, IEvaluation[]).
    A special case of evaluate().
  - evaluate
```
public void evaluate(@NonNull
                     DataSetIterator iterator,
                     @NonNull
                     Map<String,IEvaluation> variableEvals,
                     @NonNull
                     Listener... listeners)
```
    Evaluation for multiple-output networks.
    See evaluate(MultiDataSetIterator, Map, Map, Listener[]).
    A special case of evaluate().
  - evaluateMultiple
```
public void evaluateMultiple(DataSetIterator iterator,
                             Map<String,List<IEvaluation>> variableEvals,
                             @NonNull
                             Listener... listeners)
```
    Evaluation for multiple output networks - one or more. See evaluate(MultiDataSetIterator, Map, Map, Listener[]).
    A special case of evaluate().
  - evaluate
```
public void evaluate(@NonNull
                     MultiDataSetIterator iterator,
                     @NonNull
                     String outputVariable,
                     int labelIndex,
                     @NonNull
                     List<Listener> listeners,
                     @NonNull
                     IEvaluation... evaluations)
```
    Evaluate the performance of a single variable's prediction.
    For example, if the variable to evaluatate was called "softmax" you would use:
```
  Evaluation e = new Evaluation();
 sameDiff.evaluate(iterator, "softmax", e);
 
```
    A special case of evaluate().
    Parameters:
    
    iterator - Iterator as source of data to evaluate
    
    outputVariable - The variable to evaluate
    
    labelIndex - The index of the target variable's labels in the iterator
    
    listeners - Additional listeners to use during this operation.
    
    evaluations - The evaluations to perform
  - evaluate
```
public void evaluate(@NonNull
                     MultiDataSetIterator iterator,
                     @NonNull
                     String outputVariable,
                     int labelIndex,
                     @NonNull
                     IEvaluation... evaluations)
```
    See evaluate(MultiDataSetIterator, String, int, List, IEvaluation[]).
    A special case of evaluate().
  - evaluate
```
public void evaluate(MultiDataSetIterator iterator,
                     Map<String,List<IEvaluation>> variableEvals,
                     Map<String,Integer> predictionLabelMapping,
                     Listener... listeners)
```
    Perform evaluation using classes such as Evaluation for classifier outputs and RegressionEvaluation for regression outputs.
    
    Example: classifier evaluation
    Predictions variable name: "softmaxOutput"
    Evaluations to perform: Evaluation
    Data: single input, single output MultiDataSets
    Code:
```
 
 MultiDataSetIterator data = ...
 Map<String,List<IEvaluation>> evals = Collections.singletonMap("softmaxOutput",Collections.singletonList(new Evaluation()));
 Map<String,Integer> labelMapping = Collections.singletonMap("softmaxOutput",0);  //Compare: "softmaxOutput" vs. MultiDataSet.getLabels(0)
 
 
```
    A special case of evaluate().
    Parameters:
    
    iterator - The iterator - the source of the data for evaluation
    
    variableEvals - The evaluations to perform. Key: the name of the variable. Value: the evaluations to perform
    
    predictionLabelMapping - The output/label mapping. Key: the name of the variable.
    
    listeners - Additional listeners to use during this operation.
  - evaluate
```
public EvaluationConfig evaluate()
```
    Set up for a evaluation operation using EvaluationConfig.
    Supports the setting of the data (MultiDataSetIterator or DataSetIterator), adding evaluations for variables (with optional label index setting), setting label indices, and setting additional listeners. Does not require setting label indices when using a DataSetIterator.
    Also supports using SDVariable instances instead of variable names.
    
    Example: evaluate "pred" with Evaluation and ROC, using label 0.
```
      
     SameDiff sd = ...;
     MultiDataSetIterator data = ...;

     EvaluationRecord results = sd.evaluate()
         .data(data)
         .evaluate("pred", 0, new Evaluation(), new ROC()),
         .exec();
      
  
```
    Example: evaluate "pred" with Evaluation, using the only label from a DataSetIterator.
```
      
     SameDiff sd = ...;
     DataSetIterator singleData = ...;

     EvaluationRecord results = sd.evaluate()
         .data(singleData)
         .evaluate("pred", new Evaluation()),
         .exec();
      
  
```
  - output
```
public Map<String,INDArray> output(@NonNull
                                   DataSet dataSet,
                                   @NonNull
                                   String... outputs)
```
    Do a single batch inference on a network with a single input.
    For example, if the variable to infer was called "softmax" you would use:
```
 
 sameDiff.output(iterator, "softmax");
 
```
    Parameters:
    
    dataSet - The data to evaluate
    
    outputs - The variables to evaluate
  - output
```
public Map<String,INDArray> output(@NonNull
                                   MultiDataSet dataSet,
                                   @NonNull
                                   String... outputs)
```
    Do a single batch inference on a network.
    For example, if the variable to infer was called "softmax" you would use:
```
 
 sameDiff.output(iterator, "softmax");
 
```
    Parameters:
    
    dataSet - The data to evaluate
    
    outputs - The variables to evaluate
  - output
```
public Map<String,INDArray> output(@NonNull
                                   DataSetIterator iterator,
                                   @NonNull
                                   List<Listener> listeners,
                                   @NonNull
                                   String... outputs)
```
    Do inference on a network with a single input.
    For example, if the variable to infer was called "softmax" you would use:
```
 
 sameDiff.output(iterator, "softmax");
 
```
    Uses concatenation on the outputs of outputBatches(DataSetIterator, String...) which may cause issues with some inputs. RNNs with variable time series length and CNNs with variable image sizes will most likely have issues.
    Special case of output().
    Parameters:
    
    iterator - Iterator as source of data to evaluate
    
    listeners - Additional listeners to use during this operation.
    
    outputs - The variables to evaluate
  - output
```
public Map<String,INDArray> output(@NonNull
                                   DataSetIterator dataSet,
                                   @NonNull
                                   String... outputs)
```
    See output(DataSetIterator, List, String...). No additional listeners.
    Special case of output().
  - outputBatches
```
public List<Map<String,INDArray>> outputBatches(DataSetIterator iterator,
                                                List<Listener> listeners,
                                                String... outputs)
```
    See output(DataSetIterator, List, String...), but without the concatenation of batches.
    Special case of output().
  - outputBatches
```
public List<Map<String,INDArray>> outputBatches(DataSetIterator iterator,
                                                String... outputs)
```
    See output(DataSetIterator, String...), but without the concatenation of batches.
    Special case of output().
  - output
```
public Map<String,INDArray> output(@NonNull
                                   MultiDataSetIterator iterator,
                                   @NonNull
                                   List<Listener> listeners,
                                   @NonNull
                                   String... outputs)
```
    Perform inference.
    
    Example: classifier inference
    Predictions variable name: "softmaxOutput"
    Evaluations to perform: Evaluation
    Data: single output MultiDataSets
    Code:
```
 
 MultiDataSetIterator data = ...
 sameDiff.output(iterator, "softmaxOutput);
 
 
```
    Special case of output().
    Parameters:
    
    iterator - The iterator - the source of the data for inference
    
    listeners - Additional listeners to use during this operation.
    
    outputs - The set of outputs to report. If null, defaults to all outputs of this SameDiff.
  - output
```
public Map<String,INDArray> output(@NonNull
                                   MultiDataSetIterator dataSet,
                                   @NonNull
                                   String... outputs)
```
    See output(MultiDataSetIterator, List, String...). No additional listeners.
    Special case of output().
  - outputBatches
```
public List<Map<String,INDArray>> outputBatches(MultiDataSetIterator iterator,
                                                List<Listener> listeners,
                                                String... outputs)
```
    Perform inference.
    
    Example: classifier inference
    Predictions variable name: "softmaxOutput"
    Evaluations to perform: Evaluation
    Data: single output MultiDataSets
    Code:
```
 
 MultiDataSetIterator data = ...
 sameDiff.output(iterator, "softmaxOutput);
 
 
```
    Uses concatenation on the outputs of outputBatches(MultiDataSetIterator, List, String...) which may cause issues with some inputs. RNNs with variable time series length and CNNs with variable image sizes will most likely have issues.
    Special case of output().
    Parameters:
    
    iterator - The iterator - the source of the data for inference
    
    listeners - Additional listeners to use during this operation.
    
    outputs - The set of outputs to report. If null, defaults to all outputs of this SameDiff.
  - outputBatches
```
public List<Map<String,INDArray>> outputBatches(MultiDataSetIterator iterator,
                                                String... outputs)
```
    See outputBatches(MultiDataSetIterator, List, String...). No additional listeners.
    Special case of output().
  - output
```
public OutputConfig output()
```
    Set up for an inference operation using OutputConfig. Supports the setting of variables to output, the input data (MultiDataSetIterator or DataSetIterator), and additional listeners. Has exec methods to get results in batches or concatenated, or to get results when there is only a single output (again in batches or concatenated).
    Also supports using SDVariable instances instead of variable names.
    
    Example: get the output of pred, with batches concatenated together
```
     
     SameDiff sd = ...;
     MultiDataSet data = ...;

     INDArray out = sd.output()
         .data(data)
         .output("pred")
         .execSingle();
     
 
```
  - batchOutput
```
public BatchOutputConfig batchOutput()
```
    Set up for a single batch inference operation using OutputConfig. Supports the setting of placeholder inputs, outputs, and additional listeners. Has exec methods to get the single output if only one is requested, or all requested outputs.
    Also supports using SDVariable instances instead of variable names.
    Example: get the value of "out" with placeholders x and y
```
     
     SameDiff sd = ...;
     INDArray xValue = ...;
     INDArray yValue = ...;
     SDVariable y = ...;

     INDArray outValue = sd.batchOutput()
         .output("out")
         .input("x", xValue)
         .input(y, yValue)
         .execSingle();
     
 
```
  - execAll
```
@Deprecated
public Map<String,INDArray> execAll(Map<String,INDArray> placeholders)
```
    Deprecated. See outputAll(Map) and batchOutput()
  - outputAll
```
public Map<String,INDArray> outputAll(Map<String,INDArray> placeholders)
```
    Do inference for all variables for a single batch.
    See output(Map, List, String...).
    Special case of batchOutput().
  - execSingle
```
@Deprecated
public INDArray execSingle(Map<String,INDArray> placeholders,
                                        String output)
```
    Deprecated. See outputSingle(Map, String) and batchOutput()
  - outputSingle
```
public INDArray outputSingle(Map<String,INDArray> placeholders,
                             String output)
```
    Do inference for a single variable for a single batch.
    See output(Map, List, String...).
    Special case of batchOutput().
  - exec
```
@Deprecated
public Map<String,INDArray> exec(Map<String,INDArray> placeholders,
                                              List<String> outputs)
```
    Deprecated. See output(Map, List) and batchOutput()
  - output
```
public Map<String,INDArray> output(Map<String,INDArray> placeholders,
                                   List<String> outputs)
```
    Do inference for the given variables for a single batch.
    See output(Map, List, String...).
    Special case of batchOutput().
  - exec
```
@Deprecated
public Map<String,INDArray> exec(Map<String,INDArray> placeholders,
                                              String... outputs)
```
    Deprecated. See output(Map, String...) and batchOutput()
  - output
```
public Map<String,INDArray> output(Map<String,INDArray> placeholders,
                                   String... outputs)
```
    Do inference for the given variables for a single batch.
    See output(Map, List, String...).
    Special case of batchOutput().
  - output
```
public Map<String,INDArray> output(Map<String,INDArray> placeholders,
                                   @NonNull
                                   List<Listener> listeners,
                                   String... outputs)
```
    Do inference for the given variables for a single batch.
    Special case of batchOutput().
    
    Parameters:
    
    placeholders - The values to use for placeholders.
    
    listeners - Additional listeners to use during this operation.
    
    outputs - The variables to output and return.
  - batchOutputHelper
```
protected Map<String,INDArray> batchOutputHelper(Map<String,INDArray> placeholders,
                                                 @NonNull
                                                 List<Listener> listeners,
                                                 String... outputs)
```
  - directExecHelper
```
protected Map<String,INDArray> directExecHelper(Map<String,INDArray> placeholders,
                                                At at,
                                                MultiDataSet batch,
                                                Collection<String> requiredActivations,
                                                List<Listener> activeListeners,
                                                String... outputs)
```
    Do inference for the given variables for a single batch, with training information
  - one
```
public SDVariable one(String name,
                      int... shape)
```
    See one(String, DataType, int...). Uses the DataType of the Nd4j default floating point type (Nd4j.defaultFloatingPointType()).
  - one
```
public SDVariable one(String name,
                      long... shape)
```
    See one(String, DataType, long...). Uses the DataType of the Nd4j default floating point type (Nd4j.defaultFloatingPointType()).
  - one
```
public SDVariable one(String name,
                      DataType dataType,
                      int... shape)
```
    Create a new variable with the specified shape, with all values initialized to 1.0
    
    Parameters:
    
    name - the name of the variable to create
    
    shape - the shape of the array to be created
    
    Returns:
    
    the created variable
  - one
```
public SDVariable one(String name,
                      DataType dataType,
                      long... shape)
```
    Create a new variable with the specified shape, with all values initialized to 1.0
    
    Parameters:
    
    name - the name of the variable to create
    
    shape - the shape of the array to be created
    
    Returns:
    
    the created variable
  - zero
```
public SDVariable zero(String name,
                       long... shape)
```
    See zero(String, DataType, long...). Uses the DataType of the Nd4j default floating point type (Nd4j.defaultFloatingPointType()).
  - zero
```
public SDVariable zero(String name,
                       int... shape)
```
    See zero(String, DataType, int...). Uses the DataType of the Nd4j default floating point type (Nd4j.defaultFloatingPointType()).
  - zero
```
public SDVariable zero(String name,
                       DataType dataType,
                       long... shape)
```
    Create a new variable with the specified shape, with all values initialized to 0
    
    Parameters:
    
    name - the name of the variable to create
    
    shape - the shape of the array to be created
    
    Returns:
    
    the created variable
  - zero
```
public SDVariable zero(String name,
                       DataType dataType,
                       int... shape)
```
    Create a new variable with the specified shape, with all values initialized to 0
    
    Parameters:
    
    name - the name of the variable to create
    
    shape - the shape of the array to be created
    
    Returns:
    
    the created variable
  - constant
```
public SDVariable constant(@NonNull
                           INDArray constant)
```
    Create an SDVariable with a fixed/constant value, with a generated name
    Constants are not modified by training/backprop. See VariableType for more details.
    
    Parameters:
    
    constant - Value for the constant SDVariable
    
    Returns:
    
    The created variable
  - constant
```
public SDVariable constant(String name,
                           @NonNull
                           INDArray constant)
```
    Create an SDVariable with a fixed/constant value
    Constants are not modified by training/backprop. See VariableType for more details.
    
    Parameters:
    
    name - Name of the constant SDVariable
    
    constant - Value for the constant SDVariable
    
    Returns:
    
    The created variable
  - constant
```
@Deprecated
public SDVariable constant(SDVariable value,
                                        long... shape)
```
    Deprecated.
    
    Return a variable of given shape in which all values have a given constant value.
    
    Parameters:
    
    value - constant to set for each value
    
    shape - shape of the variable as long array
    
    Returns:
    
    A new SDVariable of provided shape with constant value.
  - constant
```
@Deprecated
public SDVariable constant(String name,
                                        SDVariable value,
                                        long... shape)
```
    Deprecated.
    
    Return a variable of given shape in which all values have a given constant value.
    
    Parameters:
    
    name - Name of the new SDVariable
    
    value - constant to set for each value
    
    shape - shape of the variable as long array
    
    Returns:
    
    A new SDVariable of provided shape with constant value.
  - placeHolder
```
public SDVariable placeHolder(@NonNull
                              String name,
                              DataType dataType,
                              long... shape)
```
    Create a a placeholder variable. Placeholders are variables that expect an array to be provided during training and inference.
    For example, the SDVariables for your input/features and labels should be placeholders.
    See also: VariableType
    
    Parameters:
    
    name - the name of the variable
    
    dataType - Data type of the new placeholder
    
    shape - the shape of the variable if any
    
    Returns:
    
    SDVariable placeholder
  - var
```
public SDVariable var(@NonNull
                      String name,
                      @NonNull
                      WeightInitScheme weightInitScheme,
                      @NonNull
                      DataType dataType,
                      @NonNull
                      long... shape)
```
    Variable initialization with a specified WeightInitScheme This method creates VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    name - the name of the variable
    
    shape - the shape of the array to be created
    
    weightInitScheme - the weight initialization scheme
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(@NonNull
                      String name,
                      @NonNull
                      VariableType variableType,
                      WeightInitScheme weightInitScheme,
                      DataType dataType,
                      long... shape)
```
    Variable initialization with a specified WeightInitScheme This method creates VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    name - the name of the variable
    
    variableType - the SameDiff variable type of the variable (e.g. CONSTANT, PLACEHOLDER, etc.)
    
    weightInitScheme - the weight initialization scheme
    
    dataType - the data type of the variable (float, int, etc)
    
    shape - the shape of the array to be created
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(@NonNull
                      String name,
                      @NonNull
                      LongShapeDescriptor shape,
                      WeightInitScheme weightInitScheme)
```
    Creates a SDVariable with the given shape and name
    The underlying array will be initialized using the specified weight initilization scheme
    This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    name - the name of the variable
    
    shape - the shape of the variable
    
    weightInitScheme - Weight initialization scheme to use to initialize the underlying array
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(String name,
                      DataType dataType,
                      long... shape)
```
    Creates a SDVariable with the given shape and name
    Any array will be generated with all zeros for the values
    This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    name - the name of the variable
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(String name,
                      LongShapeDescriptor shapeDesc)
```
    Creates a SDVariable with the given shape and name
    Any array will be generated with all zeros for the values
    This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    name - the name of the variable
    
    shapeDesc - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(String name,
                      int... shape)
```
    Creates a SDVariable with the given shape and name
    Any array will be generated with all zeros for the values. Data type will be given by Nd4j.defaultFloatingPointType()
    This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    name - the name of the variable
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(String name,
                      long... shape)
```
    Creates a SDVariable with the given shape and name
    Any array will be generated with all zeros for the values. Data type will be given by Nd4j.defaultFloatingPointType()
    This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    name - the name of the variable
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(String name,
                      DataType dataType,
                      int... shape)
```
    Creates a SDVariable with the given shape and name
    Any array will be generated with all zeros for the values
    
    Parameters:
    
    name - the name of the variable
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(@NonNull
                      SDVariable v)
```
    Initialize a SDVariable reference tying this variable to this samediff instance.
    NDArraySupplierInitScheme is used to ensure that if the array is allocated anywhere and SameDiff instance to exist as a copy of the variable.
    
    Parameters:
    
    v - Variable
    
    Returns:
  - var
```
public SDVariable var(DataType dataType,
                      int... shape)
```
    Creates a SDVariable with the specified shape and a generated name
    Any array will be generated with all zeros for the values
    This method creates a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(DataType dataType,
                      long... shape)
```
    Creates a SDVariable with the specified shape and a generated name
    Any array will be generated with all zeros for the values
    This method creates a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(WeightInitScheme weightInitScheme,
                      DataType dataType,
                      long... shape)
```
    Creates a SDVariable with the specified shape and a generated name. The associated array will then be generated using the specified weight initialization scheme
    
    Parameters:
    
    weightInitScheme - The weight initialization scheme to use when generating an INDArray
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(INDArray arr)
```
    Create an SDVariable with a generated name, and assocate the specified array with it.
    This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    arr - Array to associate with the new variable
    
    Returns:
    
    New SDVariable
    
    See Also:
    
    var(String, INDArray)
  - var
```
public SDVariable var(String name,
                      @NonNull
                      INDArray arr)
```
    Create an SDVariable with the specified name, and associate the specified array with it
    This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. See VariableType for more details.
    
    Parameters:
    
    arr - Array to associate with the new variable
    
    Returns:
    
    New SDVariable with the specified name and array
  - convertToConstant
```
public SDVariable convertToConstant(@NonNull
                                    SDVariable variable)
```
    Convert the specified variable to a constant. This is equivalent to "freezing" a variable so that it's value won't be changed by further training.
    This can only be done for variables and placeholders, not ARRAY type variables (which are usually network activations). As a constant, this variable will no longer be modified by any subsequent training.
    See also: VariableType
    
    Parameters:
    
    variable - Variable to convert to a constant
    
    Returns:
    
    The (now constant) SDVariable
  - convertToConstants
```
public void convertToConstants(List<SDVariable> variables)
```
    Convert all of the specified variables to constants. This is equivalent to "freezing" the variables so that their values won't be changed by further training.
    This can only be done for variables and placeholders, not ARRAY type variables (which are usually network activations). As constants, these variables will no longer be modified by any subsequent training.
    See also: VariableType
    
    Parameters:
    
    variables - Variables to convert to constants
  - convertToVariable
```
public SDVariable convertToVariable(@NonNull
                                    SDVariable constant)
```
    Convert the specified variable to a VARIABLE type SDVariable.
    This can only be done for constants and placeholders, not ARRAY type variables (which are usually network activations). As a variable, this variable will modified during any subsequent training.
    See also: VariableType
    
    Returns:
    
    This variable (now a variable type SDVariable)
  - convertToVariables
```
public void convertToVariables(@NonNull
                               List<SDVariable> constants)
```
    Convert the specified variables to VARIABLE type SDVariables.
    This can only be done for constants and placeholders, not ARRAY type variables (which are usually network activations). As variables, this variable will modified during any subsequent training.
    See also: VariableType
  - convertDataTypes
```
public void convertDataTypes(@NonNull
                             Map<String,DataType> dataTypeMap)
```
    Convert the datatypes of the specified constants, placeholders and variables.
    After conversion, the downstream datatypes are changed. For example, z(float) = x(float)+y(float), changing both x and y to double results in z(double) = x(double)+y(double) without doing anything to change z's datatype directly (z datatype is inferred from x + y + add op).
    ARRAY type SDVariables cannot be converted directly, as their datatypes are determined by the function + input datatypes. Note that this method should be used with caution: incorrect datatype modifications may leave your network in an incorrect state. For example, op(x(float),y(float)) -> op(x(double),y(float)) may not be supported by all ops.
    
    Parameters:
    
    dataTypeMap - Map of SDVariables to change the datatype for. Key = SDVariable name, Value = new datatype
  renameVariable
  
  public void renameVariable(String from, String to)
  
  Rename the specified variable to the new name.
  
  Parameters:
  
  from - The variable to rename - this variable must exist
  
  to - The new name for the variable - no variable with this name must already exist
  
  removeArgFromOp
  
  public void removeArgFromOp(String varName, DifferentialFunction function)
  
  Remove an argument for a function. Note that if this function does not contain the argument, it will just be a no op.
  
  Parameters:
  
  varName - the variable name to remove
  
  function - the function to remove the argument from
  
  getVariable
  
  public SDVariable getVariable(String name)
  
  Get the variable based on the opName
  
  Parameters:
  
  name - the opName of the variable
  
  Returns:
  
  the variabel instance if there is one
  
  hasVariable
  
  public boolean hasVariable(String name)
  
  getGradForVariable
  
  public SDVariable getGradForVariable(String varName)
  
  Get the gradient for the variable with the specified name.
  The gradient variable is the variable that represents the derivative of the loss function with respect to the output of this variable. I.e., if this variable is X and loss function is L, then gradient() returns the variable representing dL/dX
  Note that only floating point variables can have gradients.
  Note also that a gradient may not yet be defined, and/or if no loss function variables have been set.
  You can set the loss function variables using setLossVariables(String...) and then create the gradient functions using createGradFunction(). Alternatively, the gradient function will be created automatically when training is performed.
  
  Parameters:
  
  varName - the vertex id
  
  Returns:
  
  the gradient for this variable or null
  
  variableHasGradient
  
  public boolean variableHasGradient(String varName)
  
  Determine if the specified variable has a gradient with respect to the current loss. Note that: (a) Non-floating-point variables (integer, string, etc) will never have gradients
  (b) This method will return false if no gradient function has been created yet. See createGradFunction() and setLossVariables(String...)
  (c) Floating point variables may not have any gradient if the specified loss variables does not depend on the specified variable at all. In this case, "no gradient" for floating point is equivalent to "always 0"
  
  Parameters:
  
  varName - Name of the variable to check the existence of a gradient variable for
  
  Returns:
  
  True if a gradient variable exists for the specified variable, for the current loss
  
  setGradientForVariableName
  
  public void setGradientForVariableName(String variableName, SDVariable variable)
  
  Assign a SDVariable to represent the gradient of the SDVariable with the specified name
  
  Parameters:
  
  variableName - the variable name to assign the gradient variable for
  
  variable - the gradient variable
  
  setForwardVariableForVarName
  
  public void setForwardVariableForVarName(String varName, SDVariable forwardVariable)
  
  Parameters:
  
  varName -
  
  forwardVariable -
  
  grad
  
  public SDVariable grad(String varName)
  
  Get the gradient for the variable with the specified variable name. Note that in order to run this function, execBackwards(Map, Operation, MultiDataSet, Collection, List) must be executed first. All gradient functions are obtained from the results of the execBackwards call.
  
  Parameters:
  
  varName - the variable name to get the gradient variable for.
  
  Returns:
  
  The gradient variable for the specified variable
  
  scalar
  
  public SDVariable scalar(String name, double value)
  
  Create a new double scalar (rank 0) SDVariable with the specified value
  
  Parameters:
  
  name - Name of the SDVariable
  
  value - Value to initialize the variable with
  
  Returns:
  
  SDVariable
  
  scalar
  
  public SDVariable scalar(String name, float value)
  
  Create a new float scalar (rank 0) SDVariable with the specified value
  
  Parameters:
  
  name - Name of the SDVariable
  
  value - Value to initialize the variable with
  
  Returns:
  
  SDVariable
  
  scalar
  
  public SDVariable scalar(String name, int value)
  
  Create a new integer scalar (rank 0) SDVariable with the specified value
  
  Parameters:
  
  name - Name of the SDVariable
  
  value - Value to initialize the variable with
  
  Returns:
  
  SDVariable
  
  scalar
  
  public SDVariable scalar(String name, long value)
  
  Create a new long scalar (rank 0) SDVariable with the specified value
  
  Parameters:
  
  name - Name of the SDVariable
  
  value - Value to initialize the variable with
  
  Returns:
  
  SDVariable
  
  scalar
  
  public SDVariable scalar(String name, DataType dataType, Number value)
  
  Create a new scalar (rank 0) SDVariable with the specified value and datatype
  
  Parameters:
  
  name - Name of the SDVariable
  
  dataType - Data type of the scalar
  
  value - Value to initialize the variable with
  
  Returns:
  
  SDVariable
  
  constant
  
  public SDVariable constant(double value)
  
  Create a new double scalar constant (rank 0) with the specified value.
  Constants are not modified by training/backprop. See VariableType for more details.
  
  Parameters:
  
  value - Value to initialize the constant with
  
  Returns:
  
  SDVariable
  
  constant
  
  public SDVariable constant(String name, double value)
  
  Create a new double scalar constant (rank 0) with the specified value
  
  Parameters:
  
  name - Name of the SDVariable
  
  value - Value to initialize the constant with
  
  Returns:
  
  SDVariable
  
  constant
  
  public SDVariable constant(float value)
  
  Create a new float scalar constant (rank 0) with the specified value
  Constants are not modified by training/backprop. See VariableType for more details.
  
  Parameters:
  
  value - Value to initialize the constant with
  
  Returns:
  
  SDVariable
  
  constant
  
  public SDVariable constant(String name, float value)
  
  Create a new float scalar constant (rank 0) with the specified value
  
  Parameters:
  
  name - Name of the SDVariable
  
  value - Value to initialize the constant with
  
  Returns:
  
  SDVariable
  
  constant
  
  public SDVariable constant(int value)
  
  Create a new integer scalar constant (rank 0) with the specified value
  
  Parameters:
  
  value - Value to initialize the constant with
  
  constant
  
  public SDVariable constant(String name, int value)
  
  Create a new integer scalar constant (rank 0) with the specified value
  
  Parameters:
  
  name - Name of the SDVariable
  
  value - Value to initialize the constant with
  
  Returns:
  
  SDVariable
  
  constant
  
  public SDVariable constant(long value)
  
  Create a new long scalar constant (rank 0) with the specified value
  
  Parameters:
  
  value - Value to initialize the constant with
  
  constant
  
  public SDVariable constant(String name, long value)
  
  Create a new long scalar constant (rank 0) with the specified value
  
  Parameters:
  
  name - Name of the SDVariable
  
  value - Value to initialize the constant with
  
  constant
  
  public SDVariable constant(String name, DataType dataType, Number value)
  
  Create a new scalar constant (rank 0) with the specified value and datatype
  
  Parameters:
  
  name - Name of the SDVariable
  
  dataType - Data type of the scalar constant
  
  value - Value to initialize the constant with
  
  addVariable
  
  public SDVariable addVariable(SDVariable variable)
  
  Add the specified variable to this SameDiff instance
  
  Parameters:
  
  variable - Variable to add
  
  generateOutputVariableForOp
  
  public SDVariable[] generateOutputVariableForOp(DifferentialFunction function, String baseName, boolean isImport)
  
  Generate the variables based on the given input op and return the output variable names.
  
  Parameters:
  
  function - the function to generate the output variable names for
  
  Returns:
  
  the set of names generated for each output of the function.
  
  generateOutputVariableForOp
  
  public SDVariable[] generateOutputVariableForOp(DifferentialFunction function)
  
  Generate the variables based on the given input op and return the output variable names.
  
  Parameters:
  
  function - the function to generate the output variable names for
  
  Returns:
  
  the set of names generated for each output of the function.
  
  getFunction
  
  public SameDiff getFunction(String functionName)
  
  Get a SameDiff function instance given the name of the function
  
  Parameters:
  
  functionName - the name of the function
  
  Returns:
  
  the same diff function instance defined for the given name
  
  whileStatement
  
  @Deprecated public While whileStatement(SameDiffConditional sameDiffConditional, SameDiffFunctionDefinition conditionBody, SameDiffFunctionDefinition loopBody, SDVariable[] inputVars)
  
  Deprecated. Use SDBaseOps.whileLoop(String[], String, SDVariable[], SameDiffSingleLambda, SameDiffLambda)
  
  ifStatement
  
  @Deprecated public If ifStatement(SameDiffConditional conditional, SameDiffFunctionDefinition conditionBody, SameDiffFunctionDefinition trueBody, SameDiffFunctionDefinition falseBody, SDVariable[] inputVars)
  
  Deprecated. Use SDBaseOps.ifCond(String, String, SameDiffNoArgSingleLambda, SameDiffNoArgSingleLambda, SameDiffNoArgSingleLambda)
  
  tensorArray
  
  public TensorArray tensorArray(DataType dataType)
  
  Create a new TensorArray.
  
  invokeFunctionOn
  
  public SDVariable invokeFunctionOn(String functionName, SameDiff with)
  
  Parameters:
  
  functionName -
  
  with -
  
  defineFunction
  
  public SameDiff defineFunction(String function, SameDiffFunctionDefinition functionDefinition, SDVariable[] variables)
  
  Parameters:
  
  function -
  
  defineFunction
  
  public void defineFunction(String function, SameDiffFunctionDefinition functionDefinition)
  
  Parameters:
  
  function -
  
  defineFunction
  
  public void defineFunction(String function, SameDiffFunctionDefinition functionDefinition, Map<String,INDArray> inputs)
  
  Parameters:
  
  function -
  
  functionDefinition -
  
  inputs -
  
  execAndEndResult
  
  @Deprecated public INDArray execAndEndResult()
  
  Deprecated.
  
  execBackwards
  
  public void execBackwards(Map<String,INDArray> placeholders, Operation op)
  
  Create (if required) and then calculate the variable gradients (backward pass) for this graph.
  After execution, the gradient arrays can be accessed using myVariable.getGradient().getArr()
  Note: This method by default calculates VARIABLE type SDVariable gradients only (as well as any other gradients needed to calculate the variable gradients). That is, placeholder, constant, etc gradients are not calculated. If these gradients are required, they can be calculated using execBackwards(Map, List, Operation, MultiDataSet, Collection, List) instead, which allows specifying the set of SDVariables to calculate the gradients for. For example, execBackwards(placeholders, Arrays.asList(myPlaceholder.gradient().getVarName()). In some cases, createGradFunction() may need to be called first
  
  Parameters:
  
  placeholders - Values for the placeholder variables in the graph. For graphs without placeholders, use null or an empty map
  
  execBackwards
  
  public void execBackwards(Map<String,INDArray> placeholders)
  
  See execBackwards(Map, Operation).
  Uses Operation.INFERENCE.
  
  execBackwards
  
  protected void execBackwards(Map<String,INDArray> placeholders, Operation op, MultiDataSet batch, Collection<String> requiredActivations, List<Listener> activeListeners)
  
  execBackwards
  
  public Map<String,INDArray> execBackwards(Map<String,INDArray> placeholders, Operation op, String... variableGradNamesList)
  
  See execBackwards(Map, List, Operation)
  
  execBackwards
  
  public Map<String,INDArray> execBackwards(Map<String,INDArray> placeholders, String... variableGradNamesList)
  
  See execBackwards(Map, Operation, String...).
  Uses Operation.INFERENCE.
  
  execBackwards
  
  public Map<String,INDArray> execBackwards(Map<String,INDArray> placeholders, List<String> variableGradNamesList, Operation operation)
  
  As per execBackwards(Map, Operation, MultiDataSet, Collection, List), but the set of gradients to calculate can be specified manually.
  For example, to calculate the gradient for placeholder variable "myPlaceholder", use execBackwards(placeholders, Arrays.asList(myPlaceholder.gradient().getVarName()).
  
  Parameters:
  
  placeholders - Values for the placeholder variables in the graph. For graphs without placeholders, use null or an empty map
  
  variableGradNamesList - Names of the gradient variables to calculate
  
  execBackwards
  
  public Map<String,INDArray> execBackwards(Map<String,INDArray> placeholders, List<String> variableGradNamesList)
  
  See execBackwards(Map, List, Operation).
  Uses Operation.INFERENCE.
  
  execBackwards
  
  protected Map<String,INDArray> execBackwards(Map<String,INDArray> placeholders, List<String> variableGradNamesList, Operation operation, MultiDataSet batch, Collection<String> requiredActivations, List<Listener> activeListeners)
  
  hasGradientFunction
  
  public boolean hasGradientFunction()
  
  Returns true if the gradient function has been created - i.e., createGradFunction() or createGradFunction(String...) has been called at all
  
  Returns:
  
  True if gradient (backprop) function exists
  
  createGradFunction
  
  public void createGradFunction()
  
  Create the gradient function (for calculating gradients via execBackwards(Map, Operation, String[])) if it is not already defined. Users do not usually need to call this function manually, as it is called as required in the aforementioned method.
  
  If the gradient function already exists, this method is a no-op.
  After this method returns, the SameDiff function instance for the gradient can be accessed using getFunction(String) with name "grad" as the argument.
  Note that the gradient array (after execBackwards has been called) can be accessed via SDVariable.gradient().getArr()
  
  createGradFunction
  
  public void createGradFunction(String... variablesRequiringGradients)
  
  As per createGradFunction(), but this method allows a set of variables requiring gradients to be specified. By default, only parameter gradients will be calculated; placeholder gradients may not be defined (unless they happen to be calculated in the same op as calculating a parameter gradient. This method allows you to override this behaviour by passing the name of the placeholder you want the gradients for. The specified gradient variables still need to be floating point variables.
  
  Parameters:
  
  variablesRequiringGradients - May be null. If non-null: the gradients for the variables with these names will be calculated and available after backprop has been done
  
  setOriginalPlaceHolderShape
  
  public void setOriginalPlaceHolderShape(String variableName, long[] shape)
  
  Set the original shape for a given place holder.
  This is used to track original shapes of place holder variables.
  The reason we track original shapes is to validate possible candidate arrays coming in (especially with -1 as the expected shapes).
  Note that if isPlaceHolder(String) returns false for the passed in vertex id, a ND4JIllegalStateException is thrown.
  
  Parameters:
  
  variableName - the vertex id for the original shape
  
  shape - the shape of the place holder
  
  getOriginalShapeForPlaceHolder
  
  @Deprecated public long[] getOriginalShapeForPlaceHolder(String varName)
  
  Deprecated.
  
  Get the original shape for the vertex id if one was set (other wise returns null).
  This is mainly for use in validating passed in arrays as arguments to resolveVariablesWith(Map) usually when executing using execAll(Map)
  
  Parameters:
  
  varName - the vertex id to get the original shape for.
  
  Returns:
  
  the set vertex
  
  isPlaceHolder
  
  public boolean isPlaceHolder(String varName)
  
  Returns true if this vertex id is a place holder variable or not
  A place holder variable is one where the array shape(s) are currently known and can't yet be calculated
  
  Parameters:
  
  varName - the vertex id to test
  
  Returns:
  
  True if the variable is a placeholder, false otherwise
  
  resolveVariablesWith
  
  public void resolveVariablesWith(Map<String,INDArray> arrays)
  
  Resolve all ndarrays by updating the variables for each array specified in the given map. An IllegalStateException will be thrown if not all arrays are specified for resolution.
  
  Parameters:
  
  arrays - the arrays to resolve.
  
  updateVariableNameAndReference
  
  public SDVariable updateVariableNameAndReference(SDVariable varToUpdate, String newVarName)
  
  Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.
  Note that if null for the new variable is passed in, it will just return the original input variable.
  
  Specified by:
  
  updateVariableNameAndReference in class SDBaseOps
  
  Parameters:
  
  varToUpdate - the variable to update
  
  newVarName - the new variable name
  
  Returns:
  
  the passed in variable
  
  sd
  
  protected SameDiff sd()
  
  Specified by:
  
  sd in class SDBaseOps
  
  updateVariableNamesAndReferences
  
  public SDVariable[] updateVariableNamesAndReferences(SDVariable[] variablesToUpdate, String[] newVariableNames)
  
  Updates the variable name property on the passed in variables, its reference in samediff, and returns the variable.
  
  Specified by:
  
  updateVariableNamesAndReferences in class SDBaseOps
  
  Parameters:
  
  variablesToUpdate - the variable to update
  
  newVariableNames - the new variable name
  
  Returns:
  
  the updated, passed in variables
  
  associateSameDiffWithOpsAndVariables
  
  protected void associateSameDiffWithOpsAndVariables()
  
  Associate the current SameDiff instance with all ops and variables. This is necessary to ensure that when dealing with shared state (usually with a SameDiff function such as "grad" - the backward function) we have the correct SameDiff instance set for all ops/SDVariables.
  If this is not done, arrays and shapes could be fetched from the incorrect SameDiff instance for some methods
  
  asFlatNode
  
  protected int asFlatNode(String name, @NonNull SameDiff scope, @NonNull com.google.flatbuffers.FlatBufferBuilder bufferBuilder)
  
  parseVariable
  
  public static org.nd4j.linalg.primitives.Pair<String,Integer> parseVariable(@NonNull String varName)
  
  Note: INTENDED FOR DEVELOPER USE
  This method extract base variable name and output index (if exists) from raw variable name. I.e: - if variable name is "Unstack_2", result will be Pair("Unstack_2", 0) - if variable name is "Unstack_2:12", result will be Pair("Unstack_2", 12)
  
  Parameters:
  
  varName -
  
  Returns:
  
  asFlatBuffers
  
  public ByteBuffer asFlatBuffers(@NonNull ExecutorConfiguration configuration, boolean includeUpdaterState)
  
  This method exports the current SameDiff instance into FlatBuffers format, returning the array ops and all arrays as a ByteBuffer containing the FlatBuffers format data
  
  Parameters:
  
  configuration - - ExecutorConfiguration to be embedded into serialized graph
  
  includeUpdaterState - If true: include the updater state (state for updaters such as Adam, Nesterov, AdaGrad etc)
  
  Returns:
  
  a ByteBuffer holding the exported FlatBuffers representation of the graph
  
  asFlatBuffers
  
  public ByteBuffer asFlatBuffers(long graphId, @NonNull ExecutorConfiguration configuration, boolean includeUpdaterState)
  
  This method exports the current SameDiff instance into FlatBuffers format, returning the array ops and all arrays as a ByteBuffer containing the FlatBuffers format data
  
  Parameters:
  
  configuration - - ExecutorConfiguration to be embedded into serialized graph
  
  includeUpdaterState - If true: include the updater state (state for updaters such as Adam, Nesterov, AdaGrad etc)
  
  Returns:
  
  a ByteBuffer holding the exported FlatBuffers representation of the graph
  
  asFlatGraph
  
  public FlatGraph asFlatGraph(boolean includeUpdaterState)
  
  See asFlatGraph(long, ExecutorConfiguration, boolean). Uses the default ExecutorConfiguration with output mode as OutputMode.VARIABLE_SPACE, execution mode as ExecutionMode.SEQUENTIAL, with profiling disabled and gather timings enabled.
  
  asFlatGraph
  
  public FlatGraph asFlatGraph(long graphId, ExecutorConfiguration configuration, boolean includeUpdaterState)
  
  This method returns FlatGraph structure
  
  Parameters:
  
  configuration -
  
  includeUpdaterState - If true: include the updater state (state for updaters such as Adam, Nesterov, AdaGrad etc)
  
  Returns:
  
  asFlatBuffers
  
  public ByteBuffer asFlatBuffers(boolean includeUpdaterState)
  
  This method exports the current SameDiff instance into FlatBuffers format, returning the array ops and all arrays as a ByteBuffer containing the FlatBuffers format data Uses the default ExecutorConfiguration with output mode as OutputMode.VARIABLE_SPACE, execution mode as ExecutionMode.SEQUENTIAL, with profiling disabled and gather timings enabled.
  
  Parameters:
  
  includeUpdaterState - If true: include the updater state (state for updaters such as Adam, Nesterov, AdaGrad etc)
  
  Returns:
  
  a ByteBuffer holding the exported FlatBuffers representation of the graph
  
  save
  
  public void save(@NonNull File file, boolean saveUpdaterState)
  
  Save the SameDiff instance to a file. Files can be loaded using load(File, boolean)
  
  Parameters:
  
  file - File to save to
  
  saveUpdaterState - If true: save the updater state (arrays etc for Adam, Nesterov, RmsProp etc). If false: don't save the updater state. If you want to continue training after loading your model, this should be true, however may increase the file size significantly. If the network is to be used for inference only, set this to false to save space
  
  save
  
  public void save(@NonNull OutputStream outputStream, boolean saveUpdater)
  
  As per save(File, boolean) but the serialized SameDiff instance is written to the output stream instead. Note that this temporarily saves to disk (using ND4JFileUtils.createTempFile(String, String) then copies all file bytes to the stream
  
  Parameters:
  
  outputStream - Stream to write the serialized SameDiff instance to
  
  saveUpdater - If true: save the updater state (arrays etc for Adam, Nesterov, RmsProp etc). If false: don't save the updater state. If you want to continue training after loading your model, this should be true, however may increase the file size significantly. If the network is to be used for inference only, set this to false to save space.
  
  load
  
  public static SameDiff load(@NonNull File file, boolean loadUpdaterState)
  
  Load the SameDiff instance previously saved with save(File, boolean)
  
  Parameters:
  
  file - The file to load the network from
  
  loadUpdaterState - If true - load the updater state (history etc for updaters such as Adam, Nesterov momentum, RMSProp etc). For inference only, this should be false, as the updater state will take more memory, but is not required for training. If the network is to be trained further, this should be true. The updater state can only be loaded if it was saved with the network.
  
  Returns:
  
  The loaded SameDiff network
  
  load
  
  public static SameDiff load(@NonNull InputStream is, boolean loadUpdaterState)
  
  As per load(File, boolean) but the SameDiff instance
  
  Parameters:
  
  is - Input stream to load the saved network from
  
  loadUpdaterState - If true - load the updater state (history etc for updaters such as Adam, Nesterov momentum, RMSProp etc). For inference only, this should be false, as the updater state will take more memory, but is not required for training. If the network is to be trained further, this should be true. The updater state can only be loaded if it was saved with the network.
  
  Returns:
  
  The loaded SameDiff network
  
  asFlatFile
  
  public void asFlatFile(@NonNull File file) throws IOException
  
  This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later
  This includes the updater state, if applicable. Uses the default ExecutorConfiguration with output mode as OutputMode.VARIABLE_SPACE, execution mode as ExecutionMode.SEQUENTIAL, with profiling disabled and gather timings enabled.
  
  Parameters:
  
  file - File to save the FlatBuffers serialized graph (including arrays) to
  
  Throws:
  
  IOException
  
  asFlatFile
  
  public void asFlatFile(@NonNull File file, boolean withUpdaterState) throws IOException
  
  See asFlatFile(File, ExecutorConfiguration, boolean). Uses the default ExecutorConfiguration with output mode as OutputMode.VARIABLE_SPACE, execution mode as ExecutionMode.SEQUENTIAL, with profiling disabled and gather timings enabled.
  
  Throws:
  
  IOException
  
  asFlatFile
  
  public void asFlatFile(@NonNull File file, @NonNull ExecutorConfiguration configuration, boolean includeUpdaterState) throws IOException
  
  This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later
  
  Parameters:
  
  file - File to save the FlatBuffers serialized graph (including arrays) to
  
  includeUpdaterState - If true: include the updater state (state for updaters such as Adam, Nesterov, AdaGrad etc)
  
  Throws:
  
  IOException
  
  fromFlatFile
  
  public static SameDiff fromFlatFile(@NonNull File file) throws IOException
  
  Create a SameDiff instance from a file, including the updater state The method to save the file is save(File, boolean)
  
  Parameters:
  
  file - the file to load from
  
  Returns:
  
  the loaded same diff instance
  
  Throws:
  
  IOException
  
  fromFlatFile
  
  public static SameDiff fromFlatFile(@NonNull File file, boolean loadUpdaterState) throws IOException
  
  Create a SameDiff instance from a file, optionally also loading the updater state The method to save the file is save(File, boolean)
  
  Parameters:
  
  file - the file to load from
  
  loadUpdaterState - If true, load the updater state (Adam etc state). For training, use true. For inference, use false
  
  Returns:
  
  the loaded same diff instance
  
  Throws:
  
  IOException
  
  fromFlatBuffers
  
  public static SameDiff fromFlatBuffers(ByteBuffer bbIn) throws IOException
  
  Create a SameDiff instance from a byte buffers instance. See fromFlatBuffers(ByteBuffer, boolean). Loads updater state (loadUpdaterState is true).
  
  Parameters:
  
  bbIn - the input byte buffer
  
  Returns:
  
  the created samediff instance
  
  Throws:
  
  IOException
  
  fromFlatBuffers
  
  public static SameDiff fromFlatBuffers(ByteBuffer bbIn, boolean loadUpdaterState) throws IOException
  
  Create a SameDiff instance from a byte buffers instance.
  
  Parameters:
  
  bbIn - the input byte buffer
  
  loadUpdaterState - If true, load the updater state (Adam etc state). For training, use true. For inference, use false
  
  Returns:
  
  the created samediff instance
  
  Throws:
  
  IOException
  
  asFlatPrint
  
  public String asFlatPrint()
  
  This method returns a text representation of the "flattened" graph.
  
  Returns:
  
  String representation of the graph
  
  See Also:
  
  summary()
  
  summary
  
  public String summary()
  
  Generate and return a String representation of the current SameDiff instance
  Reports variables, ops, SameDiff function instances, and (where possible) array shapes.
  For ops, the input and output variables are reported.
  For variables, the ops that they are inputs to - or outputs of - are also reported
  
  Returns:
  
  A String representation of the SameDiff instance
  
  calculateOutputDataTypes
  
  public Map<String,DataType> calculateOutputDataTypes()
  
  Calculate data types for the variables in the graph
  
  calculateOutputDataTypes
  
  public Map<String,DataType> calculateOutputDataTypes(boolean dynamicUpdate)
  
  Calculate data types for the variables in the graph
  
  newBlockName
  
  public String newBlockName(String baseName)
  
  For internal use only. Creates a new discinct block name from baseName. Block names are used by If and While
  
  importFrozenTF
  
  public static SameDiff importFrozenTF(File graphFile)
  
  Import a frozen Tensorflow graph to a new SameDiff graph.
  
  Parameters:
  
  graphFile - The text or binary file containing the graph
  
  Returns:
  
  The imported graph
  
  importFrozenTF
  
  public static SameDiff importFrozenTF(GraphDef graphDef)
  
  See importFrozenTF(File)
  
  importFrozenTF
  
  public static SameDiff importFrozenTF(InputStream graph)
  
  See importFrozenTF(File)
  Again, the input can be text or binary.
  
  getOpName
  
  public String getOpName(String base, boolean force)
  
  Generate a new, distinct op name of the form <base>_#.
  Applies name scope if active.
  
  Parameters:
  
  base - The base name to use
  
  force - Whether to force the result name to be the same as base.
  
  getOpName
  
  public String getOpName(String base)
  
  See getOpName(String, boolean) force is false
  
  generateNewVarName
  
  public String generateNewVarName(String base, int argIndex, boolean existingOp)
  
  Generate a new, distinct variable name of the form <base>_#[:#].
  Applies name scopes if active.
  
  Parameters:
  
  base - The base of the name.
  
  argIndex - The argument index, used in the ":#". A value of 0 (or negative) does not include the ":#" part.
  
  existingOp - Whether to generate an distinct operation name from base (if false), or just use base (if true).
  
  generateNewVarName
  
  public String generateNewVarName(String base, int argIndex)
  
  See generateNewVarName(String, int, boolean) existingOp is true.
  
  Specified by:
  
  generateNewVarName in class SDBaseOps
  
  generateDistinctCustomVariableName
  
  public String generateDistinctCustomVariableName(String base)
  
  Returns an unused variable name of the format <base>_#. Intended to be used for custom variables (like weights), arguments and op outputs should use generateNewVarName(String, int).

Class SameDiff

Field Summary

Method Summary

Methods inherited from class org.nd4j.autodiff.samediff.ops.SDBaseOps

Methods inherited from class java.lang.Object

Field Detail

GRAD_FN_KEY

math

random

nn

cnn

rnn

loss

image

bitwise

Method Detail

math

random

nn

cnn

rnn

loss

image

bitwise

updateVariableName

disableDebugging

enableDebugMode

f

setListeners

setListeners

addListeners

addListeners

getListeners

currentNameScope

nameWithScope

withNameScope

getOpsInScope

getOpsInScope

getVariablesInScope

getVariablesInScope

invokeGraphOn

opExists

getVariableOutputOp

getOpById

putOpForId

getInputsForOp

getOutputsForOp

getOutputVariablesForOp

getInputVariablesForOp

setArrayForVariable

getShapeForVarName

getShapeDescriptorForVarName

putShapeForVarName

putShapeForVarName

putOrUpdateShapeForVarName

shapeAlreadyExistsForVarName

arrayAlreadyExistsForVarName

getArrForVarName

associateArrayWithVariable

associateArrayWithVariable

assignArray

putSubFunction

variableMap

invoke

definedFunctionNames

invoke

addPropertyToResolve

removePropertyToResolve

propertiesToResolveForFunction

addVariableMappingForField

getVarNameForFieldAndFunction

setBaseNameForFunctionInstanceId

getBaseNameForFunction

setupFunction

addOutgoingFor

addOutgoingFor

addArgumentInterceptor

removeArgumentInterceptor

pauseArgumentInterceptor

pauseArgumentInterceptor