SameDiff (nd4j-api 1.0.0-alpha API)

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

```
public class SameDiff
extends Object
```
SameDiff is the entrypoint for nd4j's autodiff.
You define a graph symbolically.
That graph accumulates operations.
In order to execute the graph, you run exec() to get all the operations exec(List) for an already created set of ops execAndEndResult() for the end result only execAndEndResult(List) for a cached set of ops

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`SameDiff.DefaultSameDiffConditional`
`static interface`	`SameDiff.SameDiffConditional` An interface for representing a conditional statement
`static interface`	`SameDiff.SameDiffFunctionDefinition` A function definition for samediff

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`SDVariable`	`abs(SDVariable ix)`
`SDVariable`	`abs(String name, SDVariable ix)`
`SDVariable`	`acos(SDVariable iX)`
`SDVariable`	`acos(String name, SDVariable iX)`
`SDVariable`	`acosh(SDVariable iX)`
`SDVariable`	`acosh(String name, SDVariable iX)`
`void`	`addArgsFor(SDVariable[] variables, DifferentialFunction function)` Adds incoming args to the graph
`void`	`addArgsFor(String[] variables, DifferentialFunction function)` Adds incoming args to the graph
`void`	`addAsPlaceHolder(String varName)` Add this vertex id as a place holder
`void`	`addOutgoingFor(SDVariable[] variables, DifferentialFunction function)` Adds outgoing args to the graph
`void`	`addOutgoingFor(String[] varNames, DifferentialFunction function)` Adds outgoing arguments to the graph.
`void`	`addPropertyForFunction(DifferentialFunction functionFor, String propertyName, INDArray property)` Add a property for the given function
`void`	`addPropertyForFunction(DifferentialFunction functionFor, String propertyName, long property)` Add a property for the given function
`void`	`addPropertyToResolve(DifferentialFunction forFunction, String arrayName)` Adds a property that needs to be resolve for later.
`void`	`addVariable(SDVariable variable)`
`void`	`addVariableMappingForField(DifferentialFunction function, String fieldName, String varName)` Adds a field name -> variable name mapping for a given function.
`void`	`addVarNameForImport(String varName)` Marks a variable name as imported.
`boolean`	`allPlaceHolderVariablesResolved()` Returns true if all place holder variables are resolved.
`SDVariable`	`and(SDVariable iX, SDVariable iY)`
`SDVariable`	`and(String name, SDVariable ix, SDVariable iy)`
`SDVariable`	`argmax(SDVariable in, int... dimensions)`
`SDVariable`	`argmax(String name, SDVariable in, int... dimensions)`
`SDVariable`	`argmin(SDVariable in, int... dimensions)`
`SDVariable`	`argmin(String name, SDVariable in, int... dimensions)`
`boolean`	`arrayAlreadyExistsForVarName(String varName)` Returns true if the given vertex id and `INDArray` already exist.
`ByteBuffer`	`asFlatBuffers()` This method exports given SameDiff instance into FlatBuffers
`ByteBuffer`	`asFlatBuffers(ExecutorConfiguration configuration)` This method exports given SameDiff instance into FlatBuffers
`void`	`asFlatFile(File file)` This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later
`void`	`asFlatFile(File file, ExecutorConfiguration configuration)` This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later
`protected int`	`asFlatNode(DifferentialFunction node, com.google.flatbuffers.FlatBufferBuilder bufferBuilder, List<SDVariable> variables, Map<String,Integer> reverseMap, Map<String,Integer> forwardMap, Map<String,Integer> framesMap, AtomicInteger idCounter)`
`protected int`	`asFlatNode(String name, SameDiff scope, com.google.flatbuffers.FlatBufferBuilder bufferBuilder)`
`String`	`asFlatPrint()` This method returns "flattened" graph.
`SDVariable`	`asin(SDVariable iX)`
`SDVariable`	`asin(String name, SDVariable iX)`
`SDVariable`	`asinh(SDVariable iX)`
`SDVariable`	`asinh(String name, SDVariable iX)`
`SDVariable`	`assign(SDVariable x, SDVariable y)`
`SDVariable`	`assign(String name, SDVariable x, SDVariable y)`
`void`	`associateArrayWithVariable(INDArray arr, SDVariable variable)` Associate the array with the given variable.
`SDVariable`	`atan(SDVariable iX)`
`SDVariable`	`atan(String name, SDVariable iX)`
`SDVariable`	`atan2(SDVariable y, SDVariable x)`
`SDVariable`	`atan2(String name, SDVariable y, SDVariable x)`
`SDVariable`	`atanh(SDVariable iX)`
`SDVariable`	`atanh(String name, SDVariable iX)`
`SDVariable`	`avgPooling2d(SDVariable[] inputs, Pooling2DConfig pooling2DConfig)` Average pooling 2d operation.
`SDVariable`	`avgPooling2d(String name, SDVariable[] inputs, Pooling2DConfig pooling2DConfig)` Average pooling 2d operation.
`SDVariable`	`avgPooling3d(SDVariable[] inputs, Pooling3DConfig pooling3DConfig)` Average pooling 3d operation.
`SDVariable`	`avgPooling3d(String name, SDVariable[] inputs, Pooling3DConfig pooling3DConfig)` Average pooling 3d operation.
`SDVariable`	`batchNorm(SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon)` Batch norm operation.
`SDVariable`	`batchNorm(String name, SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon)` Batch norm operation.
`SDVariable`	`batchToSpace(SDVariable iX, int[] blocks, int[][] crops)`
`SDVariable`	`batchToSpace(String name, SDVariable iX, int[] blocks, int[][] crops)`
`SDVariable`	`biasAdd(SDVariable input, SDVariable bias)`
`SDVariable`	`biasAdd(String name, SDVariable input, SDVariable bias)`
`SDVariable`	`ceil(SDVariable x)`
`SDVariable`	`ceil(String name, SDVariable x)`
`SDVariable`	`clipByNorm(SDVariable x, double clipValue)`
`SDVariable`	`clipByNorm(String name, SDVariable x, double clipValue)`
`SDVariable`	`clipByValue(SDVariable x, double clipValueMin, double clipValueMax)`
`SDVariable`	`clipByValue(String name, SDVariable x, double clipValueMin, double clipValueMax)`
`SDVariable`	`concat(int dimension, SDVariable... inputs)`
`SDVariable`	`concat(String name, int dimension, SDVariable... inputs)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable predictions)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights)`
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred)`
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred, Integer numClasses)`
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)`
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred, SDVariable weights)`
`SDVariable`	`conv1d(SDVariable[] inputs, Conv1DConfig conv1DConfig)` Conv1d operation.
`SDVariable`	`conv1d(String name, SDVariable[] inputs, Conv1DConfig conv1DConfig)` Conv1d operation.
`SDVariable`	`conv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig)` Conv2d operation.
`SDVariable`	`conv2d(String name, SDVariable[] inputs, Conv2DConfig conv2DConfig)` Conv2d operation.
`SDVariable`	`conv3d(SDVariable[] inputs, Conv3DConfig conv3DConfig)` Conv3d operation.
`SDVariable`	`conv3d(String name, SDVariable[] inputs, Conv3DConfig conv3DConfig)` Conv3d operation.
`SDVariable`	`cos(SDVariable iX)`
`SDVariable`	`cos(String name, SDVariable iX)`
`SDVariable`	`cosh(SDVariable iX)`
`SDVariable`	`cosh(String name, SDVariable iX)`
`SDVariable`	`cosineDistance(SDVariable ix, SDVariable iy, int... dimensions)`
`SDVariable`	`cosineDistance(String name, SDVariable ix, SDVariable iy, int... dimensions)`
`SDVariable`	`cosineSimilarity(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`cosineSimilarity(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`countNonZero(SDVariable input)`
`SDVariable`	`countNonZero(String name, SDVariable input)`
`SDVariable`	`countZero(SDVariable input)`
`SDVariable`	`countZero(String name, SDVariable input)`
`static SameDiff`	`create()`
`static SameDiff`	`create(SameDiff originalSameDiff)`
`SDVariable`	`cross(SDVariable a, SDVariable b)`
`SDVariable`	`cross(String name, SDVariable a, SDVariable b)`
`SDVariable`	`cube(SDVariable iX)`
`SDVariable`	`cube(String name, SDVariable iX)`
`SDVariable`	`cumprod(SDVariable in, boolean exclusive, boolean reverse, int... dimensions)`
`SDVariable`	`cumprod(String name, SDVariable in, boolean exclusive, boolean reverse, int... dimensions)`
`SDVariable`	`cumsum(SDVariable in, boolean exclusive, boolean reverse, int... dimensions)`
`SDVariable`	`cumsum(String name, SDVariable in, boolean exclusive, boolean reverse, int... dimensions)`
`SDVariable`	`deconv2d(SDVariable[] inputs, DeConv2DConfig deconv2DConfig)` Deconv2d operation.
`SDVariable`	`deconv2d(String name, SDVariable[] inputs, DeConv2DConfig deconv2DConfig)` Deconv2d operation.
`Collection<String>`	`definedFunctionNames()` The set of defined function names
`void`	`defineFunction(String function, SameDiff.SameDiffFunctionDefinition functionDefinition)`
`void`	`defineFunction(String function, SameDiff.SameDiffFunctionDefinition functionDefinition, Map<String,INDArray> inputs)`
`SameDiff`	`defineFunction(String function, SameDiff.SameDiffFunctionDefinition functionDefinition, SDVariable[] variables)`
`SDVariable`	`depthToSpace(SDVariable iX, int blockSize, String dataFormat)`
`SDVariable`	`depthToSpace(String name, SDVariable iX, int blockSize, String dataFormat)`
`SDVariable`	`depthWiseConv2d(SDVariable[] inputs, Conv2DConfig depthConv2DConfig)` Depth-wise Conv2d operation.
`SDVariable`	`depthWiseConv2d(String name, SDVariable[] inputs, Conv2DConfig depthConv2DConfig)` Depth-wise Conv2d operation.
`SDVariable`	`diag(SDVariable iX)`
`SDVariable`	`diag(String name, SDVariable iX)`
`SDVariable`	`diagPart(SDVariable iX)`
`SDVariable`	`diagPart(String name, SDVariable iX)`
`SDVariable`	`dilation2D(SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)`
`SDVariable`	`dilation2D(String name, SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)`
`SameDiff`	`disableDebugging()` Clears debugging state and disables debug mode.
`SDVariable`	`dropout(SDVariable input, double p)`
`SDVariable`	`dropout(String name, SDVariable input, double p)`
`SameDiff`	`dup()`
`SDVariable[]`	`dynamicPartition(SDVariable iX, SDVariable partitions, int numPartitions)`
`SDVariable[]`	`dynamicPartition(String[] name, SDVariable iX, SDVariable partitions, int numPartitions)`
`SDVariable`	`dynamicStitch(SDVariable[] indices, SDVariable[] iX)`
`SDVariable`	`dynamicStitch(String name, SDVariable[] indices, SDVariable[] iX)`
`SDVariable`	`elu(SDVariable iX)`
`SDVariable`	`elu(String name, SDVariable iX)`
`SDVariable`	`eluDerivative(SDVariable iX)`
`SDVariable`	`eluDerivative(String name, SDVariable iX)`
`SameDiff`	`enableDebugMode()` Enables tracing of graphs automatically.
`SDVariable`	`eq(SDVariable iX, double iy)`
`SDVariable`	`eq(SDVariable iX, SDVariable iy)`
`SDVariable`	`eq(String name, SDVariable iX, double iy)`
`SDVariable`	`eq(String name, SDVariable iX, SDVariable iy)`
`boolean`	`equals(Object o)`
`SDVariable`	`erf(SDVariable iX)`
`SDVariable`	`erf(String name, SDVariable iX)`
`SDVariable`	`erfc(SDVariable iX)`
`SDVariable`	`erfc(String name, SDVariable iX)`
`SDVariable`	`euclideanDistance(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`euclideanDistance(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`INDArray[]`	`eval(Map<String,INDArray> inputs)` Evaluate the given inputs based on the current graph
`org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>`	`exec()` Creates and executes a list of operations
`List<DifferentialFunction>`	`exec(List<DifferentialFunction> ops)` Executes the list of operations.
`org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>`	`exec(String functionName)` Exec a given function
`List<DifferentialFunction>`	`exec(String functionName, List<DifferentialFunction> cachedOps)` Exec the given function given the ops
`INDArray`	`execAndEndResult()`
`INDArray`	`execAndEndResult(List<DifferentialFunction> ops)` u
`INDArray`	`execAndEndResult(String functionName)` Exec a given function
`INDArray`	`execBackwardAndEndResult()` Exec a backwards operation and return the end result
`org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>`	`execBackwards()` Builds a backwards graph and executes the operations on that graph.
`org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>`	`execWithPlaceHolder(Map<String,INDArray> inputs)` Creates and executes a list of operations based on the given variables passed in.
`INDArray`	`execWithPlaceHolderAndEndResult(Map<String,INDArray> inputs)` Creates and executes a list of operations
`SDVariable`	`exp(SDVariable iX)`
`SDVariable`	`exp(String name, SDVariable iX)`
`SDVariable`	`expandDims(SDVariable ix, int axis)`
`SDVariable`	`expandDims(String name, SDVariable ix, int axis)`
`SDVariable`	`expm1(SDVariable iX)`
`SDVariable`	`expm1(String name, SDVariable iX)`
`DifferentialFunctionFactory`	`f()` Returns this samediff instance's `DifferentialFunctionFactory`
`SDVariable`	`fill(SDVariable shape, double value)`
`SDVariable`	`fill(String name, SDVariable shape, double value)`
`SDVariable`	`floor(SDVariable iX)`
`SDVariable`	`floor(String name, SDVariable iX)`
`boolean`	`functionExists(String id)` Returns true if the given function id exists
`DifferentialFunction[]`	`functions()`
`SDVariable`	`gather(SDVariable df, int axis, int[] broadcast)`
`SDVariable`	`gather(String name, SDVariable df, int axis, int[] broadcast)`
`SDVariable`	`gatherNd(SDVariable df, SDVariable indices)`
`SDVariable`	`gatherNd(String name, SDVariable df, SDVariable indices)`
`String`	`generateNewVarName(String baseName, int argIndex)` Generate a new variable name based on the uniqueness of thebase name and arg index
`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)` 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
`String`	`getBaseNameForFunction(DifferentialFunction function)` Returns the base name for the given function if any (may return null)
`static byte`	`getDataTypeAsByte(DataBuffer.Type type)` This method converts enums for DataType
`static DataBuffer.Type`	`getDataTypeFromByte(byte val)` This method converts enums for DataType
`static byte`	`getFlatOpType(Op.Type type)` This method converts enums for DataType
`SDVariable`	`getForwardVariableForVertexId(int vertexId)` Get the forward variable for gradient based on the gradient's vertex id
`SameDiff`	`getFunction(String functionName)` Get a function instance given the opName
`DifferentialFunction`	`getFunctionById(String id)` Get the function by the `DifferentialFunction#getOwnName()`
`SDVariable`	`getGradForVariable(String varName)` Get the gradient for the given vertex id
`String[]`	`getInputsForFunction(DifferentialFunction function)` Returns the inputs for the given function
`SDVariable[]`	`getInputVariablesForFunction(DifferentialFunction function)` Get the input variables given a set of ids from `getInputVariablesForFunction(DifferentialFunction)`
`static long`	`getOpNum(String name, Op.Type type)` This method return operation ID for given op name/type pair.
`static byte`	`getOrderAsByte()` This method returns current byte order for this JVM as libnd4j enum
`static ByteOrder`	`getOrderFromByte(byte val)` This method just converts enums
`int[]`	`getOriginalShapeForPlaceHolder(String varName)` Get the original shape for the vertex id if one was set (other wise returns null).
`String[]`	`getOutputsForFunction(DifferentialFunction function)` Returns the outputs for the given function
`SDVariable[]`	`getOutputVariablesForFunction(DifferentialFunction function)` Get the output variables given a set of ids from `getOutputsForFunction(DifferentialFunction)`
`List<String[]>`	`getPlaceHoldersFor(String varName)` Get the place holders for a given vertex id.
`<T> T`	`getPropertyForFunction(DifferentialFunction functionInstance, String propertyName)` Get the property for a given function
`int[]`	`getShapeForVarName(String varName)` Get the shape for the given vertex id.
`static Op.Type`	`getTypeFromByte(byte type)` This method converts enums for DataType
`SDVariable`	`getVariable(String name)` Get the variable based on the opName
`SDVariable`	`getVariableForArray(INDArray arr)` Get an `SDVariable` for an array reference.
`List<SDVariable>`	`getVariablesAssociatedWithFunctions(List<DifferentialFunction> functions)` Get the `SDVariable` associated with each function based on the `DifferentialFunction.outputVariables()` ()}
`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)` Gradient with respect to the given variable opName.
`SDVariable`	`gradientBackwardsMarker(SDVariable iX)`
`SDVariable`	`gradientBackwardsMarker(String name, SDVariable iX)`
`SDVariable`	`gru(GRUCellConfiguration configuration)` The gru cell
`SDVariable`	`gru(String baseName, GRUCellConfiguration configuration)` The gru cell
`SDVariable`	`gt(SDVariable iX, double iy)`
`SDVariable`	`gt(SDVariable iX, SDVariable iy)`
`SDVariable`	`gt(String name, SDVariable iX, double iy)`
`SDVariable`	`gt(String name, SDVariable iX, SDVariable iy)`
`SDVariable`	`gte(SDVariable iX, double iy)`
`SDVariable`	`gte(SDVariable iX, SDVariable iy)`
`SDVariable`	`gte(String name, SDVariable iX, double iy)`
`SDVariable`	`gte(String name, SDVariable iX, SDVariable iy)`
`SDVariable`	`hammingDistance(SDVariable ix, SDVariable iy, int... dimensions)`
`SDVariable`	`hammingDistance(String name, SDVariable ix, SDVariable iy, int... dimensions)`
`SDVariable`	`hardTanh(SDVariable iX)`
`SDVariable`	`hardTanh(String name, SDVariable iX)`
`SDVariable`	`hardTanhDerivative(SDVariable iX)`
`SDVariable`	`hardTanhDerivative(String name, SDVariable iX)`
`boolean`	`hasArgs(DifferentialFunction function)` Returns true if this function already has defined arguments
`boolean`	`hasArgs(int[] function)` Returns true if this function already has defined arguments
`int`	`hashCode()`
`boolean`	`hasPlaceHolderVariables(String vertexId)` Returns true if the given vertex id has any placeholder variables
`boolean`	`hasPropertiesToResolve(DifferentialFunction function)` Returns true if the given function has ndarray properties to resolve.
`If`	`ifStatement(SameDiff.SameDiffConditional conditional, SameDiff.SameDiffFunctionDefinition conditionBody, SameDiff.SameDiffFunctionDefinition trueBody, SameDiff.SameDiffFunctionDefinition falseBody, SDVariable[] inputVars)`
`SDVariable`	`invertPermutation(SDVariable input)`
`SDVariable`	`invertPermutation(String name, SDVariable input)`
`SDVariable`	`invoke(Op op, SDVariable x)` Invoke an op by opName
`SDVariable`	`invoke(Op op, SDVariable x, SDVariable y)` Invoke an op by opName
`SDVariable`	`invokeFunctionOn(String functionName, SameDiff with)`
`SDVariable`	`invokeGraphOn(SameDiff sameDiff)`
`SDVariable`	`isFinite(SDVariable iX)`
`SDVariable`	`isFinite(String name, SDVariable iX)`
`boolean`	`isImportVariable(String variableName)` Returns true if the variable name is imported
`SDVariable`	`isInfinite(SDVariable iX)`
`SDVariable`	`isInfinite(String name, SDVariable iX)`
`SDVariable`	`isNaN(SDVariable iX)`
`SDVariable`	`isNaN(String name, SDVariable iX)`
`SDVariable`	`isNonDecreasing(SDVariable iX)`
`SDVariable`	`isNonDecreasing(String name, SDVariable iX)`
`SDVariable`	`isNumericTensor(SDVariable iX)`
`SDVariable`	`isNumericTensor(String name, SDVariable iX)`
`boolean`	`isPlaceHolder(String varName)` Returns true if this vertex id is a place holder variable or not
`SDVariable`	`isStrictlyIncreasing(SDVariable iX)`
`SDVariable`	`isStrictlyIncreasing(String name, SDVariable iX)`
`SDVariable`	`jaccardDistance(SDVariable ix, SDVariable iy, int... dimensions)`
`SDVariable`	`jaccardDistance(String name, SDVariable ix, SDVariable iy, int... dimensions)`
`SDVariable`	`leakyRelu(SDVariable iX, double cutoff)`
`SDVariable`	`leakyRelu(String name, SDVariable iX, double alpha)`
`SDVariable`	`leakyReluDerivative(String name, SDVariable iX, double alpha)`
`SDVariable`	`localResponseNormalization(SDVariable inputs, LocalResponseNormalizationConfig lrnConfig)` Local response normalization operation.
`SDVariable`	`localResponseNormalization(String name, SDVariable inputs, LocalResponseNormalizationConfig lrnConfig)` Local response normalization operation.
`SDVariable`	`log(SDVariable iX)`
`SDVariable`	`log(String name, SDVariable iX)`
`SDVariable`	`log1p(SDVariable iX)`
`SDVariable`	`log1p(String name, SDVariable iX)`
`SDVariable`	`logSigmoid(SDVariable iX)`
`SDVariable`	`logSigmoid(String name, SDVariable iX)`
`SDVariable`	`logSoftmax(SDVariable iX)`
`SDVariable`	`logSoftmax(String name, SDVariable iX)`
`SDVariable`	`lossBinaryXENT(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossBinaryXENT(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossCosineSimilarity(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossCosineSimilarity(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossHinge(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossHinge(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossKLD(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossKLD(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossL1(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossL1(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossL2(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossL2(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMAE(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMAE(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMCXENT(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMCXENT(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMSE(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMSE(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMSLE(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMSLE(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossNegativeLogLikelihood(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossNegativeLogLikelihood(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossPoisson(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossPoisson(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossSquaredHinge(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossSquaredHinge(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lstm(String baseName, LSTMCellConfiguration configuration)` LSTM unit
`SDVariable`	`lt(SDVariable iX, double iy)`
`SDVariable`	`lt(SDVariable iX, SDVariable iy)`
`SDVariable`	`lt(String name, SDVariable iX, double iy)`
`SDVariable`	`lt(String name, SDVariable iX, SDVariable iy)`
`SDVariable`	`lte(SDVariable iX, double iy)`
`SDVariable`	`lte(SDVariable iX, SDVariable iy)`
`SDVariable`	`lte(String name, SDVariable iX, double iy)`
`SDVariable`	`lte(String name, SDVariable iX, SDVariable iy)`
`SDVariable`	`manhattanDistance(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`manhattanDistance(String name, SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`max(SDVariable iX, int... dimensions)`
`SDVariable`	`max(SDVariable first, SDVariable second)`
`SDVariable`	`max(String name, SDVariable iX, int... dimensions)`
`SDVariable`	`max(String name, SDVariable first, SDVariable second)`
`SDVariable`	`maxPooling2d(SDVariable[] inputs, Pooling2DConfig pooling2DConfig)` Max pooling 2d operation.
`SDVariable`	`maxPooling2d(String name, SDVariable[] inputs, Pooling2DConfig pooling2DConfig)` Max pooling 2d operation.
`SDVariable`	`maxPooling3d(SDVariable[] inputs, Pooling3DConfig pooling3DConfig)` Max pooling 3d operation.
`SDVariable`	`maxPooling3d(String name, SDVariable[] inputs, Pooling3DConfig pooling3DConfig)` Max pooling 3d operation.
`SDVariable`	`mean(SDVariable iX)`
`SDVariable`	`mean(SDVariable iX, int... dimension)`
`SDVariable`	`mean(String name, SDVariable iX)`
`SDVariable`	`mean(String name, SDVariable iX, int... dimension)`
`long`	`memoryForGraph()` Returns the number of bytes for the graph
`SDVariable`	`mergeAdd(SDVariable... iX)`
`SDVariable`	`mergeAdd(String name, SDVariable[] iX)`
`SDVariable`	`min(SDVariable iX, int... dimensions)`
`SDVariable`	`min(SDVariable first, SDVariable second)`
`SDVariable`	`min(String name, SDVariable iX, int... dimensions)`
`SDVariable`	`min(String name, SDVariable first, SDVariable second)`
`SDVariable`	`mmul(SDVariable x, SDVariable y)`
`SDVariable`	`mmul(SDVariable x, SDVariable y, MMulTranspose transpose)`
`SDVariable`	`mmul(String name, SDVariable x, SDVariable y)`
`SDVariable`	`mmul(String name, SDVariable x, SDVariable y, MMulTranspose transpose)`
`SDVariable[]`	`moments(SDVariable input, int... axes)`
`SDVariable[]`	`moments(String[] name, SDVariable input, int... axes)`
`SDVariable`	`neg(SDVariable iX)`
`SDVariable`	`neg(String name, SDVariable iX)`
`SDVariable`	`neq(SDVariable iX, double iy)`
`SDVariable`	`neq(SDVariable iX, SDVariable iy)`
`SDVariable`	`neq(String name, SDVariable iX, double iy)`
`SDVariable`	`neq(String name, SDVariable iX, SDVariable iy)`
`static com.rits.cloning.Cloner`	`newCloner()`
`SDVariable`	`norm1(String name, SDVariable ix, int... dimensions)`
`SDVariable`	`norm2(String name, SDVariable ix, int... dimensions)`
`SDVariable[]`	`normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)`
`SDVariable[]`	`normalizeMoments(String[] name, SDVariable counts, SDVariable means, SDVariable variances, double shift)`
`SDVariable`	`normmax(String name, SDVariable ix, int... dimensions)`
`long`	`numElements()`
`SDVariable`	`one(String name, int[] shape)` Variable initialization with 1.0
`SDVariable`	`oneHot(SDVariable indices, int depth)`
`SDVariable`	`oneHot(SDVariable indices, int depth, int axis, double on, double off)`
`SDVariable`	`oneHot(String name, SDVariable indices, int depth)`
`SDVariable`	`oneHot(String name, SDVariable indices, int depth, int axis, double on, double off)`
`SDVariable`	`onesLike(SDVariable input)` Return a variable of all 1s, with the same shape as the input
`SDVariable`	`onesLike(String name, SDVariable input)` Return a variable of all 1s, with the same shape as the input
`SDVariable`	`or(SDVariable iX, SDVariable iy)`
`SDVariable`	`or(String name, SDVariable iX, SDVariable iy)`
`SDVariable`	`parallel_stack(SDVariable[] values)`
`SDVariable`	`parallel_stack(String name, SDVariable[] values)`
`static org.nd4j.linalg.primitives.Pair<String,Integer>`	`parseVariable(String varName)` This method extract base variable name and output index (if exists) from raw variable name.
`SDVariable`	`permute(SDVariable iX, int... dimensions)`
`SDVariable`	`permute(String name, SDVariable iX, int... dimensions)`
`static int[]`	`permuteDataFormatForSameDiff(String dataFormat, boolean weights)` Permute indices for the samediff/dl4j format.
`SDVariable`	`pow(SDVariable iX, double value)`
`SDVariable`	`pow(String name, SDVariable iX, double value)`
`void`	`printFunction(DifferentialFunction differentialFunction)` Print the given function for debugging (will not print functions)
`SDVariable`	`prod(SDVariable iX, int... dimensions)`
`SDVariable`	`prod(String name, SDVariable iX, int... dimensions)`
`List<String>`	`propertiesToResolveForFunction(DifferentialFunction function)` Return the properties to resolve for the given function.
`void`	`putArrayForVarName(String varName, INDArray arr)` Adds an ndarray for a given vertex id.
`void`	`putFunctionForId(String id, DifferentialFunction function)` Put the function for id
`void`	`putPlaceHolderForVariable(String varName, String... placeHolderVariables)` Add one or or more place holder variables for the given vertex id.
`void`	`putShapeForVarName(String varName, int[] shape)` Associate a vertex id with the given shape.
`void`	`putSubFunction(String name, SameDiff nameSpace)` Associate a `SameDiff` namespace as a sub function.
`SDVariable`	`reciprocal(SDVariable a)`
`SDVariable`	`reciprocal(String name, SDVariable a)`
`SDVariable`	`relu(SDVariable iX, double cutoff)`
`SDVariable`	`relu(String name, SDVariable iX, double cutoff)`
`SDVariable`	`relu6(SDVariable iX, double cutoff)`
`SDVariable`	`relu6(String name, SDVariable iX, double cutoff)`
`SDVariable`	`reluLayer(SDVariable input, SDVariable weights, SDVariable bias)`
`SDVariable`	`reluLayer(String name, SDVariable input, SDVariable weights, SDVariable bias)`
`void`	`removeArgFromFunction(String varName, DifferentialFunction function)` Remove an argument for a function.
`SDVariable`	`repeat(SDVariable df, int axis)`
`SDVariable`	`repeat(String name, SDVariable df, int axis)`
`SDVariable`	`reshape(SDVariable iX, int... shape)`
`SDVariable`	`reshape(String name, SDVariable iX, int... shape)`
`void`	`resolveVariablesWith(Map<String,INDArray> arrays)` Resolve all ndarrays by updating the variables for each array specified in the given map.
`SDVariable`	`reverse(SDVariable x, int... dimensions)`
`SDVariable`	`reverse(String name, SDVariable x, int... dimensions)`
`SDVariable`	`reverseSequence(SDVariable x, SDVariable seq_lengths)`
`SDVariable`	`reverseSequence(SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)`
`SDVariable`	`reverseSequence(String name, SDVariable x, SDVariable seq_lengths)`
`SDVariable`	`reverseSequence(String name, SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)`
`SDVariable`	`rollAxis(SDVariable x, int axis)`
`SDVariable`	`rollAxis(String name, SDVariable x, int axis)`
`SDVariable`	`round(SDVariable iX)`
`SDVariable`	`round(String name, SDVariable iX)`
`SDVariable`	`rsqrt(SDVariable iX)`
`SDVariable`	`rsqrt(String name, SDVariable iX)`
`SDVariable`	`scalar(String name, double value)`
`SDVariable`	`scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterAdd(String name, SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterDiv(String name, SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterMul(String name, SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterSub(String name, SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`sconv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig)` Separable Conv2d operation.
`SDVariable`	`sconv2d(String name, SDVariable[] inputs, Conv2DConfig conv2DConfig)` Separable Conv2d operation.
`SDVariable`	`selu(SDVariable iX)`
`SDVariable`	`selu(String name, SDVariable iX)`
`SDVariable`	`sequenceMask(SDVariable lengths)`
`SDVariable`	`sequenceMask(SDVariable lengths, int maxLen)`
`SDVariable`	`sequenceMask(SDVariable lengths, SDVariable maxLen)`
`SDVariable`	`sequenceMask(String name, SDVariable lengths)`
`SDVariable`	`sequenceMask(String name, SDVariable lengths, int maxLen)`
`SDVariable`	`sequenceMask(String name, SDVariable lengths, SDVariable maxLen)`
`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 vertex id to a gradient
`void`	`setOriginalPlaceHolderShape(String variableName, int[] shape)` Set the original shape for a given place holder.
`<X extends SDVariable> X`	`setupFunction(X function)` Attempts to insert the `DifferentialFunction` reference in to this `SameDiff` instance.
`SDVariable`	`shape(SDVariable df)`
`SDVariable`	`shape(String name, SDVariable df)`
`boolean`	`shapeAlreadyExistsForVarName(String varName)` Returns true if the given vertex id and shape already exist.
`SDVariable`	`sigmoid(SDVariable iX)`
`SDVariable`	`sigmoid(String name, SDVariable iX)`
`SDVariable`	`sigmoidCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)`
`SDVariable`	`sigmoidCrossEntropyWithLogits(String name, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)`
`SDVariable`	`sigmoidDerivative(SDVariable iX, SDVariable wrt)`
`SDVariable`	`sigmoidDerivative(String name, SDVariable iX, SDVariable wrt)`
`SDVariable`	`sign(SDVariable iX)`
`SDVariable`	`sign(String name, SDVariable iX)`
`SDVariable`	`sin(SDVariable iX)`
`SDVariable`	`sin(String name, SDVariable iX)`
`SDVariable`	`sinh(SDVariable iX)`
`SDVariable`	`sinh(String name, SDVariable iX)`
`SDVariable`	`slice(SDVariable input, int[] begin, int[] size)`
`SDVariable`	`slice(String name, SDVariable input, int[] begin, int[] size)`
`SDVariable`	`softmax(SDVariable iX)`
`SDVariable`	`softmax(String name, SDVariable iX)`
`SDVariable`	`softmaxCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)`
`SDVariable`	`softmaxCrossEntropyWithLogits(String name, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)`
`SDVariable`	`softmaxDerivative(String name, SDVariable iX, SDVariable wrt)`
`SDVariable`	`softplus(SDVariable iX)`
`SDVariable`	`softplus(String name, SDVariable iX)`
`SDVariable`	`softsign(SDVariable iX)`
`SDVariable`	`softsign(String name, SDVariable iX)`
`SDVariable`	`softsignDerivative(SDVariable iX)`
`SDVariable`	`softsignDerivative(String name, SDVariable iX)`
`SDVariable`	`spaceToBatch(SDVariable iX, int[] blocks, int[][] padding)`
`SDVariable`	`spaceToBatch(String name, SDVariable iX, int[] blocks, int[][] padding)`
`SDVariable`	`spaceToDepth(SDVariable iX, int blockSize, String dataFormat)`
`SDVariable`	`spaceToDepth(String name, SDVariable iX, int blockSize, String dataFormat)`
`SDVariable`	`sqrt(SDVariable iX)`
`SDVariable`	`sqrt(String name, SDVariable iX)`
`SDVariable`	`square(SDVariable iX)`
`SDVariable`	`square(String name, SDVariable iX)`
`SDVariable`	`squeeze(SDVariable ix, int axis)`
`SDVariable`	`squeeze(String name, SDVariable ix, int axis)`
`SDVariable`	`sru(SRUConfiguration configuration)` Simple recurrent unit
`SDVariable`	`sru(String baseName, SRUConfiguration configuration)` Simiple recurrent unit
`SDVariable`	`sruCell(SRUCellConfiguration configuration)` An sru cell
`SDVariable`	`sruCell(String baseName, SRUCellConfiguration configuration)` An sru cell
`SDVariable`	`stack(SDVariable[] values, int axis)`
`SDVariable`	`stack(String name, SDVariable[] values, int axis)`
`SDVariable`	`standardDeviation(SDVariable iX, boolean biasCorrected, int... dimensions)`
`SDVariable`	`standardDeviation(String name, SDVariable iX, boolean biasCorrected, int... dimensions)`
`SDVariable`	`stridedSlice(SDVariable input, int[] begin, int[] end, int[] strides)`
`SDVariable`	`stridedSlice(SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)`
`SDVariable`	`stridedSlice(String name, SDVariable input, int[] begin, int[] end, int[] strides)`
`SDVariable`	`stridedSlice(String name, SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)`
`SDVariable`	`sum(SDVariable iX, int... dimensions)`
`SDVariable`	`sum(String name, SDVariable iX, int... dimensions)`
`SDVariable`	`swish(SDVariable iX)`
`SDVariable`	`swish(String name, SDVariable iX)`
`SDVariable`	`tan(SDVariable iX)`
`SDVariable`	`tan(String name, SDVariable iX)`
`SDVariable`	`tanh(SDVariable iX)`
`SDVariable`	`tanh(String name, SDVariable iX)`
`SDVariable`	`tensorMmul(SDVariable x, SDVariable y, int[][] dimensions)`
`SDVariable`	`tensorMmul(String name, SDVariable x, SDVariable y, int[][] dimensions)`
`SDVariable`	`tile(SDVariable iX, int[] repeat)`
`SDVariable`	`tile(String name, SDVariable iX, int[] repeat)`
`SDVariable`	`transpose(SDVariable iX)`
`SDVariable`	`transpose(String name, SDVariable iX)`
`SDVariable[]`	`unstack(SDVariable value, int axis)`
`SDVariable[]`	`unstack(String[] names, SDVariable value, int axis)`
`void`	`updateArrayForVarName(String varName, INDArray arr)` Update the ndarray for the given vertex id.
`void`	`updateShapeForVarName(String varName, int[] shape)` Update a vertex id with the given shape.
`void`	`updateVariable(String variableName, INDArray arr)` Update the `INDArray` ndarray for the given variable name
`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(SDVariable arr)` Initialize a `SDVariable` reference tying this variable to this samediff instance.
`SDVariable`	`var(String name, INDArray arr)`
`SDVariable`	`var(String name, int[] shape)` Creates a `SDVariable` with the given shape and a depth of 0.
`SDVariable`	`var(String name, int[] shape, WeightInitScheme weightInitScheme)` Variable initialization with a specified `WeightInitScheme`
`Map<String,SDVariable>`	`variableMap()` Return the internal variable map
`List<SDVariable>`	`variables()` The list of available variables in the graph
`SDVariable`	`variance(SDVariable iX, boolean biasCorrected, int... dimensions)`
`SDVariable`	`variance(String name, SDVariable iX, boolean biasCorrected, int... dimensions)`
`SDVariable`	`weightedCrossEntropyWithLogits(SDVariable targets, SDVariable inputs, SDVariable weights)`
`SDVariable`	`weightedCrossEntropyWithLogits(String name, SDVariable targets, SDVariable inputs, SDVariable weights)`
`While`	`whileStatement(SameDiff.SameDiffConditional sameDiffConditional, SameDiff.SameDiffFunctionDefinition conditionBody, SameDiff.SameDiffFunctionDefinition loopBody, SDVariable[] inputVars)` Creates a while statement
`SDVariable`	`xor(SDVariable ix, SDVariable iy)`
`SDVariable`	`xor(String name, SDVariable ix, SDVariable iy)`
`SDVariable`	`xwPlusB(SDVariable input, SDVariable weights, SDVariable bias)`
`SDVariable`	`xwPlusB(String name, SDVariable input, SDVariable weights, SDVariable bias)`
`INDArray`	`yetAnotherExecMethod(Map<String,INDArray> inputs)`
`SDVariable`	`zero(String name, int[] shape)` Variable initialization with 0.0
`SDVariable`	`zeroFraction(SDVariable input)`
`SDVariable`	`zeroFraction(String name, SDVariable input)`
`SDVariable`	`zerosLike(SDVariable input)` Return a variable of all 0s with the same shape as the input
`SDVariable`	`zerosLike(String name, SDVariable input)` Return a variable of all 0s, with the same shape as the input

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

Method Detail

newCloner

public static com.rits.cloning.Cloner newCloner()

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

Returns:

invokeGraphOn

public SDVariable invokeGraphOn(SameDiff sameDiff)

Parameters:: sameDiff -
Returns:

functionExists
```
public boolean functionExists(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

getFunctionById
```
public DifferentialFunction getFunctionById(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

putFunctionForId

public void putFunctionForId(String id,
                             DifferentialFunction function)

Put the function for id

Parameters:: id - the id; function - the function

getInputsForFunction
```
public String[] getInputsForFunction(DifferentialFunction function)
```
Returns the inputs for the given function

Parameters:

function - the function to get the inputs for

Returns:

the input ids for a given function

getOutputsForFunction
```
public String[] getOutputsForFunction(DifferentialFunction function)
```
Returns the outputs for the given function

Parameters:

function - the function to get the inputs for

Returns:

the outputs ids for a given function

getOutputVariablesForFunction
```
public SDVariable[] getOutputVariablesForFunction(DifferentialFunction function)
```
Get the output variables given a set of ids from getOutputsForFunction(DifferentialFunction)

Parameters:

function - the function reference to get the id for

Returns:

the output variables for the given function

getInputVariablesForFunction
```
public SDVariable[] getInputVariablesForFunction(DifferentialFunction function)
```
Get the input variables given a set of ids from getInputVariablesForFunction(DifferentialFunction)

Parameters:

function - the function reference to get the id for

Returns:

the output variables for the given function

updateArrayForVarName
```
public void updateArrayForVarName(String varName,
                                  INDArray arr)
```
Update the ndarray for the given vertex id.

Parameters:

varName -

arr -

Throws:

{@link - ND4JIllegalStateException} when the array does not exist.

putArrayForVarName
```
public void putArrayForVarName(String varName,
                               INDArray arr)
```
Adds an ndarray for a given vertex id. Use updateArrayForVarName(String, INDArray) if the array already exists.

Parameters:

varName - the vertex id to add

arr - the array to add

Throws:

{@link - ND4JIllegalStateException} when the array already exists.

getShapeForVarName
```
public int[] getShapeForVarName(String varName)
```
Get the shape for the given vertex id. Note that if an array is defined, it will use that shape 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 if any.

updateShapeForVarName
```
public void updateShapeForVarName(String varName,
                                  int[] shape)
```
Update a vertex id with the given shape. Note that you should use putShapeForVarName(String, int[]) if you want to add a new shape. Update is meant to be an in place replacement of the shape for the vertex id *only*.

Parameters:

varName - the vertex id to associate

shape - the shape to associate with

putShapeForVarName
```
public void putShapeForVarName(String varName,
                               int[] shape)
```
Associate a vertex id with the given shape.

Parameters:

varName - the vertex id to associate

shape - the shape to associate with

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 the ndarray and vertex id already exist

getArrForVarName
```
public INDArray getArrForVarName(String varName)
```
Get an INDArray for a given vertex id

Parameters:

varName -

Returns:

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

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 the internal variable map

Returns:

invoke

public SDVariable invoke(Op op,
                         SDVariable x,
                         SDVariable y)

Invoke an op by opName

Parameters:: op - the op; x - the first input; y - the second input
Returns:: the result variable

getVariableForArray
```
public SDVariable getVariableForArray(INDArray arr)
```
Get an SDVariable for an array reference. Internally samediff associates array references with variables. This will typically be a shortcut for the array associated with SDVariable.getArr()

Parameters:

arr - the array reference

Returns:

the variable if one exists

definedFunctionNames
```
public Collection<String> definedFunctionNames()
```
The set of defined function names

Returns:

memoryForGraph
```
public long memoryForGraph()
```
Returns the number of bytes for the graph

Returns:

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

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

hasPropertiesToResolve
```
public boolean hasPropertiesToResolve(DifferentialFunction function)
```
Returns true if the given function has ndarray properties to resolve.

Parameters:

function - the function to check

Returns:

true if the function has yet to be resolved properties

getPropertyForFunction
```
public <T> T getPropertyForFunction(DifferentialFunction functionInstance,
                                    String propertyName)
```
Get the property for a given function

Type Parameters:

T - the inferred return type

Parameters:

functionInstance - the function to get the property for

propertyName - the name of the property to get

Returns:

the property for the given function

addPropertyForFunction

public void addPropertyForFunction(DifferentialFunction functionFor,
                                   String propertyName,
                                   INDArray property)

Add a property for the given function

Parameters:: functionFor - the function add a property for; propertyName - the property name; property - the property value

addPropertyForFunction

public void addPropertyForFunction(DifferentialFunction functionFor,
                                   String propertyName,
                                   long property)

Add a property for the given function

Parameters:: functionFor - the function to add the property for; propertyName - the name of the property to add the value for; property - the property value to add

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

isImportVariable
```
public boolean isImportVariable(String variableName)
```
Returns true if the variable name is imported

Parameters:

variableName - the imported variable name

Returns:

true if the name is imported, false otherwise

addVarNameForImport
```
public void addVarNameForImport(String varName)
```
Marks a variable name as imported. This is used in conjunction with model import to ensure immutability when referencing graph variables mapped from an external source.

Parameters:

varName - the var name to add.

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:

addOutgoingFor

public void addOutgoingFor(SDVariable[] variables,
                           DifferentialFunction function)

Adds outgoing args to the graph

Parameters:: variables -; function -

addOutgoingFor
```
public void addOutgoingFor(String[] varNames,
                           DifferentialFunction function)
```
Adds outgoing arguments to the graph. Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.

Parameters:

varNames -

function -

addArgsFor

public void addArgsFor(String[] variables,
                       DifferentialFunction function)

Adds incoming args to the graph

Parameters:: variables -; function -

addArgsFor

public void addArgsFor(SDVariable[] variables,
                       DifferentialFunction function)

Adds incoming args to the graph

Parameters:: variables -; function -

hasArgs
```
public boolean hasArgs(int[] 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

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

functions

public DifferentialFunction[] functions()

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

hashCode in class Object

create

public static SameDiff create(SameDiff originalSameDiff)

Parameters:: originalSameDiff -
Returns:

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

equals in class Object

create
```
public static SameDiff create()
```
Returns:

eval
```
public INDArray[] eval(Map<String,INDArray> inputs)
```
Evaluate the given inputs based on the current graph

Parameters:

inputs - the inputs to evaluate

Returns:

dup
```
public SameDiff dup()
```
Returns:

numElements
```
public long numElements()
```
Returns:

variables
```
public List<SDVariable> variables()
```
The list of available variables in the graph

Returns:

one
```
public SDVariable one(String name,
                      int[] shape)
```
Variable initialization with 1.0

Parameters:

name - the opName of the variable

shape - the shape of the array to be created

Returns:

the created variable

onesLike
```
public SDVariable onesLike(SDVariable input)
```
Return a variable of all 1s, with the same shape as the input

Parameters:

input -

Returns:

onesLike

public SDVariable onesLike(String name,
                           SDVariable input)

Return a variable of all 1s, with the same shape as the input

Parameters:: input -
Returns:

zero
```
public SDVariable zero(String name,
                       int[] shape)
```
Variable initialization with 0.0

Parameters:

name - the opName of the variable

shape - the shape of the array to be created

Returns:

the created variable

zerosLike
```
public SDVariable zerosLike(SDVariable input)
```
Return a variable of all 0s with the same shape as the input

Parameters:

input -

Returns:

zerosLike

public SDVariable zerosLike(String name,
                            SDVariable input)

Return a variable of all 0s, with the same shape as the input

Parameters:: input -
Returns:

var
```
public SDVariable var(String name,
                      int[] shape,
                      WeightInitScheme weightInitScheme)
```
Variable initialization with a specified WeightInitScheme

Parameters:

name - the opName of the variable

shape - the shape of the array to be created

weightInitScheme - the weight init scheme

Returns:

the created variable

var
```
public SDVariable var(String name,
                      int[] shape)
```
Creates a SDVariable with the given shape and a depth of 0.

Parameters:

name - the opName of the variable

shape - the shape of the variable

Returns:

the created variable

var
```
public SDVariable var(SDVariable arr)
```
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:

arr -

Returns:

removeArgFromFunction
```
public void removeArgFromFunction(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

var

public SDVariable var(String name,
                      INDArray arr)

Parameters:: name -; arr -
Returns:

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

getGradForVariable
```
public SDVariable getGradForVariable(String varName)
```
Get the gradient for the given vertex id

Parameters:

varName - the vertex id

Returns:

the gradient for this variable or null

setGradientForVariableName

public void setGradientForVariableName(String variableName,
                                       SDVariable variable)

Assign a vertex id to a gradient

Parameters:: variableName - the vertex id to assign; variable - the variable

getForwardVariableForVertexId
```
public SDVariable getForwardVariableForVertexId(int vertexId)
```
Get the forward variable for gradient based on the gradient's vertex id

Parameters:

vertexId - the vertex id

Returns:

the gradient for the variable or null

setForwardVariableForVarName

public void setForwardVariableForVarName(String varName,
                                         SDVariable forwardVariable)

Parameters:: varName -; forwardVariable -

grad
```
public SDVariable grad(String varName)
```
Gradient with respect to the given variable opName. Note that in order to run this function, execBackwards() must be executed first. All gradient functions are obtained within that time.

Parameters:

varName - the variable opName to get the gradient for.

Returns:

avgPooling2d

public SDVariable avgPooling2d(SDVariable[] inputs,
                               Pooling2DConfig pooling2DConfig)

Average pooling 2d operation.

Parameters:: inputs - the inputs to average pooling 2d; pooling2DConfig - the configuration
Returns:

avgPooling2d

public SDVariable avgPooling2d(String name,
                               SDVariable[] inputs,
                               Pooling2DConfig pooling2DConfig)

Average pooling 2d operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to average pooling 2d; pooling2DConfig - the configuration
Returns:

maxPooling2d

public SDVariable maxPooling2d(SDVariable[] inputs,
                               Pooling2DConfig pooling2DConfig)

Max pooling 2d operation.

Parameters:: inputs - the inputs to max pooling 2d; pooling2DConfig - the configuration
Returns:

maxPooling2d

public SDVariable maxPooling2d(String name,
                               SDVariable[] inputs,
                               Pooling2DConfig pooling2DConfig)

Max pooling 2d operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to max pooling 2d; pooling2DConfig - the configuration
Returns:

avgPooling3d

public SDVariable avgPooling3d(SDVariable[] inputs,
                               Pooling3DConfig pooling3DConfig)

Average pooling 3d operation.

Parameters:: inputs - the inputs to average pooling 3d; pooling3DConfig - the configuration
Returns:

avgPooling3d

public SDVariable avgPooling3d(String name,
                               SDVariable[] inputs,
                               Pooling3DConfig pooling3DConfig)

Average pooling 3d operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to average pooling 3d; pooling3DConfig - the configuration
Returns:

maxPooling3d

public SDVariable maxPooling3d(SDVariable[] inputs,
                               Pooling3DConfig pooling3DConfig)

Max pooling 3d operation.

Parameters:: inputs - the inputs to max pooling 3d; pooling3DConfig - the configuration
Returns:

maxPooling3d

public SDVariable maxPooling3d(String name,
                               SDVariable[] inputs,
                               Pooling3DConfig pooling3DConfig)

Max pooling 3d operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to max pooling 3d; pooling3DConfig - the configuration
Returns:

conv1d

public SDVariable conv1d(SDVariable[] inputs,
                         Conv1DConfig conv1DConfig)

Conv1d operation.

Parameters:: inputs - the inputs to conv1d; conv1DConfig - the configuration
Returns:

conv1d

public SDVariable conv1d(String name,
                         SDVariable[] inputs,
                         Conv1DConfig conv1DConfig)

Conv1d operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to conv1d; conv1DConfig - the configuration
Returns:

localResponseNormalization

public SDVariable localResponseNormalization(SDVariable inputs,
                                             LocalResponseNormalizationConfig lrnConfig)

Local response normalization operation.

Parameters:: inputs - the inputs to lrn; lrnConfig - the configuration
Returns:

localResponseNormalization

public SDVariable localResponseNormalization(String name,
                                             SDVariable inputs,
                                             LocalResponseNormalizationConfig lrnConfig)

Local response normalization operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to lrn; lrnConfig - the configuration
Returns:

conv2d

public SDVariable conv2d(SDVariable[] inputs,
                         Conv2DConfig conv2DConfig)

Conv2d operation.

Parameters:: inputs - the inputs to conv2d; conv2DConfig - the configuration
Returns:

conv2d

public SDVariable conv2d(String name,
                         SDVariable[] inputs,
                         Conv2DConfig conv2DConfig)

Conv2d operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to conv2d; conv2DConfig - the configuration
Returns:

depthWiseConv2d

public SDVariable depthWiseConv2d(SDVariable[] inputs,
                                  Conv2DConfig depthConv2DConfig)

Depth-wise Conv2d operation.

Parameters:: inputs - the inputs to conv2d; depthConv2DConfig - the configuration
Returns:

depthWiseConv2d

public SDVariable depthWiseConv2d(String name,
                                  SDVariable[] inputs,
                                  Conv2DConfig depthConv2DConfig)

Depth-wise Conv2d operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to sconv2d; depthConv2DConfig - the configuration
Returns:

sconv2d

public SDVariable sconv2d(SDVariable[] inputs,
                          Conv2DConfig conv2DConfig)

Separable Conv2d operation.

Parameters:: inputs - the inputs to conv2d; conv2DConfig - the configuration
Returns:

sconv2d

public SDVariable sconv2d(String name,
                          SDVariable[] inputs,
                          Conv2DConfig conv2DConfig)

Separable Conv2d operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to sconv2d; conv2DConfig - the configuration
Returns:

deconv2d

public SDVariable deconv2d(SDVariable[] inputs,
                           DeConv2DConfig deconv2DConfig)

Deconv2d operation.

Parameters:: inputs - the inputs to sconv2d; deconv2DConfig - the configuration
Returns:

deconv2d

public SDVariable deconv2d(String name,
                           SDVariable[] inputs,
                           DeConv2DConfig deconv2DConfig)

Deconv2d operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to sconv2d; deconv2DConfig - the configuration
Returns:

conv3d

public SDVariable conv3d(SDVariable[] inputs,
                         Conv3DConfig conv3DConfig)

Conv3d operation.

Parameters:: inputs - the inputs to conv3d; conv3DConfig - the configuration
Returns:

conv3d

public SDVariable conv3d(String name,
                         SDVariable[] inputs,
                         Conv3DConfig conv3DConfig)

Conv3d operation.

Parameters:: name - name of the operation in SameDiff; inputs - the inputs to conv3d; conv3DConfig - the configuration
Returns:

batchNorm

public SDVariable batchNorm(SDVariable input,
                            SDVariable mean,
                            SDVariable variance,
                            SDVariable gamma,
                            SDVariable beta,
                            boolean applyGamma,
                            boolean applyBeta,
                            double epsilon)

Batch norm operation.

batchNorm

public SDVariable batchNorm(String name,
                            SDVariable input,
                            SDVariable mean,
                            SDVariable variance,
                            SDVariable gamma,
                            SDVariable beta,
                            boolean applyGamma,
                            boolean applyBeta,
                            double epsilon)

Batch norm operation.

scalar

public SDVariable scalar(String name,
                         double value)

Parameters:: name -; value -
Returns:

gte

public SDVariable gte(SDVariable iX,
                      double iy)

Parameters:: iX -
Returns:

lte

public SDVariable lte(SDVariable iX,
                      double iy)

Parameters:: iX -
Returns:

gt

public SDVariable gt(SDVariable iX,
                     double iy)

Parameters:: iX -
Returns:

lt

public SDVariable lt(SDVariable iX,
                     double iy)

Parameters:: iX -
Returns:

neq

public SDVariable neq(SDVariable iX,
                      double iy)

Parameters:: iX -
Returns:

eq

public SDVariable eq(SDVariable iX,
                     double iy)

Parameters:: iX -
Returns:

gte

public SDVariable gte(SDVariable iX,
                      SDVariable iy)

Parameters:: iX -
Returns:

lte

public SDVariable lte(SDVariable iX,
                      SDVariable iy)

Parameters:: iX -
Returns:

gt

public SDVariable gt(SDVariable iX,
                     SDVariable iy)

Parameters:: iX -
Returns:

lt

public SDVariable lt(SDVariable iX,
                     SDVariable iy)

Parameters:: iX -
Returns:

neq

public SDVariable neq(SDVariable iX,
                      SDVariable iy)

Parameters:: iX -
Returns:

eq

public SDVariable eq(SDVariable iX,
                     SDVariable iy)

Parameters:: iX -
Returns:

or

public SDVariable or(SDVariable iX,
                     SDVariable iy)

Parameters:: iX -
Returns:

and

public SDVariable and(SDVariable iX,
                      SDVariable iY)

and

public SDVariable and(String name,
                      SDVariable ix,
                      SDVariable iy)

xor

public SDVariable xor(SDVariable ix,
                      SDVariable iy)

xor

public SDVariable xor(String name,
                      SDVariable ix,
                      SDVariable iy)

abs
```
public SDVariable abs(SDVariable ix)
```

abs

public SDVariable abs(String name,
                      SDVariable ix)

neg
```
public SDVariable neg(SDVariable iX)
```
Parameters:

iX -

Returns:

cos
```
public SDVariable cos(SDVariable iX)
```
Parameters:

iX -

Returns:

sin
```
public SDVariable sin(SDVariable iX)
```
Parameters:

iX -

Returns:

tan
```
public SDVariable tan(SDVariable iX)
```
Parameters:

iX -

Returns:

invertPermutation

public SDVariable invertPermutation(SDVariable input)

invertPermutation

public SDVariable invertPermutation(String name,
                                    SDVariable input)

acos

public SDVariable acos(SDVariable iX)

Parameters:: iX -
Returns:

asin

public SDVariable asin(SDVariable iX)

Parameters:: iX -
Returns:

atan

public SDVariable atan(SDVariable iX)

Parameters:: iX -
Returns:

atan2

public SDVariable atan2(SDVariable y,
                        SDVariable x)

atan2

public SDVariable atan2(String name,
                        SDVariable y,
                        SDVariable x)

cosh

public SDVariable cosh(SDVariable iX)

Parameters:: iX -
Returns:

sinh

public SDVariable sinh(SDVariable iX)

Parameters:: iX -
Returns:

tanh

public SDVariable tanh(SDVariable iX)

Parameters:: iX -
Returns:

acosh

public SDVariable acosh(SDVariable iX)

Parameters:: iX -
Returns:

asinh

public SDVariable asinh(SDVariable iX)

Parameters:: iX -
Returns:

atanh

public SDVariable atanh(SDVariable iX)

Parameters:: iX -
Returns:

exp
```
public SDVariable exp(SDVariable iX)
```
Parameters:

iX -

Returns:

rsqrt

public SDVariable rsqrt(SDVariable iX)

Parameters:: iX -
Returns:

expm1

public SDVariable expm1(SDVariable iX)

Parameters:: iX -
Returns:

log1p

public SDVariable log1p(SDVariable iX)

Parameters:: iX -
Returns:

isInfinite

public SDVariable isInfinite(SDVariable iX)

Parameters:: iX -
Returns:

isNaN

public SDVariable isNaN(SDVariable iX)

Parameters:: iX -
Returns:

round

public SDVariable round(SDVariable iX)

Parameters:: iX -
Returns:

isFinite

public SDVariable isFinite(SDVariable iX)

Parameters:: iX -
Returns:

log
```
public SDVariable log(SDVariable iX)
```
Parameters:

iX -

Returns:

cube

public SDVariable cube(SDVariable iX)

Parameters:: iX -
Returns:

pow

public SDVariable pow(SDVariable iX,
                      double value)

Parameters:: iX -; value -
Returns:

sqrt

public SDVariable sqrt(SDVariable iX)

Parameters:: iX -
Returns:

square

public SDVariable square(SDVariable iX)

Parameters:: iX -
Returns:

floor

public SDVariable floor(SDVariable iX)

Parameters:: iX -
Returns:

ceil
```
public SDVariable ceil(SDVariable x)
```

ceil

public SDVariable ceil(String name,
                       SDVariable x)

clipByValue

public SDVariable clipByValue(SDVariable x,
                              double clipValueMin,
                              double clipValueMax)

clipByValue

public SDVariable clipByValue(String name,
                              SDVariable x,
                              double clipValueMin,
                              double clipValueMax)

clipByNorm

public SDVariable clipByNorm(SDVariable x,
                             double clipValue)

clipByNorm

public SDVariable clipByNorm(String name,
                             SDVariable x,
                             double clipValue)

relu

public SDVariable relu(SDVariable iX,
                       double cutoff)

Parameters:: iX -
Returns:

relu6

public SDVariable relu6(SDVariable iX,
                        double cutoff)

Parameters:: iX -
Returns:

softmax

public SDVariable softmax(SDVariable iX)

Parameters:: iX -
Returns:

logSoftmax

public SDVariable logSoftmax(SDVariable iX)

logSoftmax

public SDVariable logSoftmax(String name,
                             SDVariable iX)

selu

public SDVariable selu(SDVariable iX)

selu

public SDVariable selu(String name,
                       SDVariable iX)

mergeAdd

public SDVariable mergeAdd(SDVariable... iX)

mergeAdd

public SDVariable mergeAdd(String name,
                           SDVariable[] iX)

batchToSpace

public SDVariable batchToSpace(SDVariable iX,
                               int[] blocks,
                               int[][] crops)

batchToSpace

public SDVariable batchToSpace(String name,
                               SDVariable iX,
                               int[] blocks,
                               int[][] crops)

depthToSpace

public SDVariable depthToSpace(SDVariable iX,
                               int blockSize,
                               String dataFormat)

depthToSpace

public SDVariable depthToSpace(String name,
                               SDVariable iX,
                               int blockSize,
                               String dataFormat)

spaceToBatch

public SDVariable spaceToBatch(SDVariable iX,
                               int[] blocks,
                               int[][] padding)

spaceToBatch

public SDVariable spaceToBatch(String name,
                               SDVariable iX,
                               int[] blocks,
                               int[][] padding)

spaceToDepth

public SDVariable spaceToDepth(SDVariable iX,
                               int blockSize,
                               String dataFormat)

spaceToDepth

public SDVariable spaceToDepth(String name,
                               SDVariable iX,
                               int blockSize,
                               String dataFormat)

dynamicPartition

public SDVariable[] dynamicPartition(SDVariable iX,
                                     SDVariable partitions,
                                     int numPartitions)

dynamicPartition

public SDVariable[] dynamicPartition(String[] name,
                                     SDVariable iX,
                                     SDVariable partitions,
                                     int numPartitions)

dynamicStitch

public SDVariable dynamicStitch(SDVariable[] indices,
                                SDVariable[] iX)

dynamicStitch

public SDVariable dynamicStitch(String name,
                                SDVariable[] indices,
                                SDVariable[] iX)

dilation2D

public SDVariable dilation2D(SDVariable df,
                             SDVariable weights,
                             int[] strides,
                             int[] rates,
                             boolean isSameMode)

dilation2D

public SDVariable dilation2D(String name,
                             SDVariable df,
                             SDVariable weights,
                             int[] strides,
                             int[] rates,
                             boolean isSameMode)

shape

public SDVariable shape(SDVariable df)

shape

public SDVariable shape(String name,
                        SDVariable df)

cross

public SDVariable cross(SDVariable a,
                        SDVariable b)

cross

public SDVariable cross(String name,
                        SDVariable a,
                        SDVariable b)

gather

public SDVariable gather(SDVariable df,
                         int axis,
                         int[] broadcast)

gather

public SDVariable gather(String name,
                         SDVariable df,
                         int axis,
                         int[] broadcast)

gatherNd

public SDVariable gatherNd(SDVariable df,
                           SDVariable indices)

gatherNd

public SDVariable gatherNd(String name,
                           SDVariable df,
                           SDVariable indices)

repeat

public SDVariable repeat(SDVariable df,
                         int axis)

repeat

public SDVariable repeat(String name,
                         SDVariable df,
                         int axis)

stack

public SDVariable stack(SDVariable[] values,
                        int axis)

stack

public SDVariable stack(String name,
                        SDVariable[] values,
                        int axis)

parallel_stack

public SDVariable parallel_stack(SDVariable[] values)

parallel_stack

public SDVariable parallel_stack(String name,
                                 SDVariable[] values)

unstack

public SDVariable[] unstack(SDVariable value,
                            int axis)

unstack

public SDVariable[] unstack(String[] names,
                            SDVariable value,
                            int axis)

erf
```
public SDVariable erf(SDVariable iX)
```

erf

public SDVariable erf(String name,
                      SDVariable iX)

erfc

public SDVariable erfc(SDVariable iX)

erfc

public SDVariable erfc(String name,
                       SDVariable iX)

diag

public SDVariable diag(SDVariable iX)

diag

public SDVariable diag(String name,
                       SDVariable iX)

diagPart

public SDVariable diagPart(SDVariable iX)

diagPart

public SDVariable diagPart(String name,
                           SDVariable iX)

oneHot

public SDVariable oneHot(SDVariable indices,
                         int depth)

oneHot

public SDVariable oneHot(SDVariable indices,
                         int depth,
                         int axis,
                         double on,
                         double off)

oneHot

public SDVariable oneHot(String name,
                         SDVariable indices,
                         int depth)

oneHot

public SDVariable oneHot(String name,
                         SDVariable indices,
                         int depth,
                         int axis,
                         double on,
                         double off)

reciprocal

public SDVariable reciprocal(SDVariable a)

reciprocal

public SDVariable reciprocal(String name,
                             SDVariable a)

gradientBackwardsMarker

public SDVariable gradientBackwardsMarker(SDVariable iX)

Parameters:: iX -
Returns:

hardTanh

public SDVariable hardTanh(SDVariable iX)

Parameters:: iX -
Returns:

hardTanhDerivative

public SDVariable hardTanhDerivative(SDVariable iX)

Parameters:: iX -
Returns:

sigmoid

public SDVariable sigmoid(SDVariable iX)

Parameters:: iX -
Returns:

sigmoidDerivative

public SDVariable sigmoidDerivative(SDVariable iX,
                                    SDVariable wrt)

Parameters:: iX -
Returns:

logSigmoid

public SDVariable logSigmoid(SDVariable iX)

logSigmoid

public SDVariable logSigmoid(String name,
                             SDVariable iX)

sign

public SDVariable sign(SDVariable iX)

Parameters:: iX -
Returns:

softsign

public SDVariable softsign(SDVariable iX)

Parameters:: iX -
Returns:

softsignDerivative

public SDVariable softsignDerivative(SDVariable iX)

Parameters:: iX -
Returns:

softplus

public SDVariable softplus(SDVariable iX)

Parameters:: iX -
Returns:

swish

public SDVariable swish(SDVariable iX)

swish

public SDVariable swish(String name,
                        SDVariable iX)

elu
```
public SDVariable elu(SDVariable iX)
```
Parameters:

iX -

Returns:

eluDerivative

public SDVariable eluDerivative(SDVariable iX)

Parameters:: iX -
Returns:

leakyRelu

public SDVariable leakyRelu(SDVariable iX,
                            double cutoff)

Parameters:: iX -; cutoff -
Returns:

mean

public SDVariable mean(SDVariable iX)

Parameters:: iX -
Returns:

mean

public SDVariable mean(SDVariable iX,
                       int... dimension)

Parameters:: iX -; dimension -
Returns:

standardDeviation

public SDVariable standardDeviation(SDVariable iX,
                                    boolean biasCorrected,
                                    int... dimensions)

Parameters:: iX -; biasCorrected -; dimensions -
Returns:

variance

public SDVariable variance(SDVariable iX,
                           boolean biasCorrected,
                           int... dimensions)

Parameters:: iX -; biasCorrected -; dimensions -
Returns:

sum

public SDVariable sum(SDVariable iX,
                      int... dimensions)

Parameters:: iX -; dimensions -
Returns:

prod

public SDVariable prod(SDVariable iX,
                       int... dimensions)

Parameters:: iX -; dimensions -
Returns:

max

public SDVariable max(SDVariable iX,
                      int... dimensions)

Parameters:: iX -; dimensions -
Returns:

max

public SDVariable max(SDVariable first,
                      SDVariable second)

max

public SDVariable max(String name,
                      SDVariable first,
                      SDVariable second)

countZero

public SDVariable countZero(SDVariable input)

countZero

public SDVariable countZero(String name,
                            SDVariable input)

zeroFraction

public SDVariable zeroFraction(SDVariable input)

zeroFraction

public SDVariable zeroFraction(String name,
                               SDVariable input)

countNonZero

public SDVariable countNonZero(SDVariable input)

countNonZero

public SDVariable countNonZero(String name,
                               SDVariable input)

min

public SDVariable min(SDVariable iX,
                      int... dimensions)

Parameters:: iX -; dimensions -
Returns:

min

public SDVariable min(SDVariable first,
                      SDVariable second)

min

public SDVariable min(String name,
                      SDVariable first,
                      SDVariable second)

argmax

public SDVariable argmax(SDVariable in,
                         int... dimensions)

argmax

public SDVariable argmax(String name,
                         SDVariable in,
                         int... dimensions)

argmin

public SDVariable argmin(SDVariable in,
                         int... dimensions)

argmin

public SDVariable argmin(String name,
                         SDVariable in,
                         int... dimensions)

cumsum

public SDVariable cumsum(SDVariable in,
                         boolean exclusive,
                         boolean reverse,
                         int... dimensions)

cumsum

public SDVariable cumsum(String name,
                         SDVariable in,
                         boolean exclusive,
                         boolean reverse,
                         int... dimensions)

cumprod

public SDVariable cumprod(SDVariable in,
                          boolean exclusive,
                          boolean reverse,
                          int... dimensions)

cumprod

public SDVariable cumprod(String name,
                          SDVariable in,
                          boolean exclusive,
                          boolean reverse,
                          int... dimensions)

biasAdd

public SDVariable biasAdd(SDVariable input,
                          SDVariable bias)

biasAdd

public SDVariable biasAdd(String name,
                          SDVariable input,
                          SDVariable bias)

reshape

public SDVariable reshape(SDVariable iX,
                          int... shape)

Parameters:: iX -; shape -
Returns:

reverse

public SDVariable reverse(SDVariable x,
                          int... dimensions)

Parameters:: x -; dimensions -
Returns:

reverse

public SDVariable reverse(String name,
                          SDVariable x,
                          int... dimensions)

Parameters:: x -; dimensions -
Returns:

reverseSequence

public SDVariable reverseSequence(String name,
                                  SDVariable x,
                                  SDVariable seq_lengths,
                                  int seqDim,
                                  int batchDim)

reverseSequence

public SDVariable reverseSequence(String name,
                                  SDVariable x,
                                  SDVariable seq_lengths)

reverseSequence

public SDVariable reverseSequence(SDVariable x,
                                  SDVariable seq_lengths,
                                  int seqDim,
                                  int batchDim)

reverseSequence

public SDVariable reverseSequence(SDVariable x,
                                  SDVariable seq_lengths)

sequenceMask

public SDVariable sequenceMask(String name,
                               SDVariable lengths,
                               SDVariable maxLen)

sequenceMask

public SDVariable sequenceMask(SDVariable lengths,
                               SDVariable maxLen)

sequenceMask

public SDVariable sequenceMask(String name,
                               SDVariable lengths,
                               int maxLen)

sequenceMask

public SDVariable sequenceMask(SDVariable lengths,
                               int maxLen)

sequenceMask

public SDVariable sequenceMask(String name,
                               SDVariable lengths)

sequenceMask

public SDVariable sequenceMask(SDVariable lengths)

assign

public SDVariable assign(SDVariable x,
                         SDVariable y)

assign

public SDVariable assign(String name,
                         SDVariable x,
                         SDVariable y)

transpose

public SDVariable transpose(SDVariable iX)

Parameters:: iX -
Returns:

permute

public SDVariable permute(SDVariable iX,
                          int... dimensions)

Parameters:: iX -; dimensions -
Returns:

rollAxis

public SDVariable rollAxis(SDVariable x,
                           int axis)

Parameters:: x -; axis -
Returns:

concat

public SDVariable concat(int dimension,
                         SDVariable... inputs)

Parameters:: dimension -; inputs -
Returns:

moments

public SDVariable[] moments(SDVariable input,
                            int... axes)

moments

public SDVariable[] moments(String[] name,
                            SDVariable input,
                            int... axes)

normalizeMoments

public SDVariable[] normalizeMoments(SDVariable counts,
                                     SDVariable means,
                                     SDVariable variances,
                                     double shift)

normalizeMoments

public SDVariable[] normalizeMoments(String[] name,
                                     SDVariable counts,
                                     SDVariable means,
                                     SDVariable variances,
                                     double shift)

tile

public SDVariable tile(SDVariable iX,
                       int[] repeat)

Parameters:: iX -; repeat -
Returns:

fill

public SDVariable fill(SDVariable shape,
                       double value)

dropout

public SDVariable dropout(SDVariable input,
                          double p)

dropout

public SDVariable dropout(String name,
                          SDVariable input,
                          double p)

xwPlusB

public SDVariable xwPlusB(SDVariable input,
                          SDVariable weights,
                          SDVariable bias)

xwPlusB

public SDVariable xwPlusB(String name,
                          SDVariable input,
                          SDVariable weights,
                          SDVariable bias)

reluLayer

public SDVariable reluLayer(SDVariable input,
                            SDVariable weights,
                            SDVariable bias)

reluLayer

public SDVariable reluLayer(String name,
                            SDVariable input,
                            SDVariable weights,
                            SDVariable bias)

mmul

public SDVariable mmul(SDVariable x,
                       SDVariable y,
                       MMulTranspose transpose)

Parameters:: x -; y -; transpose -
Returns:

mmul

public SDVariable mmul(SDVariable x,
                       SDVariable y)

Parameters:: x -; y -
Returns:

tensorMmul

public SDVariable tensorMmul(SDVariable x,
                             SDVariable y,
                             int[][] dimensions)

Parameters:: x -; y -; dimensions -
Returns:

cosineSimilarity

public SDVariable cosineSimilarity(SDVariable iX,
                                   SDVariable i_y,
                                   int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

euclideanDistance

public SDVariable euclideanDistance(SDVariable iX,
                                    SDVariable i_y,
                                    int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

manhattanDistance

public SDVariable manhattanDistance(SDVariable iX,
                                    SDVariable i_y,
                                    int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

cosineDistance

public SDVariable cosineDistance(SDVariable ix,
                                 SDVariable iy,
                                 int... dimensions)

cosineDistance

public SDVariable cosineDistance(String name,
                                 SDVariable ix,
                                 SDVariable iy,
                                 int... dimensions)

hammingDistance

public SDVariable hammingDistance(SDVariable ix,
                                  SDVariable iy,
                                  int... dimensions)

hammingDistance

public SDVariable hammingDistance(String name,
                                  SDVariable ix,
                                  SDVariable iy,
                                  int... dimensions)

jaccardDistance

public SDVariable jaccardDistance(SDVariable ix,
                                  SDVariable iy,
                                  int... dimensions)

jaccardDistance

public SDVariable jaccardDistance(String name,
                                  SDVariable ix,
                                  SDVariable iy,
                                  int... dimensions)

lossBinaryXENT

public SDVariable lossBinaryXENT(SDVariable iX,
                                 SDVariable i_y,
                                 int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossCosineSimilarity

public SDVariable lossCosineSimilarity(SDVariable iX,
                                       SDVariable i_y,
                                       int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossHinge

public SDVariable lossHinge(SDVariable iX,
                            SDVariable i_y,
                            int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossKLD

public SDVariable lossKLD(SDVariable iX,
                          SDVariable i_y,
                          int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossL1

public SDVariable lossL1(SDVariable iX,
                         SDVariable i_y,
                         int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossL2

public SDVariable lossL2(SDVariable iX,
                         SDVariable i_y,
                         int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossMAE

public SDVariable lossMAE(SDVariable iX,
                          SDVariable i_y,
                          int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossMSE

public SDVariable lossMSE(SDVariable iX,
                          SDVariable i_y,
                          int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossMCXENT

public SDVariable lossMCXENT(SDVariable iX,
                             SDVariable i_y,
                             int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossMSLE

public SDVariable lossMSLE(SDVariable iX,
                           SDVariable i_y,
                           int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossNegativeLogLikelihood

public SDVariable lossNegativeLogLikelihood(SDVariable iX,
                                            SDVariable i_y,
                                            int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossPoisson

public SDVariable lossPoisson(SDVariable iX,
                              SDVariable i_y,
                              int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossSquaredHinge

public SDVariable lossSquaredHinge(SDVariable iX,
                                   SDVariable i_y,
                                   int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

gradientBackwardsMarker

public SDVariable gradientBackwardsMarker(String name,
                                          SDVariable iX)

Parameters:: name -; iX -
Returns:

neq

public SDVariable neq(String name,
                      SDVariable iX,
                      double iy)

Parameters:: iX -
Returns:

eq

public SDVariable eq(String name,
                     SDVariable iX,
                     double iy)

Parameters:: iX -
Returns:

gte

public SDVariable gte(String name,
                      SDVariable iX,
                      double iy)

Parameters:: iX -
Returns:

lte

public SDVariable lte(String name,
                      SDVariable iX,
                      double iy)

Parameters:: iX -
Returns:

gt

public SDVariable gt(String name,
                     SDVariable iX,
                     double iy)

Parameters:: iX -
Returns:

lt

public SDVariable lt(String name,
                     SDVariable iX,
                     double iy)

Parameters:: iX -
Returns:

neq

public SDVariable neq(String name,
                      SDVariable iX,
                      SDVariable iy)

Parameters:: iX -
Returns:

eq

public SDVariable eq(String name,
                     SDVariable iX,
                     SDVariable iy)

Parameters:: iX -
Returns:

gte

public SDVariable gte(String name,
                      SDVariable iX,
                      SDVariable iy)

Parameters:: iX -
Returns:

lte

public SDVariable lte(String name,
                      SDVariable iX,
                      SDVariable iy)

Parameters:: iX -
Returns:

gt

public SDVariable gt(String name,
                     SDVariable iX,
                     SDVariable iy)

Parameters:: iX -
Returns:

lt

public SDVariable lt(String name,
                     SDVariable iX,
                     SDVariable iy)

Parameters:: iX -
Returns:

or

public SDVariable or(String name,
                     SDVariable iX,
                     SDVariable iy)

Parameters:: iX -
Returns:

neg

public SDVariable neg(String name,
                      SDVariable iX)

Parameters:: iX -
Returns:

isNonDecreasing

public SDVariable isNonDecreasing(SDVariable iX)

Parameters:: iX -
Returns:

isNonDecreasing

public SDVariable isNonDecreasing(String name,
                                  SDVariable iX)

Parameters:: iX -
Returns:

isStrictlyIncreasing

public SDVariable isStrictlyIncreasing(SDVariable iX)

Parameters:: iX -
Returns:

isStrictlyIncreasing

public SDVariable isStrictlyIncreasing(String name,
                                       SDVariable iX)

Parameters:: iX -
Returns:

isNumericTensor

public SDVariable isNumericTensor(SDVariable iX)

Parameters:: -
Returns:

isNumericTensor

public SDVariable isNumericTensor(String name,
                                  SDVariable iX)

Parameters:: -
Returns:

cos

public SDVariable cos(String name,
                      SDVariable iX)

Parameters:: iX -
Returns:

sin

public SDVariable sin(String name,
                      SDVariable iX)

Parameters:: iX -
Returns:

tan

public SDVariable tan(String name,
                      SDVariable iX)

Parameters:: iX -
Returns:

acos

public SDVariable acos(String name,
                       SDVariable iX)

Parameters:: iX -
Returns:

asin

public SDVariable asin(String name,
                       SDVariable iX)

Parameters:: iX -
Returns:

atan

public SDVariable atan(String name,
                       SDVariable iX)

Parameters:: iX -
Returns:

cosh

public SDVariable cosh(String name,
                       SDVariable iX)

Parameters:: iX -
Returns:

sinh

public SDVariable sinh(String name,
                       SDVariable iX)

Parameters:: iX -
Returns:

tanh

public SDVariable tanh(String name,
                       SDVariable iX)

Parameters:: iX -
Returns:

acosh

public SDVariable acosh(String name,
                        SDVariable iX)

Parameters:: iX -
Returns:

asinh

public SDVariable asinh(String name,
                        SDVariable iX)

Parameters:: iX -
Returns:

atanh

public SDVariable atanh(String name,
                        SDVariable iX)

Parameters:: iX -
Returns:

exp

public SDVariable exp(String name,
                      SDVariable iX)

Parameters:: iX -
Returns:

expm1

public SDVariable expm1(String name,
                        SDVariable iX)

Parameters:: iX -
Returns:

rsqrt

public SDVariable rsqrt(String name,
                        SDVariable iX)

Parameters:: iX -
Returns:

log

public SDVariable log(String name,
                      SDVariable iX)

Parameters:: iX -
Returns:

log1p

public SDVariable log1p(String name,
                        SDVariable iX)

Parameters:: iX -
Returns:

isFinite

public SDVariable isFinite(String name,
                           SDVariable iX)

Parameters:: iX -
Returns:

isInfinite

public SDVariable isInfinite(String name,
                             SDVariable iX)

Parameters:: iX -
Returns:

isNaN

public SDVariable isNaN(String name,
                        SDVariable iX)

Parameters:: iX -
Returns:

round

public SDVariable round(String name,
                        SDVariable iX)

Parameters:: iX -
Returns:

pow

public SDVariable pow(String name,
                      SDVariable iX,
                      double value)

Parameters:: iX -; value -
Returns:

cube

public SDVariable cube(String name,
                       SDVariable iX)

Parameters:: iX -
Returns:

sqrt

public SDVariable sqrt(String name,
                       SDVariable iX)

Parameters:: iX -
Returns:

square

public SDVariable square(String name,
                         SDVariable iX)

Parameters:: iX -
Returns:

floor

public SDVariable floor(String name,
                        SDVariable iX)

Parameters:: iX -
Returns:

relu

public SDVariable relu(String name,
                       SDVariable iX,
                       double cutoff)

Parameters:: iX -
Returns:

relu6

public SDVariable relu6(String name,
                        SDVariable iX,
                        double cutoff)

Parameters:: iX -
Returns:

softmax

public SDVariable softmax(String name,
                          SDVariable iX)

Parameters:: iX -
Returns:

softmaxDerivative

public SDVariable softmaxDerivative(String name,
                                    SDVariable iX,
                                    SDVariable wrt)

Parameters:: iX -
Returns:

hardTanh

public SDVariable hardTanh(String name,
                           SDVariable iX)

Parameters:: iX -
Returns:

hardTanhDerivative

public SDVariable hardTanhDerivative(String name,
                                     SDVariable iX)

Parameters:: iX -
Returns:

sigmoid

public SDVariable sigmoid(String name,
                          SDVariable iX)

Parameters:: iX -
Returns:

sigmoidDerivative

public SDVariable sigmoidDerivative(String name,
                                    SDVariable iX,
                                    SDVariable wrt)

Parameters:: iX -
Returns:

sign

public SDVariable sign(String name,
                       SDVariable iX)

Parameters:: iX -
Returns:

softsign

public SDVariable softsign(String name,
                           SDVariable iX)

Parameters:: iX -
Returns:

softsignDerivative

public SDVariable softsignDerivative(String name,
                                     SDVariable iX)

Parameters:: iX -
Returns:

softplus

public SDVariable softplus(String name,
                           SDVariable iX)

Parameters:: iX -
Returns:

elu

public SDVariable elu(String name,
                      SDVariable iX)

Parameters:: iX -
Returns:

eluDerivative

public SDVariable eluDerivative(String name,
                                SDVariable iX)

Parameters:: iX -
Returns:

leakyRelu

public SDVariable leakyRelu(String name,
                            SDVariable iX,
                            double alpha)

Parameters:: iX -; alpha -
Returns:

leakyReluDerivative

public SDVariable leakyReluDerivative(String name,
                                      SDVariable iX,
                                      double alpha)

Parameters:: iX -; alpha -
Returns:

mean

public SDVariable mean(String name,
                       SDVariable iX)

Parameters:: iX -
Returns:

mean

public SDVariable mean(String name,
                       SDVariable iX,
                       int... dimension)

standardDeviation

public SDVariable standardDeviation(String name,
                                    SDVariable iX,
                                    boolean biasCorrected,
                                    int... dimensions)

Parameters:: iX -; biasCorrected -; dimensions -
Returns:

variance

public SDVariable variance(String name,
                           SDVariable iX,
                           boolean biasCorrected,
                           int... dimensions)

Parameters:: iX -; biasCorrected -; dimensions -
Returns:

sum

public SDVariable sum(String name,
                      SDVariable iX,
                      int... dimensions)

Parameters:: iX -; dimensions -
Returns:

prod

public SDVariable prod(String name,
                       SDVariable iX,
                       int... dimensions)

Parameters:: iX -; dimensions -
Returns:

max

public SDVariable max(String name,
                      SDVariable iX,
                      int... dimensions)

Parameters:: iX -; dimensions -
Returns:

min

public SDVariable min(String name,
                      SDVariable iX,
                      int... dimensions)

Parameters:: iX -; dimensions -
Returns:

norm1

public SDVariable norm1(String name,
                        SDVariable ix,
                        int... dimensions)

norm2

public SDVariable norm2(String name,
                        SDVariable ix,
                        int... dimensions)

normmax

public SDVariable normmax(String name,
                          SDVariable ix,
                          int... dimensions)

reshape

public SDVariable reshape(String name,
                          SDVariable iX,
                          int... shape)

Parameters:: iX -; shape -
Returns:

transpose

public SDVariable transpose(String name,
                            SDVariable iX)

Parameters:: iX -
Returns:

permute

public SDVariable permute(String name,
                          SDVariable iX,
                          int... dimensions)

Parameters:: iX -; dimensions -
Returns:

rollAxis

public SDVariable rollAxis(String name,
                           SDVariable x,
                           int axis)

Parameters:: x -; axis -
Returns:

fill

public SDVariable fill(String name,
                       SDVariable shape,
                       double value)

Parameters:: shape -; value -
Returns:

concat

public SDVariable concat(String name,
                         int dimension,
                         SDVariable... inputs)

Parameters:: dimension -; inputs -
Returns:

tile

public SDVariable tile(String name,
                       SDVariable iX,
                       int[] repeat)

Parameters:: iX -; repeat -
Returns:

mmul

public SDVariable mmul(String name,
                       SDVariable x,
                       SDVariable y,
                       MMulTranspose transpose)

Parameters:: x -; y -; transpose -
Returns:

mmul

public SDVariable mmul(String name,
                       SDVariable x,
                       SDVariable y)

Parameters:: x -; y -
Returns:

tensorMmul

public SDVariable tensorMmul(String name,
                             SDVariable x,
                             SDVariable y,
                             int[][] dimensions)

Parameters:: x -; y -; dimensions -
Returns:

cosineSimilarity

public SDVariable cosineSimilarity(String name,
                                   SDVariable iX,
                                   SDVariable i_y,
                                   int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

euclideanDistance

public SDVariable euclideanDistance(String name,
                                    SDVariable iX,
                                    SDVariable i_y,
                                    int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

manhattanDistance

public SDVariable manhattanDistance(String name,
                                    SDVariable iX,
                                    SDVariable i_y,
                                    int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

sigmoidCrossEntropyWithLogits

public SDVariable sigmoidCrossEntropyWithLogits(SDVariable logits,
                                                SDVariable weights,
                                                SDVariable labels,
                                                int reductionMode,
                                                double labelSmoothing)

sigmoidCrossEntropyWithLogits

public SDVariable sigmoidCrossEntropyWithLogits(String name,
                                                SDVariable logits,
                                                SDVariable weights,
                                                SDVariable labels,
                                                int reductionMode,
                                                double labelSmoothing)

softmaxCrossEntropyWithLogits

public SDVariable softmaxCrossEntropyWithLogits(SDVariable logits,
                                                SDVariable weights,
                                                SDVariable labels,
                                                int reductionMode,
                                                double labelSmoothing)

softmaxCrossEntropyWithLogits

public SDVariable softmaxCrossEntropyWithLogits(String name,
                                                SDVariable logits,
                                                SDVariable weights,
                                                SDVariable labels,
                                                int reductionMode,
                                                double labelSmoothing)

weightedCrossEntropyWithLogits

public SDVariable weightedCrossEntropyWithLogits(SDVariable targets,
                                                 SDVariable inputs,
                                                 SDVariable weights)

weightedCrossEntropyWithLogits

public SDVariable weightedCrossEntropyWithLogits(String name,
                                                 SDVariable targets,
                                                 SDVariable inputs,
                                                 SDVariable weights)

lossBinaryXENT

public SDVariable lossBinaryXENT(String name,
                                 SDVariable iX,
                                 SDVariable i_y,
                                 int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossCosineSimilarity

public SDVariable lossCosineSimilarity(String name,
                                       SDVariable iX,
                                       SDVariable i_y,
                                       int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossHinge

public SDVariable lossHinge(String name,
                            SDVariable iX,
                            SDVariable i_y,
                            int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossKLD

public SDVariable lossKLD(String name,
                          SDVariable iX,
                          SDVariable i_y,
                          int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossL1

public SDVariable lossL1(String name,
                         SDVariable iX,
                         SDVariable i_y,
                         int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossL2

public SDVariable lossL2(String name,
                         SDVariable iX,
                         SDVariable i_y,
                         int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossMAE

public SDVariable lossMAE(String name,
                          SDVariable iX,
                          SDVariable i_y,
                          int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossMSE

public SDVariable lossMSE(String name,
                          SDVariable iX,
                          SDVariable i_y,
                          int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossMCXENT

public SDVariable lossMCXENT(String name,
                             SDVariable iX,
                             SDVariable i_y,
                             int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossMSLE

public SDVariable lossMSLE(String name,
                           SDVariable iX,
                           SDVariable i_y,
                           int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossNegativeLogLikelihood

public SDVariable lossNegativeLogLikelihood(String name,
                                            SDVariable iX,
                                            SDVariable i_y,
                                            int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossPoisson

public SDVariable lossPoisson(String name,
                              SDVariable iX,
                              SDVariable i_y,
                              int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

lossSquaredHinge

public SDVariable lossSquaredHinge(String name,
                                   SDVariable iX,
                                   SDVariable i_y,
                                   int... dimensions)

Parameters:: iX -; i_y -; dimensions -
Returns:

expandDims

public SDVariable expandDims(SDVariable ix,
                             int axis)

expandDims

public SDVariable expandDims(String name,
                             SDVariable ix,
                             int axis)

squeeze

public SDVariable squeeze(SDVariable ix,
                          int axis)

squeeze

public SDVariable squeeze(String name,
                          SDVariable ix,
                          int axis)

confusionMatrix

public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable predictions)

confusionMatrix

public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred)

confusionMatrix

public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses)

confusionMatrix

public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses)

confusionMatrix

public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable pred,
                                  SDVariable weights)

confusionMatrix

public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred,
                                  SDVariable weights)

confusionMatrix

public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses,
                                  SDVariable weights)

confusionMatrix

public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses,
                                  SDVariable weights)

addVariable

public void addVariable(SDVariable variable)

Parameters:: variable -

generateNewVarName
```
public String generateNewVarName(String baseName,
                                 int argIndex)
```
Generate a new variable name based on the uniqueness of thebase name and arg index

Parameters:

baseName - the base name to use (use function.opName() where function is a DifferentialFunction

argIndex - the arg index

Returns:

the new generated name

lstm

public SDVariable lstm(String baseName,
                       LSTMCellConfiguration configuration)

LSTM unit

Parameters:: baseName - the base name for outputs; configuration - the configuration to use
Returns:

sruCell
```
public SDVariable sruCell(SRUCellConfiguration configuration)
```
An sru cell

Parameters:

configuration - the configuration for the sru cell

Returns:

sru
```
public SDVariable sru(SRUConfiguration configuration)
```
Simple recurrent unit

Parameters:

configuration - the configuration for the sru

Returns:

gru
```
public SDVariable gru(GRUCellConfiguration configuration)
```
The gru cell

Parameters:

configuration - teh configuration to use

Returns:

sruCell

public SDVariable sruCell(String baseName,
                          SRUCellConfiguration configuration)

An sru cell

Parameters:: baseName - the base name to use for the output variables; configuration - the configuration for the sru cell
Returns:

sru
```
public SDVariable sru(String baseName,
                      SRUConfiguration configuration)
```
Simiple recurrent unit

Parameters:

baseName - the base name to use for output variables

configuration - the configuration for the sru

Returns:

gru

public SDVariable gru(String baseName,
                      GRUCellConfiguration configuration)

The gru cell

Parameters:: baseName - the base name for the gru cell; configuration - teh configuration to use
Returns:

slice

public SDVariable slice(SDVariable input,
                        int[] begin,
                        int[] size)

slice

public SDVariable slice(String name,
                        SDVariable input,
                        int[] begin,
                        int[] size)

stridedSlice

public SDVariable stridedSlice(SDVariable input,
                               int[] begin,
                               int[] end,
                               int[] strides)

stridedSlice

public SDVariable stridedSlice(String name,
                               SDVariable input,
                               int[] begin,
                               int[] end,
                               int[] strides)

stridedSlice

public SDVariable stridedSlice(SDVariable in,
                               int[] begin,
                               int[] end,
                               int[] strides,
                               int beginMask,
                               int endMask,
                               int ellipsisMask,
                               int newAxisMask,
                               int shrinkAxisMask)

stridedSlice

public SDVariable stridedSlice(String name,
                               SDVariable in,
                               int[] begin,
                               int[] end,
                               int[] strides,
                               int beginMask,
                               int endMask,
                               int ellipsisMask,
                               int newAxisMask,
                               int shrinkAxisMask)

scatterAdd

public SDVariable scatterAdd(String name,
                             SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)

scatterMul

public SDVariable scatterMul(String name,
                             SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)

scatterSub

public SDVariable scatterSub(String name,
                             SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)

scatterDiv

public SDVariable scatterDiv(String name,
                             SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)

scatterAdd

public SDVariable scatterAdd(SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)

scatterMul

public SDVariable scatterMul(SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)

scatterSub

public SDVariable scatterSub(SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)

scatterDiv

public SDVariable scatterDiv(SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)

generateOutputVariableForOp
```
public SDVariable[] generateOutputVariableForOp(DifferentialFunction function,
                                                String baseName)
```
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 function instance given the opName

Parameters:

functionName - the opName of the function

Returns:

the same diff function instance defined for the given opName

execAndEndResult

public INDArray execAndEndResult(List<DifferentialFunction> ops)

Returns:

execAndEndResult
```
public INDArray execAndEndResult()
```
Returns:

yetAnotherExecMethod

public INDArray yetAnotherExecMethod(@NonNull
                                     Map<String,INDArray> inputs)

exec
```
public List<DifferentialFunction> exec(List<DifferentialFunction> ops)
```
Executes the list of operations. This exec method is for only invoking operations rather than creating them

Parameters:

ops - the list of already created ops

Returns:

the passes in list

whileStatement

public While whileStatement(SameDiff.SameDiffConditional sameDiffConditional,
                            SameDiff.SameDiffFunctionDefinition conditionBody,
                            SameDiff.SameDiffFunctionDefinition loopBody,
                            SDVariable[] inputVars)

Creates a while statement

Parameters:: sameDiffConditional -; loopBody -
Returns:

ifStatement

public If ifStatement(SameDiff.SameDiffConditional conditional,
                      SameDiff.SameDiffFunctionDefinition conditionBody,
                      SameDiff.SameDiffFunctionDefinition trueBody,
                      SameDiff.SameDiffFunctionDefinition falseBody,
                      SDVariable[] inputVars)

Parameters:: conditional -; trueBody -; falseBody -
Returns:

invokeFunctionOn

public SDVariable invokeFunctionOn(String functionName,
                                   SameDiff with)

Parameters:: functionName -; with -

defineFunction

public SameDiff defineFunction(String function,
                               SameDiff.SameDiffFunctionDefinition functionDefinition,
                               SDVariable[] variables)

Parameters:: function -

defineFunction

public void defineFunction(String function,
                           SameDiff.SameDiffFunctionDefinition functionDefinition)

Parameters:: function -

defineFunction

public void defineFunction(String function,
                           SameDiff.SameDiffFunctionDefinition functionDefinition,
                           Map<String,INDArray> inputs)

Parameters:: function -; functionDefinition -; inputs -

execAndEndResult
```
public INDArray execAndEndResult(String functionName)
```
Exec a given function

Parameters:

functionName - the opName of the function to invoke

Returns:

exec

public org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>> exec(String functionName)

Exec a given function

Parameters:: functionName - the opName of the function to invoke
Returns:

exec

public List<DifferentialFunction> exec(String functionName,
                                       List<DifferentialFunction> cachedOps)

Exec the given function given the ops

Parameters:: functionName - the opName of the function to exec; cachedOps - the cached operations
Returns:

execBackwards

public org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>> execBackwards()

Builds a backwards graph and executes the operations on that graph.

Returns:

execBackwardAndEndResult
```
public INDArray execBackwardAndEndResult()
```
Exec a backwards operation and return the end result

Returns:

execWithPlaceHolderAndEndResult

public INDArray execWithPlaceHolderAndEndResult(Map<String,INDArray> inputs)

Creates and executes a list of operations

Returns:

setOriginalPlaceHolderShape
```
public void setOriginalPlaceHolderShape(String variableName,
                                        int[] 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.
A vertex id must be added first. You can do this with addAsPlaceHolder(String)

Parameters:

variableName - the vertex id for the original shape

shape - the shape of the place holder

getOriginalShapeForPlaceHolder
```
public int[] getOriginalShapeForPlaceHolder(String varName)
```
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 execWithPlaceHolder(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

Parameters:

varName - the vertex id to test

Returns:

addAsPlaceHolder
```
public void addAsPlaceHolder(String varName)
```
Add this vertex id as a place holder

Parameters:

varName - the vertex id to add

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.

allPlaceHolderVariablesResolved
```
public boolean allPlaceHolderVariablesResolved()
```
Returns true if all place holder variables are resolved. A place holder variable is resolved when getVariable(String) getArr() does not return null and the shape is properly resolved.

Returns:

true if all place holder variables are resolved.

putPlaceHolderForVariable
```
public void putPlaceHolderForVariable(String varName,
                                      String... placeHolderVariables)
```
Add one or or more place holder variables for the given vertex id.
Note that if a vertex id in placeHolderVariables isn't present in this samediff instance anyways, an ND4JIllegalStateException is thrown

Parameters:

varName - the vertex id to add place holders for

placeHolderVariables - the place holder variables

hasPlaceHolderVariables
```
public boolean hasPlaceHolderVariables(String vertexId)
```
Returns true if the given vertex id has any placeholder variables

Parameters:

vertexId - the vertex id to check for

Returns:

true if this vertex has any place holder variables or not

getPlaceHoldersFor
```
public List<String[]> getPlaceHoldersFor(String varName)
```
Get the place holders for a given vertex id. May return null.
Consider using hasPlaceHolderVariables(String)

Parameters:

varName - the vertex id to get the place holders for

Returns:

the place holder variables for the given vertex id or null

execWithPlaceHolder

public org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>> execWithPlaceHolder(Map<String,INDArray> inputs)

Creates and executes a list of operations based on the given variables passed in. resolveVariablesWith(Map) is called

Returns:

getVariablesAssociatedWithFunctions
```
public List<SDVariable> getVariablesAssociatedWithFunctions(List<DifferentialFunction> functions)
```
Get the SDVariable associated with each function based on the DifferentialFunction.outputVariables() ()}

Parameters:

functions - the functions to get the variables for

Returns:

the list of variables associated with the given DifferentialFunction

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.

Parameters:

varToUpdate - the variable to update

newVarName - the new variable name

Returns:

the passed in variable

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.

Parameters:

variablesToUpdate - the variable to update

newVariableNames - the new variable name

Returns:

the updated, passed in variables

exec

public org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>> exec()

Creates and executes a list of operations

Returns:

printFunction
```
public void printFunction(DifferentialFunction differentialFunction)
```
Print the given function for debugging (will not print functions)

Parameters:

differentialFunction - the function to print

permuteDataFormatForSameDiff
```
public static int[] permuteDataFormatForSameDiff(String dataFormat,
                                                 boolean weights)
```
Permute indices for the samediff/dl4j format. Due to the dl4j format being NCHW, this is a simple routine for returning permute indices. This is typically used for model import.

Parameters:

dataFormat - the data format to permute

Returns:

the permuted indices

updateVariable
```
public void updateVariable(String variableName,
                           INDArray arr)
```
Update the INDArray ndarray for the given variable name

Parameters:

variableName - the variable to update

arr - the array to update with

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)
```
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:

asFlatNode

protected int asFlatNode(@NonNull
                         DifferentialFunction node,
                         @NonNull
                         com.google.flatbuffers.FlatBufferBuilder bufferBuilder,
                         List<SDVariable> variables,
                         Map<String,Integer> reverseMap,
                         Map<String,Integer> forwardMap,
                         Map<String,Integer> framesMap,
                         AtomicInteger idCounter)

asFlatBuffers
```
public ByteBuffer asFlatBuffers(@NonNull
                                ExecutorConfiguration configuration)
```
This method exports given SameDiff instance into FlatBuffers

Parameters:

configuration - - ExecutorConfiguration to be embedded into serialized graph

Returns:

asFlatBuffers
```
public ByteBuffer asFlatBuffers()
```
This method exports given SameDiff instance into FlatBuffers

Returns:

getOrderFromByte
```
public static ByteOrder getOrderFromByte(byte val)
```
This method just converts enums

Parameters:

val -

Returns:

getOrderAsByte
```
public static byte getOrderAsByte()
```
This method returns current byte order for this JVM as libnd4j enum

Returns:

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

Parameters:

file -

Throws:

IOException

asFlatFile

public void asFlatFile(@NonNull
                       File file,
                       @NonNull
                       ExecutorConfiguration configuration)
                throws IOException

This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later

Parameters:: file -
Throws:: IOException

asFlatPrint
```
public String asFlatPrint()
```
This method returns "flattened" graph.

Returns:

getDataTypeFromByte
```
public static DataBuffer.Type getDataTypeFromByte(byte val)
```
This method converts enums for DataType

Parameters:

val -

Returns:

getDataTypeAsByte
```
public static byte getDataTypeAsByte(DataBuffer.Type type)
```
This method converts enums for DataType

Parameters:

type -

Returns:

getOpNum

public static long getOpNum(String name,
                            Op.Type type)

This method return operation ID for given op name/type pair.

Parameters:: name -; type -
Returns:

getTypeFromByte
```
public static Op.Type getTypeFromByte(byte type)
```
This method converts enums for DataType

Parameters:

type -

Returns:

getFlatOpType
```
public static byte getFlatOpType(Op.Type type)
```
This method converts enums for DataType

Parameters:

type -

Returns:

Class SameDiff

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

newCloner

updateVariableName

disableDebugging

enableDebugMode

f

invokeGraphOn

functionExists

getFunctionById

putFunctionForId

getInputsForFunction

getOutputsForFunction

getOutputVariablesForFunction

getInputVariablesForFunction

updateArrayForVarName

putArrayForVarName

getShapeForVarName

updateShapeForVarName

putShapeForVarName

shapeAlreadyExistsForVarName

arrayAlreadyExistsForVarName

getArrForVarName

associateArrayWithVariable

putSubFunction

variableMap

invoke

getVariableForArray

definedFunctionNames

memoryForGraph

invoke

addPropertyToResolve

propertiesToResolveForFunction

hasPropertiesToResolve

getPropertyForFunction

addPropertyForFunction

addPropertyForFunction

addVariableMappingForField

getVarNameForFieldAndFunction

isImportVariable

addVarNameForImport

setBaseNameForFunctionInstanceId

getBaseNameForFunction

setupFunction

addOutgoingFor

addOutgoingFor

addArgsFor

addArgsFor

hasArgs

hasArgs

functions

hashCode

create

equals

create

eval

dup

numElements

variables

one

onesLike

onesLike

zero

zerosLike

zerosLike

var

var

var

removeArgFromFunction

var

getVariable

getGradForVariable

setGradientForVariableName

getForwardVariableForVertexId

setForwardVariableForVarName

grad

avgPooling2d