Uses of Class
org.nd4j.autodiff.samediff.SDVariable

Packages that use SDVariable

Package	Description
org.nd4j.autodiff.execution
org.nd4j.autodiff.functions
org.nd4j.autodiff.loss
org.nd4j.autodiff.samediff
org.nd4j.autodiff.samediff.impl
org.nd4j.autodiff.validation
org.nd4j.linalg.activations
org.nd4j.linalg.api.ops
org.nd4j.linalg.api.ops.impl.accum
org.nd4j.linalg.api.ops.impl.accum.bp
org.nd4j.linalg.api.ops.impl.accum.distances
org.nd4j.linalg.api.ops.impl.broadcast
org.nd4j.linalg.api.ops.impl.controlflow
org.nd4j.linalg.api.ops.impl.controlflow.compat
org.nd4j.linalg.api.ops.impl.grid
org.nd4j.linalg.api.ops.impl.indexaccum
org.nd4j.linalg.api.ops.impl.layers
org.nd4j.linalg.api.ops.impl.layers.convolution
org.nd4j.linalg.api.ops.impl.layers.recurrent.config
org.nd4j.linalg.api.ops.impl.loss
org.nd4j.linalg.api.ops.impl.meta
org.nd4j.linalg.api.ops.impl.scalar
org.nd4j.linalg.api.ops.impl.scalar.comparison
org.nd4j.linalg.api.ops.impl.scatter
org.nd4j.linalg.api.ops.impl.shape
org.nd4j.linalg.api.ops.impl.shape.bp
org.nd4j.linalg.api.ops.impl.shape.tensorops
org.nd4j.linalg.api.ops.impl.transforms
org.nd4j.linalg.api.ops.impl.transforms.arithmetic
org.nd4j.linalg.api.ops.impl.transforms.arithmetic.bp
org.nd4j.linalg.api.ops.impl.transforms.clip
org.nd4j.linalg.api.ops.impl.transforms.comparison
org.nd4j.linalg.api.ops.impl.transforms.dtype
org.nd4j.linalg.api.ops.impl.transforms.gradient
org.nd4j.linalg.api.ops.impl.transforms.segment
org.nd4j.linalg.api.ops.impl.transforms.temp
org.nd4j.linalg.api.ops.random
org.nd4j.linalg.api.ops.random.compat
org.nd4j.linalg.api.ops.random.custom
org.nd4j.linalg.api.ops.random.impl
org.nd4j.linalg.lossfunctions.impl

Uses of SDVariable in org.nd4j.autodiff.execution

Methods in org.nd4j.autodiff.execution with parameters of type SDVariable

Modifier and Type	Method and Description
INDArray[]	GraphExecutioner.executeGraph(int id, SDVariable... variables) This method executes
INDArray[]	BasicGraphExecutioner.executeGraph(int id, SDVariable... variables) This method executes

Uses of SDVariable in org.nd4j.autodiff.functions

Methods in org.nd4j.autodiff.functions that return SDVariable

Modifier and Type	Method and Description
SDVariable	DifferentialFunctionFactory.abs(SDVariable iX)
SDVariable	DifferentialFunctionFactory.acos(SDVariable iX)
SDVariable	DifferentialFunctionFactory.acosh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.add(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.add(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.addi(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.addi(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.all(SDVariable input, int... dimensions)
SDVariable	DifferentialFunctionFactory.amax(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.amean(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.amin(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.and(SDVariable ix, SDVariable iy)
SDVariable	DifferentialFunctionFactory.any(SDVariable input, int... dimensions)
SDVariable	DifferentialFunction.arg() Return the first argument
SDVariable	DifferentialFunction.arg(int num) Return the specified argument for this function
SDVariable	DifferentialFunctionFactory.argmax(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.argmin(SDVariable in, boolean keepDims, int... dimensions)
SDVariable[]	DifferentialFunction.args() Return the arguments for a given function
SDVariable	DifferentialFunctionFactory.asin(SDVariable iX)
SDVariable	DifferentialFunctionFactory.asinh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.assign(SDVariable x, Number num)
SDVariable	DifferentialFunctionFactory.assign(SDVariable x, SDVariable y)
SDVariable	DifferentialFunctionFactory.asum(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.atan(SDVariable iX)
SDVariable	DifferentialFunctionFactory.atan2(SDVariable y, SDVariable x)
SDVariable	DifferentialFunctionFactory.atanh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.avgPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig) Average pooling 2d operation.
SDVariable	DifferentialFunctionFactory.avgPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig) Avg pooling 3d operation.
SDVariable[]	DifferentialFunctionFactory.batchMmul(SDVariable[] matrices, boolean transposeA, boolean transposeB)
SDVariable[]	DifferentialFunctionFactory.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB)
SDVariable[]	DifferentialFunctionFactory.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB)
SDVariable	DifferentialFunctionFactory.batchNorm(SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon) Batch norm operation.
SDVariable	DifferentialFunctionFactory.batchToSpace(SDVariable differentialFunction, int[] blocks, int[][] crops)
SDVariable	DifferentialFunctionFactory.biasAdd(SDVariable input, SDVariable bias)
SDVariable[]	DifferentialFunctionFactory.biasAddBp(SDVariable input, SDVariable bias, SDVariable grad)
SDVariable	DifferentialFunctionFactory.broadcast(SDVariable iX, int... shape)
SDVariable	DifferentialFunctionFactory.broadcast(SDVariable iX, long... shape)
SDVariable	DifferentialFunctionFactory.ceil(SDVariable x)
SDVariable	DifferentialFunctionFactory.clipByNorm(SDVariable x, double clipValue)
SDVariable	DifferentialFunctionFactory.clipByNorm(SDVariable x, double clipValue, int... dimensions)
SDVariable	DifferentialFunctionFactory.clipByValue(SDVariable x, double clipValueMin, double clipValueMax)
SDVariable	DifferentialFunctionFactory.col2Im(SDVariable input, Conv2DConfig config)
SDVariable	DifferentialFunctionFactory.concat(int dimension, SDVariable... inputs)
SDVariable	DifferentialFunctionFactory.confusionMatrix(SDVariable labels, SDVariable pred)
SDVariable	DifferentialFunctionFactory.confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses)
SDVariable	DifferentialFunctionFactory.confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)
SDVariable	DifferentialFunctionFactory.confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights)
SDVariable	DifferentialFunctionFactory.constant(SDVariable input, long... shape)
SDVariable	DifferentialFunctionFactory.conv1d(SDVariable input, SDVariable weights, Conv1DConfig conv1DConfig) Conv1d operation.
SDVariable	DifferentialFunctionFactory.conv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig) Conv2d operation.
SDVariable	DifferentialFunctionFactory.conv3d(SDVariable[] inputs, Conv3DConfig conv3DConfig) Conv3d operation.
SDVariable	DifferentialFunctionFactory.cos(SDVariable iX)
SDVariable	DifferentialFunctionFactory.cosh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.cosineDistance(SDVariable ix, SDVariable iy, int... dimensions)
SDVariable	DifferentialFunctionFactory.cosineSimilarity(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.countNonZero(SDVariable input, int... dimensions)
SDVariable	DifferentialFunctionFactory.countZero(SDVariable input, int... dimensions)
SDVariable	DifferentialFunctionFactory.cross(SDVariable a, SDVariable b)
SDVariable	DifferentialFunctionFactory.cube(SDVariable iX)
SDVariable	DifferentialFunctionFactory.cubeDerivative(SDVariable iX)
SDVariable	DifferentialFunctionFactory.cumprod(SDVariable in, boolean exclusive, boolean reverse, int... axis)
SDVariable	DifferentialFunctionFactory.cumprodBp(SDVariable in, SDVariable grad, boolean exclusive, boolean reverse, int... axis)
SDVariable	DifferentialFunctionFactory.cumsum(SDVariable in, boolean exclusive, boolean reverse, int... axis)
SDVariable	DifferentialFunctionFactory.cumsumBp(SDVariable in, SDVariable grad, boolean exclusive, boolean reverse, int... axis)
SDVariable	DifferentialFunctionFactory.deconv2d(SDVariable[] inputs, DeConv2DConfig deconv2DConfig) Deconv2d operation.
SDVariable	DifferentialFunctionFactory.depthToSpace(SDVariable differentialFunction, int blocksSize, String dataFormat)
SDVariable	DifferentialFunctionFactory.depthWiseConv2d(SDVariable[] inputs, Conv2DConfig depthConv2DConfig) Depth-wise Conv2d operation.
SDVariable	DifferentialFunctionFactory.diag(SDVariable sdVariable)
SDVariable	DifferentialFunctionFactory.diagPart(SDVariable sdVariable)
SDVariable	DifferentialFunctionFactory.dilation2D(SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)
SDVariable	DifferentialFunctionFactory.div(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.div(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.divi(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.divi(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.doRepeat(SDVariable func, SDVariable input)
SDVariable	DifferentialFunctionFactory.dot(SDVariable x, SDVariable y, int... dimensions)
SDVariable[]	DifferentialFunctionFactory.dotBp(SDVariable in1, SDVariable in2, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.dropout(SDVariable input, double p)
SDVariable[]	DifferentialFunctionFactory.dynamicPartition(SDVariable differentialFunction, SDVariable partitions, int numPartitions)
SDVariable	DifferentialFunctionFactory.dynamicStitch(SDVariable[] indices, SDVariable[] differentialFunctions)
SDVariable	DifferentialFunctionFactory.elu(SDVariable iX)
SDVariable	DifferentialFunctionFactory.eluDerivative(SDVariable iX)
SDVariable	DifferentialFunctionFactory.entropy(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.eq(SDVariable iX, double i_y)
SDVariable	DifferentialFunctionFactory.eq(SDVariable iX, SDVariable i_y)
SDVariable	DifferentialFunctionFactory.eqi(SDVariable iX, double i_y)
SDVariable	DifferentialFunctionFactory.erf(SDVariable differentialFunction)
SDVariable	DifferentialFunctionFactory.erfc(SDVariable differentialFunction)
SDVariable	DifferentialFunctionFactory.euclideanDistance(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.exp(SDVariable iX)
SDVariable	DifferentialFunctionFactory.expandDims(SDVariable iX, int axis)
SDVariable	DifferentialFunctionFactory.expm1(SDVariable iX)
SDVariable	DifferentialFunctionFactory.fill(SDVariable shape, double value)
SDVariable	DifferentialFunctionFactory.firstIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.floor(SDVariable iX)
SDVariable	DifferentialFunctionFactory.floorDiv(SDVariable x, SDVariable y)
SDVariable	DifferentialFunctionFactory.floorMod(SDVariable x, SDVariable y)
SDVariable	DifferentialFunctionFactory.gather(SDVariable df, int[] indices, int axis)
SDVariable	DifferentialFunctionFactory.gather(SDVariable df, SDVariable indices, int axis)
SDVariable	DifferentialFunctionFactory.gatherNd(SDVariable df, SDVariable indices)
SDVariable	DifferentialFunctionFactory.gradientBackwardsMarker(SDVariable iX)
SDVariable	DifferentialFunctionFactory.gt(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.gt(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.gte(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.gte(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.gtei(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.gtei(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.gti(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.gti(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.hammingDistance(SDVariable ix, SDVariable iy, int... dimensions)
SDVariable	DifferentialFunctionFactory.hardSigmoid(SDVariable in)
SDVariable	DifferentialFunctionFactory.hardTanh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.hardTanhDerivative(SDVariable iX)
SDVariable	DifferentialFunctionFactory.iamax(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.iamin(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.identity(SDVariable input)
SDVariable	DifferentialFunctionFactory.im2Col(SDVariable input, Conv2DConfig config)
SDVariable	DifferentialFunctionFactory.im2ColBp(SDVariable im2colInput, SDVariable gradientAtOutput, Conv2DConfig config)
SDVariable	DifferentialFunctionFactory.invertPermutation(SDVariable input, boolean inPlace)
SDVariable	DifferentialFunctionFactory.invoke(String name, Object[] args)
SDVariable	DifferentialFunctionFactory.isFinite(SDVariable ix)
SDVariable	DifferentialFunctionFactory.isInfinite(SDVariable ix)
SDVariable	DifferentialFunctionFactory.isMax(SDVariable ix)
SDVariable	DifferentialFunctionFactory.isNaN(SDVariable ix)
SDVariable	DifferentialFunctionFactory.isNonDecreasing(SDVariable iX)
SDVariable	DifferentialFunctionFactory.isNumericTensor(SDVariable iX)
SDVariable	DifferentialFunctionFactory.isStrictlyIncreasing(SDVariable iX)
SDVariable	DifferentialFunctionFactory.jaccardDistance(SDVariable ix, SDVariable iy, int... dimensions)
SDVariable	DifferentialFunction.larg() The left argument for this function
SDVariable	DifferentialFunctionFactory.lastIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.leakyRelu(SDVariable iX, double alpha)
SDVariable	DifferentialFunctionFactory.leakyReluDerivative(SDVariable iX, double cutoff)
SDVariable	DifferentialFunctionFactory.linspace(double lower, double upper, long count)
SDVariable	DifferentialFunctionFactory.localResponseNormalization(SDVariable input, LocalResponseNormalizationConfig lrnConfig) Local response normalization operation.
SDVariable	DifferentialFunctionFactory.log(SDVariable iX)
SDVariable	DifferentialFunctionFactory.log(SDVariable in, double base)
SDVariable	DifferentialFunctionFactory.log1p(SDVariable iX)
SDVariable	DifferentialFunctionFactory.logEntropy(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.logSigmoid(SDVariable iX)
SDVariable	DifferentialFunctionFactory.logSigmoidDerivative(SDVariable iX, SDVariable wrt)
SDVariable	DifferentialFunctionFactory.logSoftmax(SDVariable i_v)
SDVariable	DifferentialFunctionFactory.logSoftmaxDerivative(SDVariable arg, SDVariable wrt)
SDVariable	DifferentialFunctionFactory.logSumExp(SDVariable arg, int... dimension)
SDVariable	DifferentialFunctionFactory.lossBinaryXENT(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossCosineSimilarity(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossHinge(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossKLD(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossL1(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossL2(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossMAE(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossMAPE(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossMCXENT(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossMSE(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossMSLE(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossNegativeLogLikelihood(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossPoisson(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossSquaredHinge(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lt(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.lt(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.lte(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.lte(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.ltei(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.lti(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.lti(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.ltOrEqi(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.manhattanDistance(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.matchCondition(SDVariable in, Condition condition) Returns a boolean mask of equal shape to the input, where the condition is satisfied
SDVariable	DifferentialFunctionFactory.matchConditionCount(SDVariable in, Condition condition, boolean keepDims, int... dimensions) Returns a count of the number of elements that satisfy the condition
SDVariable	DifferentialFunctionFactory.matrixDeterminant(SDVariable in)
SDVariable	DifferentialFunctionFactory.matrixInverse(SDVariable in)
SDVariable	DifferentialFunctionFactory.max(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.max(SDVariable first, SDVariable second)
SDVariable	DifferentialFunctionFactory.maxBp(SDVariable i_x, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.maxPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig) Max pooling 2d operation.
SDVariable	DifferentialFunctionFactory.maxPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig) Max pooling 3d operation.
SDVariable	DifferentialFunctionFactory.mean(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.meanBp(SDVariable in, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.mergeAdd(SDVariable... differentialFunctions)
SDVariable	DifferentialFunctionFactory.mergeAvg(SDVariable... differentialFunctions)
SDVariable	DifferentialFunctionFactory.mergeMax(SDVariable... differentialFunctions)
SDVariable[]	DifferentialFunctionFactory.meshgrid(boolean cartesian, SDVariable... inputs)
SDVariable	DifferentialFunctionFactory.min(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.min(SDVariable first, SDVariable second)
SDVariable	DifferentialFunctionFactory.minBp(SDVariable i_x, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.mmul(SDVariable x, SDVariable y)
SDVariable	DifferentialFunctionFactory.mmul(SDVariable x, SDVariable y, MMulTranspose mMulTranspose)
SDVariable[]	DifferentialFunctionFactory.moments(SDVariable input, int... axes)
SDVariable	DifferentialFunctionFactory.mul(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.mul(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.muli(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.muli(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.neg(SDVariable iX)
SDVariable	DifferentialFunctionFactory.neq(SDVariable iX, double i_y)
SDVariable	DifferentialFunctionFactory.neq(SDVariable iX, SDVariable i_y)
SDVariable	DifferentialFunctionFactory.neqi(SDVariable iX, double i_y)
SDVariable	DifferentialFunctionFactory.neqi(SDVariable iX, SDVariable i_y)
SDVariable	DifferentialFunctionFactory.noop(SDVariable input)
SDVariable	DifferentialFunctionFactory.norm1(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.norm1Bp(SDVariable preReduceIn, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.norm2(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.norm2Bp(SDVariable preReduceIn, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable[]	DifferentialFunctionFactory.normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)
SDVariable	DifferentialFunctionFactory.normmax(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.normmaxBp(SDVariable preReduceIn, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.one(int[] shape)
SDVariable	DifferentialFunctionFactory.one(long[] shape)
SDVariable	DifferentialFunctionFactory.onehot(SDVariable indices, int depth)
SDVariable	DifferentialFunctionFactory.onehot(SDVariable indices, int depth, int axis, double on, double off)
SDVariable	DifferentialFunctionFactory.onesLike(String name, SDVariable input)
SDVariable	DifferentialFunctionFactory.or(SDVariable iX, SDVariable i_y)
SDVariable	DifferentialFunction.outputVariable()
SDVariable[]	DifferentialFunction.outputVariables() Return the output variables for this differential function.
abstract SDVariable[]	DifferentialFunction.outputVariables(String baseName) Return the output functions for this differential function.
SDVariable	DifferentialFunctionFactory.parallel_stack(SDVariable[] values)
SDVariable	DifferentialFunctionFactory.permute(SDVariable iX, int... dimensions)
SDVariable	DifferentialFunctionFactory.pooling3d(SDVariable input, Pooling3DConfig pooling3DConfig)
SDVariable	DifferentialFunctionFactory.pow(SDVariable iX, double i_y)
SDVariable	DifferentialFunctionFactory.powDerivative(SDVariable iX, double pow)
SDVariable	DifferentialFunctionFactory.prod(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.prodBp(SDVariable preReduceInput, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.randomBernoulli(double p, long... shape)
SDVariable	DifferentialFunctionFactory.randomBernoulli(double p, SDVariable shape)
SDVariable	DifferentialFunctionFactory.randomBinomial(int nTrials, double p, long... shape)
SDVariable	DifferentialFunctionFactory.randomExponential(double lambda, SDVariable shape) Exponential distribution: P(x) = lambda * exp(-lambda * x)
SDVariable	DifferentialFunctionFactory.randomLogNormal(double mean, double stdev, long... shape)
SDVariable	DifferentialFunctionFactory.randomNormal(double mean, double std, long... shape)
SDVariable	DifferentialFunctionFactory.randomNormal(double mean, double std, SDVariable shape)
SDVariable	DifferentialFunctionFactory.randomNormalTruncated(double mean, double stdev, long... shape)
SDVariable	DifferentialFunctionFactory.randomUniform(double min, double max, long... shape)
SDVariable	DifferentialFunctionFactory.randomUniform(double min, double max, SDVariable shape)
SDVariable	DifferentialFunctionFactory.range(double from, double to, double step)
SDVariable	DifferentialFunctionFactory.rank(SDVariable df)
SDVariable	DifferentialFunction.rarg() The right argument for this function.
SDVariable	DifferentialFunctionFactory.rdiv(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.rdiv(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.rdivi(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.rdivi(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.reciprocal(SDVariable a)
SDVariable	DifferentialFunctionFactory.reductionBroadcastableWithOrigShape(int origRank, int[] reduceDims, SDVariable toExpand) Add 1s as required to the array make an array possible to be broadcast with the original (pre-reduce) array.
SDVariable	DifferentialFunctionFactory.relu(SDVariable iX, double cutoff)
SDVariable	DifferentialFunctionFactory.relu6(SDVariable iX, double cutoff)
SDVariable	DifferentialFunctionFactory.relu6Derivative(SDVariable iX, SDVariable wrt, double cutoff)
SDVariable	DifferentialFunctionFactory.reluLayer(SDVariable input, SDVariable weights, SDVariable bias)
SDVariable	DifferentialFunctionFactory.repeat(SDVariable iX, int axis)
SDVariable	DifferentialFunctionFactory.replaceWhere(SDVariable to, Number set, Condition condition)
SDVariable	DifferentialFunctionFactory.replaceWhere(SDVariable to, SDVariable from, Condition condition)
SDVariable	DifferentialFunctionFactory.reshape(SDVariable iX, int[] shape)
SDVariable	DifferentialFunctionFactory.reshape(SDVariable iX, long[] shape)
SDVariable	DifferentialFunctionFactory.reshape(SDVariable iX, SDVariable shape)
SDVariable	DifferentialFunctionFactory.reverse(SDVariable x, int... dimensions)
SDVariable	DifferentialFunctionFactory.reverseSequence(SDVariable x, SDVariable seq_lengths)
SDVariable	DifferentialFunctionFactory.reverseSequence(SDVariable x, SDVariable seq_lengths, int seq_dim, int batch_dim)
SDVariable	DifferentialFunctionFactory.rollAxis(SDVariable iX, int axis)
SDVariable	DifferentialFunctionFactory.round(SDVariable ix)
SDVariable	DifferentialFunctionFactory.rsqrt(SDVariable iX)
SDVariable	DifferentialFunctionFactory.rsub(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.rsub(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.rsubi(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.rsubi(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.scalarFloorMod(SDVariable in, Number num)
SDVariable	DifferentialFunctionFactory.scalarMax(SDVariable in, Number num)
SDVariable	DifferentialFunctionFactory.scalarMin(SDVariable in, Number num)
SDVariable	DifferentialFunctionFactory.scalarSet(SDVariable in, Number num)
SDVariable	DifferentialFunctionFactory.scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterMax(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterMin(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterUpdate(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.sconv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig) Separable Conv2d operation.
SDVariable	DifferentialFunctionFactory.segmentMax(SDVariable data, SDVariable segmentIds)
SDVariable	DifferentialFunctionFactory.segmentMean(SDVariable data, SDVariable segmentIds)
SDVariable	DifferentialFunctionFactory.segmentMin(SDVariable data, SDVariable segmentIds)
SDVariable	DifferentialFunctionFactory.segmentProd(SDVariable data, SDVariable segmentIds)
SDVariable	DifferentialFunctionFactory.segmentSum(SDVariable data, SDVariable segmentIds)
SDVariable	DifferentialFunctionFactory.selu(SDVariable arg)
SDVariable	DifferentialFunctionFactory.seluDerivative(SDVariable arg)
SDVariable	DifferentialFunctionFactory.sequenceMask(SDVariable lengths)
SDVariable	DifferentialFunctionFactory.sequenceMask(SDVariable lengths, int maxLen)
SDVariable	DifferentialFunctionFactory.sequenceMask(SDVariable lengths, SDVariable maxLen)
SDVariable	DifferentialFunctionFactory.setDiag(SDVariable in, SDVariable diag)
SDVariable	DifferentialFunctionFactory.shannonEntropy(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.shape(SDVariable df)
SDVariable	DifferentialFunctionFactory.sigmoid(SDVariable iX)
SDVariable	DifferentialFunctionFactory.sigmoidCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)
SDVariable	DifferentialFunctionFactory.sigmoidDerivative(SDVariable iX, SDVariable wrt)
SDVariable	DifferentialFunctionFactory.sign(SDVariable iX)
SDVariable	DifferentialFunctionFactory.sin(SDVariable iX)
SDVariable	DifferentialFunctionFactory.sinh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.size(SDVariable in)
SDVariable	DifferentialFunctionFactory.sizeAt(SDVariable in, int dimension)
SDVariable	DifferentialFunctionFactory.slice(SDVariable input, int[] begin, int[] size)
SDVariable	DifferentialFunctionFactory.sliceBp(SDVariable input, SDVariable gradient, int[] begin, int[] size)
SDVariable	DifferentialFunctionFactory.softmax(SDVariable iX)
SDVariable	DifferentialFunctionFactory.softmaxCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)
SDVariable	DifferentialFunctionFactory.softmaxDerivative(SDVariable functionInput, SDVariable wrt, Integer dimension)
SDVariable	DifferentialFunctionFactory.softplus(SDVariable iX)
SDVariable	DifferentialFunctionFactory.softsign(SDVariable iX)
SDVariable	DifferentialFunctionFactory.softsignDerivative(SDVariable iX)
SDVariable	DifferentialFunctionFactory.spaceToBatch(SDVariable differentialFunction, int[] blocks, int[][] padding)
SDVariable	DifferentialFunctionFactory.spaceToDepth(SDVariable differentialFunction, int blocksSize, String dataFormat)
SDVariable	DifferentialFunctionFactory.sqrt(SDVariable iX)
SDVariable	DifferentialFunctionFactory.square(SDVariable iX)
SDVariable	DifferentialFunctionFactory.squaredDifference(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.squaredNorm(SDVariable input, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.squaredNormBp(SDVariable preReduceInput, SDVariable gradient, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.squeeze(SDVariable iX, int... axis)
SDVariable	DifferentialFunctionFactory.stack(SDVariable[] values, int axis)
SDVariable	DifferentialFunctionFactory.std(SDVariable i_x, boolean biasCorrected, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.stdBp(SDVariable stdInput, SDVariable gradient, boolean biasCorrected, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.step(SDVariable in, double cutoff)
SDVariable	DifferentialFunctionFactory.stridedSlice(SDVariable input, int[] begin, int[] end, int[] strides)
SDVariable	DifferentialFunctionFactory.stridedSlice(SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	DifferentialFunctionFactory.stridedSlice(SDVariable input, long[] begin, long[] end, long[] strides)
SDVariable	DifferentialFunctionFactory.stridedSlice(SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	DifferentialFunctionFactory.stridedSliceBp(SDVariable in, SDVariable grad, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	DifferentialFunctionFactory.sub(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.sub(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.subi(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.subi(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.sum(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.sumBp(SDVariable i_x, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.swish(SDVariable iX)
SDVariable	DifferentialFunctionFactory.swishDerivative(SDVariable iX)
SDVariable	DifferentialFunctionFactory.tan(SDVariable iX)
SDVariable	DifferentialFunctionFactory.tanh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.tanhDerivative(SDVariable iX, SDVariable wrt)
SDVariable	DifferentialFunctionFactory.tanhRational(SDVariable in)
SDVariable	DifferentialFunctionFactory.tanhRationalDerivative(SDVariable in)
SDVariable	DifferentialFunctionFactory.tanhRectified(SDVariable in)
SDVariable	DifferentialFunctionFactory.tanhRectifiedDerivative(SDVariable in)
SDVariable	DifferentialFunctionFactory.tensorMmul(SDVariable x, SDVariable y, int[][] dimensions)
SDVariable	DifferentialFunctionFactory.tile(SDVariable iX, int[] repeat)
SDVariable	DifferentialFunctionFactory.tileBp(SDVariable in, SDVariable grad, int[] repeat)
SDVariable	DifferentialFunctionFactory.trace(SDVariable in)
SDVariable	DifferentialFunctionFactory.transpose(SDVariable iX)
SDVariable	DifferentialFunctionFactory.truncatedDiv(SDVariable differentialFunction, SDVariable i_v)
SDVariable[]	DifferentialFunctionFactory.unstack(SDVariable value, int axis)
SDVariable[]	DifferentialFunctionFactory.unstack(SDVariable value, int axis, int num)
SDVariable	DifferentialFunctionFactory.upsampling2d(SDVariable input, boolean nchw, int scaleH, int scaleW)
SDVariable	DifferentialFunctionFactory.upsampling2dBp(SDVariable input, SDVariable gradient, boolean nchw, int scaleH, int scaleW)
SDVariable	DifferentialFunctionFactory.var(String iName, SDVariable iX)
SDVariable	DifferentialFunctionFactory.variance(SDVariable i_x, boolean biasCorrected, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.varianceBp(SDVariable stdInput, SDVariable gradient, boolean biasCorrected, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.weightedCrossEntropyWithLogits(SDVariable targets, SDVariable inputs, SDVariable weights)
SDVariable	DifferentialFunctionFactory.xor(SDVariable ix, SDVariable iy)
SDVariable	DifferentialFunctionFactory.xwPlusB(SDVariable input, SDVariable weights, SDVariable bias)
SDVariable	DifferentialFunctionFactory.zero(int[] shape)
SDVariable	DifferentialFunctionFactory.zero(long[] shape)
SDVariable	DifferentialFunctionFactory.zeroFraction(SDVariable input)
SDVariable	DifferentialFunctionFactory.zerosLike(SDVariable input)
SDVariable	DifferentialFunctionFactory.zerosLike(String name, SDVariable input)

Methods in org.nd4j.autodiff.functions that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	DifferentialFunctionFactory.addBp(SDVariable x, SDVariable y, SDVariable grad)
List<SDVariable>	DifferentialFunction.diff(List<SDVariable> i_v1) Perform automatic differentiation wrt the input variables
List<SDVariable>	DifferentialFunctionFactory.divBp(SDVariable x, SDVariable y, SDVariable grad)
abstract List<SDVariable>	DifferentialFunction.doDiff(List<SDVariable> f1) The actual implementation for automatic differentiation.
List<SDVariable>	DifferentialFunctionFactory.floorDivBp(SDVariable x, SDVariable y, SDVariable grad)
List<SDVariable>	DifferentialFunctionFactory.floorModBp(SDVariable x, SDVariable y, SDVariable grad)
List<SDVariable>	DifferentialFunctionFactory.mulBp(SDVariable x, SDVariable y, SDVariable grad)
List<SDVariable>	DifferentialFunctionFactory.rdivBp(SDVariable x, SDVariable y, SDVariable grad)
List<SDVariable>	DifferentialFunctionFactory.rsubBp(SDVariable x, SDVariable y, SDVariable grad)
List<SDVariable>	DifferentialFunctionFactory.subBp(SDVariable x, SDVariable y, SDVariable grad)

Methods in org.nd4j.autodiff.functions with parameters of type SDVariable

Modifier and Type	Method and Description
SDVariable	DifferentialFunctionFactory.abs(SDVariable iX)
SDVariable	DifferentialFunctionFactory.acos(SDVariable iX)
SDVariable	DifferentialFunctionFactory.acosh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.add(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.add(SDVariable differentialFunction, SDVariable i_v)
List<SDVariable>	DifferentialFunctionFactory.addBp(SDVariable x, SDVariable y, SDVariable grad)
SDVariable	DifferentialFunctionFactory.addi(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.addi(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.all(SDVariable input, int... dimensions)
SDVariable	DifferentialFunctionFactory.amax(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.amean(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.amin(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.and(SDVariable ix, SDVariable iy)
SDVariable	DifferentialFunctionFactory.any(SDVariable input, int... dimensions)
SDVariable	DifferentialFunctionFactory.argmax(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.argmin(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.asin(SDVariable iX)
SDVariable	DifferentialFunctionFactory.asinh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.assign(SDVariable x, Number num)
SDVariable	DifferentialFunctionFactory.assign(SDVariable x, SDVariable y)
SDVariable	DifferentialFunctionFactory.asum(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.atan(SDVariable iX)
SDVariable	DifferentialFunctionFactory.atan2(SDVariable y, SDVariable x)
SDVariable	DifferentialFunctionFactory.atanh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.avgPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig) Average pooling 2d operation.
SDVariable	DifferentialFunctionFactory.avgPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig) Avg pooling 3d operation.
SDVariable[]	DifferentialFunctionFactory.batchMmul(SDVariable[] matrices, boolean transposeA, boolean transposeB)
SDVariable[]	DifferentialFunctionFactory.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB)
SDVariable[]	DifferentialFunctionFactory.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB)
SDVariable[]	DifferentialFunctionFactory.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB)
SDVariable[]	DifferentialFunctionFactory.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB)
SDVariable	DifferentialFunctionFactory.batchNorm(SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon) Batch norm operation.
SDVariable	DifferentialFunctionFactory.batchToSpace(SDVariable differentialFunction, int[] blocks, int[][] crops)
SDVariable	DifferentialFunctionFactory.biasAdd(SDVariable input, SDVariable bias)
SDVariable[]	DifferentialFunctionFactory.biasAddBp(SDVariable input, SDVariable bias, SDVariable grad)
SDVariable	DifferentialFunctionFactory.broadcast(SDVariable iX, int... shape)
SDVariable	DifferentialFunctionFactory.broadcast(SDVariable iX, long... shape)
SDVariable	DifferentialFunctionFactory.ceil(SDVariable x)
SDVariable	DifferentialFunctionFactory.clipByNorm(SDVariable x, double clipValue)
SDVariable	DifferentialFunctionFactory.clipByNorm(SDVariable x, double clipValue, int... dimensions)
SDVariable	DifferentialFunctionFactory.clipByValue(SDVariable x, double clipValueMin, double clipValueMax)
SDVariable	DifferentialFunctionFactory.col2Im(SDVariable input, Conv2DConfig config)
SDVariable	DifferentialFunctionFactory.concat(int dimension, SDVariable... inputs)
SDVariable	DifferentialFunctionFactory.confusionMatrix(SDVariable labels, SDVariable pred)
SDVariable	DifferentialFunctionFactory.confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses)
SDVariable	DifferentialFunctionFactory.confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)
SDVariable	DifferentialFunctionFactory.confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights)
SDVariable	DifferentialFunctionFactory.constant(SDVariable input, long... shape)
SDVariable	DifferentialFunctionFactory.conv1d(SDVariable input, SDVariable weights, Conv1DConfig conv1DConfig) Conv1d operation.
SDVariable	DifferentialFunctionFactory.conv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig) Conv2d operation.
SDVariable	DifferentialFunctionFactory.conv3d(SDVariable[] inputs, Conv3DConfig conv3DConfig) Conv3d operation.
SDVariable	DifferentialFunctionFactory.cos(SDVariable iX)
SDVariable	DifferentialFunctionFactory.cosh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.cosineDistance(SDVariable ix, SDVariable iy, int... dimensions)
SDVariable	DifferentialFunctionFactory.cosineSimilarity(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.countNonZero(SDVariable input, int... dimensions)
SDVariable	DifferentialFunctionFactory.countZero(SDVariable input, int... dimensions)
SDVariable	DifferentialFunctionFactory.cross(SDVariable a, SDVariable b)
SDVariable	DifferentialFunctionFactory.cube(SDVariable iX)
SDVariable	DifferentialFunctionFactory.cubeDerivative(SDVariable iX)
SDVariable	DifferentialFunctionFactory.cumprod(SDVariable in, boolean exclusive, boolean reverse, int... axis)
SDVariable	DifferentialFunctionFactory.cumprodBp(SDVariable in, SDVariable grad, boolean exclusive, boolean reverse, int... axis)
SDVariable	DifferentialFunctionFactory.cumsum(SDVariable in, boolean exclusive, boolean reverse, int... axis)
SDVariable	DifferentialFunctionFactory.cumsumBp(SDVariable in, SDVariable grad, boolean exclusive, boolean reverse, int... axis)
SDVariable	DifferentialFunctionFactory.deconv2d(SDVariable[] inputs, DeConv2DConfig deconv2DConfig) Deconv2d operation.
SDVariable	DifferentialFunctionFactory.depthToSpace(SDVariable differentialFunction, int blocksSize, String dataFormat)
SDVariable	DifferentialFunctionFactory.depthWiseConv2d(SDVariable[] inputs, Conv2DConfig depthConv2DConfig) Depth-wise Conv2d operation.
SDVariable	DifferentialFunctionFactory.diag(SDVariable sdVariable)
SDVariable	DifferentialFunctionFactory.diagPart(SDVariable sdVariable)
SDVariable	DifferentialFunctionFactory.dilation2D(SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)
SDVariable	DifferentialFunctionFactory.div(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.div(SDVariable differentialFunction, SDVariable i_v)
List<SDVariable>	DifferentialFunctionFactory.divBp(SDVariable x, SDVariable y, SDVariable grad)
SDVariable	DifferentialFunctionFactory.divi(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.divi(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.doRepeat(SDVariable func, SDVariable input)
SDVariable	DifferentialFunctionFactory.dot(SDVariable x, SDVariable y, int... dimensions)
SDVariable[]	DifferentialFunctionFactory.dotBp(SDVariable in1, SDVariable in2, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.dropout(SDVariable input, double p)
SDVariable[]	DifferentialFunctionFactory.dynamicPartition(SDVariable differentialFunction, SDVariable partitions, int numPartitions)
SDVariable	DifferentialFunctionFactory.dynamicStitch(SDVariable[] indices, SDVariable[] differentialFunctions)
SDVariable	DifferentialFunctionFactory.dynamicStitch(SDVariable[] indices, SDVariable[] differentialFunctions)
SDVariable	DifferentialFunctionFactory.elu(SDVariable iX)
SDVariable	DifferentialFunctionFactory.eluDerivative(SDVariable iX)
SDVariable	DifferentialFunctionFactory.entropy(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.eq(SDVariable iX, double i_y)
SDVariable	DifferentialFunctionFactory.eq(SDVariable iX, SDVariable i_y)
SDVariable	DifferentialFunctionFactory.eqi(SDVariable iX, double i_y)
SDVariable	DifferentialFunctionFactory.erf(SDVariable differentialFunction)
SDVariable	DifferentialFunctionFactory.erfc(SDVariable differentialFunction)
SDVariable	DifferentialFunctionFactory.euclideanDistance(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.exp(SDVariable iX)
SDVariable	DifferentialFunctionFactory.expandDims(SDVariable iX, int axis)
SDVariable	DifferentialFunctionFactory.expm1(SDVariable iX)
ExternalErrorsFunction	DifferentialFunctionFactory.externalErrors(Map<String,INDArray> externalGradients, SDVariable... inputs)
ExternalErrorsFunction	DifferentialFunctionFactory.externalErrors(SDVariable... inputs)
SDVariable	DifferentialFunctionFactory.fill(SDVariable shape, double value)
SDVariable	DifferentialFunctionFactory.firstIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.floor(SDVariable iX)
SDVariable	DifferentialFunctionFactory.floorDiv(SDVariable x, SDVariable y)
List<SDVariable>	DifferentialFunctionFactory.floorDivBp(SDVariable x, SDVariable y, SDVariable grad)
SDVariable	DifferentialFunctionFactory.floorMod(SDVariable x, SDVariable y)
List<SDVariable>	DifferentialFunctionFactory.floorModBp(SDVariable x, SDVariable y, SDVariable grad)
SDVariable	DifferentialFunctionFactory.gather(SDVariable df, int[] indices, int axis)
SDVariable	DifferentialFunctionFactory.gather(SDVariable df, SDVariable indices, int axis)
SDVariable	DifferentialFunctionFactory.gatherNd(SDVariable df, SDVariable indices)
long	DifferentialFunctionFactory.getInputLength(SDVariable func)
SDVariable	DifferentialFunctionFactory.gradientBackwardsMarker(SDVariable iX)
SDVariable	DifferentialFunctionFactory.gt(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.gt(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.gte(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.gte(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.gtei(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.gtei(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.gti(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.gti(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.hammingDistance(SDVariable ix, SDVariable iy, int... dimensions)
SDVariable	DifferentialFunctionFactory.hardSigmoid(SDVariable in)
SDVariable	DifferentialFunctionFactory.hardTanh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.hardTanhDerivative(SDVariable iX)
SDVariable	DifferentialFunctionFactory.iamax(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.iamin(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.identity(SDVariable input)
SDVariable	DifferentialFunctionFactory.im2Col(SDVariable input, Conv2DConfig config)
SDVariable	DifferentialFunctionFactory.im2ColBp(SDVariable im2colInput, SDVariable gradientAtOutput, Conv2DConfig config)
SDVariable	DifferentialFunctionFactory.invertPermutation(SDVariable input, boolean inPlace)
SDVariable	DifferentialFunctionFactory.isFinite(SDVariable ix)
SDVariable	DifferentialFunctionFactory.isInfinite(SDVariable ix)
SDVariable	DifferentialFunctionFactory.isMax(SDVariable ix)
SDVariable	DifferentialFunctionFactory.isNaN(SDVariable ix)
SDVariable	DifferentialFunctionFactory.isNonDecreasing(SDVariable iX)
SDVariable	DifferentialFunctionFactory.isNumericTensor(SDVariable iX)
SDVariable	DifferentialFunctionFactory.isStrictlyIncreasing(SDVariable iX)
SDVariable	DifferentialFunctionFactory.jaccardDistance(SDVariable ix, SDVariable iy, int... dimensions)
SDVariable	DifferentialFunctionFactory.lastIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.leakyRelu(SDVariable iX, double alpha)
SDVariable	DifferentialFunctionFactory.leakyReluDerivative(SDVariable iX, double cutoff)
SDVariable	DifferentialFunctionFactory.localResponseNormalization(SDVariable input, LocalResponseNormalizationConfig lrnConfig) Local response normalization operation.
SDVariable	DifferentialFunctionFactory.log(SDVariable iX)
SDVariable	DifferentialFunctionFactory.log(SDVariable in, double base)
SDVariable	DifferentialFunctionFactory.log1p(SDVariable iX)
SDVariable	DifferentialFunctionFactory.logEntropy(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.logSigmoid(SDVariable iX)
SDVariable	DifferentialFunctionFactory.logSigmoidDerivative(SDVariable iX, SDVariable wrt)
SDVariable	DifferentialFunctionFactory.logSoftmax(SDVariable i_v)
SDVariable	DifferentialFunctionFactory.logSoftmaxDerivative(SDVariable arg, SDVariable wrt)
SDVariable	DifferentialFunctionFactory.logSumExp(SDVariable arg, int... dimension)
SDVariable	DifferentialFunctionFactory.lossBinaryXENT(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossCosineSimilarity(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossHinge(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossKLD(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossL1(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossL2(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossMAE(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossMAPE(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossMCXENT(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossMSE(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossMSLE(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossNegativeLogLikelihood(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossPoisson(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lossSquaredHinge(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.lt(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.lt(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.lte(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.lte(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.ltei(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.lti(SDVariable functionInput, double functionInput1)
SDVariable	DifferentialFunctionFactory.lti(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.ltOrEqi(SDVariable functionInput, SDVariable functionInput1)
SDVariable	DifferentialFunctionFactory.manhattanDistance(SDVariable iX, SDVariable i_y, int... dimensions)
SDVariable	DifferentialFunctionFactory.matchCondition(SDVariable in, Condition condition) Returns a boolean mask of equal shape to the input, where the condition is satisfied
SDVariable	DifferentialFunctionFactory.matchConditionCount(SDVariable in, Condition condition, boolean keepDims, int... dimensions) Returns a count of the number of elements that satisfy the condition
SDVariable	DifferentialFunctionFactory.matrixDeterminant(SDVariable in)
SDVariable	DifferentialFunctionFactory.matrixInverse(SDVariable in)
SDVariable	DifferentialFunctionFactory.max(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.max(SDVariable first, SDVariable second)
SDVariable	DifferentialFunctionFactory.maxBp(SDVariable i_x, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.maxPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig) Max pooling 2d operation.
SDVariable	DifferentialFunctionFactory.maxPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig) Max pooling 3d operation.
SDVariable	DifferentialFunctionFactory.mean(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.meanBp(SDVariable in, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.mergeAdd(SDVariable... differentialFunctions)
SDVariable	DifferentialFunctionFactory.mergeAvg(SDVariable... differentialFunctions)
SDVariable	DifferentialFunctionFactory.mergeMax(SDVariable... differentialFunctions)
SDVariable[]	DifferentialFunctionFactory.meshgrid(boolean cartesian, SDVariable... inputs)
SDVariable	DifferentialFunctionFactory.min(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.min(SDVariable first, SDVariable second)
SDVariable	DifferentialFunctionFactory.minBp(SDVariable i_x, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.mmul(SDVariable x, SDVariable y)
SDVariable	DifferentialFunctionFactory.mmul(SDVariable x, SDVariable y, MMulTranspose mMulTranspose)
SDVariable[]	DifferentialFunctionFactory.moments(SDVariable input, int... axes)
SDVariable	DifferentialFunctionFactory.mul(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.mul(SDVariable differentialFunction, SDVariable i_v)
List<SDVariable>	DifferentialFunctionFactory.mulBp(SDVariable x, SDVariable y, SDVariable grad)
SDVariable	DifferentialFunctionFactory.muli(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.muli(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.neg(SDVariable iX)
SDVariable	DifferentialFunctionFactory.neq(SDVariable iX, double i_y)
SDVariable	DifferentialFunctionFactory.neq(SDVariable iX, SDVariable i_y)
SDVariable	DifferentialFunctionFactory.neqi(SDVariable iX, double i_y)
SDVariable	DifferentialFunctionFactory.neqi(SDVariable iX, SDVariable i_y)
SDVariable	DifferentialFunctionFactory.noop(SDVariable input)
SDVariable	DifferentialFunctionFactory.norm1(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.norm1Bp(SDVariable preReduceIn, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.norm2(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.norm2Bp(SDVariable preReduceIn, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable[]	DifferentialFunctionFactory.normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)
SDVariable	DifferentialFunctionFactory.normmax(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.normmaxBp(SDVariable preReduceIn, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.onehot(SDVariable indices, int depth)
SDVariable	DifferentialFunctionFactory.onehot(SDVariable indices, int depth, int axis, double on, double off)
SDVariable	DifferentialFunctionFactory.onesLike(String name, SDVariable input)
SDVariable	DifferentialFunctionFactory.or(SDVariable iX, SDVariable i_y)
SDVariable	DifferentialFunctionFactory.parallel_stack(SDVariable[] values)
SDVariable	DifferentialFunctionFactory.permute(SDVariable iX, int... dimensions)
SDVariable	DifferentialFunctionFactory.pooling3d(SDVariable input, Pooling3DConfig pooling3DConfig)
SDVariable	DifferentialFunctionFactory.pow(SDVariable iX, double i_y)
SDVariable	DifferentialFunctionFactory.powDerivative(SDVariable iX, double pow)
SDVariable	DifferentialFunctionFactory.prod(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.prodBp(SDVariable preReduceInput, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.randomBernoulli(double p, SDVariable shape)
SDVariable	DifferentialFunctionFactory.randomExponential(double lambda, SDVariable shape) Exponential distribution: P(x) = lambda * exp(-lambda * x)
SDVariable	DifferentialFunctionFactory.randomNormal(double mean, double std, SDVariable shape)
SDVariable	DifferentialFunctionFactory.randomUniform(double min, double max, SDVariable shape)
SDVariable	DifferentialFunctionFactory.rank(SDVariable df)
SDVariable	DifferentialFunctionFactory.rdiv(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.rdiv(SDVariable differentialFunction, SDVariable i_v)
List<SDVariable>	DifferentialFunctionFactory.rdivBp(SDVariable x, SDVariable y, SDVariable grad)
SDVariable	DifferentialFunctionFactory.rdivi(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.rdivi(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.reciprocal(SDVariable a)
SDVariable	DifferentialFunctionFactory.reductionBroadcastableWithOrigShape(int origRank, int[] reduceDims, SDVariable toExpand) Add 1s as required to the array make an array possible to be broadcast with the original (pre-reduce) array.
SDVariable	DifferentialFunctionFactory.relu(SDVariable iX, double cutoff)
SDVariable	DifferentialFunctionFactory.relu6(SDVariable iX, double cutoff)
SDVariable	DifferentialFunctionFactory.relu6Derivative(SDVariable iX, SDVariable wrt, double cutoff)
SDVariable	DifferentialFunctionFactory.reluLayer(SDVariable input, SDVariable weights, SDVariable bias)
SDVariable	DifferentialFunctionFactory.repeat(SDVariable iX, int axis)
SDVariable	DifferentialFunctionFactory.replaceWhere(SDVariable to, Number set, Condition condition)
SDVariable	DifferentialFunctionFactory.replaceWhere(SDVariable to, SDVariable from, Condition condition)
SDVariable	DifferentialFunctionFactory.reshape(SDVariable iX, int[] shape)
SDVariable	DifferentialFunctionFactory.reshape(SDVariable iX, long[] shape)
SDVariable	DifferentialFunctionFactory.reshape(SDVariable iX, SDVariable shape)
SDVariable	DifferentialFunctionFactory.reverse(SDVariable x, int... dimensions)
SDVariable	DifferentialFunctionFactory.reverseSequence(SDVariable x, SDVariable seq_lengths)
SDVariable	DifferentialFunctionFactory.reverseSequence(SDVariable x, SDVariable seq_lengths, int seq_dim, int batch_dim)
SDVariable	DifferentialFunctionFactory.rollAxis(SDVariable iX, int axis)
SDVariable	DifferentialFunctionFactory.round(SDVariable ix)
SDVariable	DifferentialFunctionFactory.rsqrt(SDVariable iX)
SDVariable	DifferentialFunctionFactory.rsub(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.rsub(SDVariable differentialFunction, SDVariable i_v)
List<SDVariable>	DifferentialFunctionFactory.rsubBp(SDVariable x, SDVariable y, SDVariable grad)
SDVariable	DifferentialFunctionFactory.rsubi(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.rsubi(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.scalarFloorMod(SDVariable in, Number num)
SDVariable	DifferentialFunctionFactory.scalarMax(SDVariable in, Number num)
SDVariable	DifferentialFunctionFactory.scalarMin(SDVariable in, Number num)
SDVariable	DifferentialFunctionFactory.scalarSet(SDVariable in, Number num)
SDVariable	DifferentialFunctionFactory.scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterMax(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterMin(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.scatterUpdate(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	DifferentialFunctionFactory.sconv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig) Separable Conv2d operation.
SDVariable	DifferentialFunctionFactory.segmentMax(SDVariable data, SDVariable segmentIds)
SDVariable	DifferentialFunctionFactory.segmentMean(SDVariable data, SDVariable segmentIds)
SDVariable	DifferentialFunctionFactory.segmentMin(SDVariable data, SDVariable segmentIds)
SDVariable	DifferentialFunctionFactory.segmentProd(SDVariable data, SDVariable segmentIds)
SDVariable	DifferentialFunctionFactory.segmentSum(SDVariable data, SDVariable segmentIds)
SDVariable	DifferentialFunctionFactory.selu(SDVariable arg)
SDVariable	DifferentialFunctionFactory.seluDerivative(SDVariable arg)
SDVariable	DifferentialFunctionFactory.sequenceMask(SDVariable lengths)
SDVariable	DifferentialFunctionFactory.sequenceMask(SDVariable lengths, int maxLen)
SDVariable	DifferentialFunctionFactory.sequenceMask(SDVariable lengths, SDVariable maxLen)
SDVariable	DifferentialFunctionFactory.setDiag(SDVariable in, SDVariable diag)
SDVariable	DifferentialFunctionFactory.shannonEntropy(SDVariable in, int... dimensions)
SDVariable	DifferentialFunctionFactory.shape(SDVariable df)
SDVariable	DifferentialFunctionFactory.sigmoid(SDVariable iX)
SDVariable	DifferentialFunctionFactory.sigmoidCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)
SDVariable	DifferentialFunctionFactory.sigmoidDerivative(SDVariable iX, SDVariable wrt)
SDVariable	DifferentialFunctionFactory.sign(SDVariable iX)
SDVariable	DifferentialFunctionFactory.sin(SDVariable iX)
SDVariable	DifferentialFunctionFactory.sinh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.size(SDVariable in)
SDVariable	DifferentialFunctionFactory.sizeAt(SDVariable in, int dimension)
SDVariable	DifferentialFunctionFactory.slice(SDVariable input, int[] begin, int[] size)
SDVariable	DifferentialFunctionFactory.sliceBp(SDVariable input, SDVariable gradient, int[] begin, int[] size)
SDVariable	DifferentialFunctionFactory.softmax(SDVariable iX)
SDVariable	DifferentialFunctionFactory.softmaxCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)
SDVariable	DifferentialFunctionFactory.softmaxDerivative(SDVariable functionInput, SDVariable wrt, Integer dimension)
SDVariable	DifferentialFunctionFactory.softplus(SDVariable iX)
SDVariable	DifferentialFunctionFactory.softsign(SDVariable iX)
SDVariable	DifferentialFunctionFactory.softsignDerivative(SDVariable iX)
SDVariable	DifferentialFunctionFactory.spaceToBatch(SDVariable differentialFunction, int[] blocks, int[][] padding)
SDVariable	DifferentialFunctionFactory.spaceToDepth(SDVariable differentialFunction, int blocksSize, String dataFormat)
SDVariable	DifferentialFunctionFactory.sqrt(SDVariable iX)
SDVariable	DifferentialFunctionFactory.square(SDVariable iX)
SDVariable	DifferentialFunctionFactory.squaredDifference(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.squaredNorm(SDVariable input, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.squaredNormBp(SDVariable preReduceInput, SDVariable gradient, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.squeeze(SDVariable iX, int... axis)
SDVariable	DifferentialFunctionFactory.stack(SDVariable[] values, int axis)
SDVariable	DifferentialFunctionFactory.std(SDVariable i_x, boolean biasCorrected, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.stdBp(SDVariable stdInput, SDVariable gradient, boolean biasCorrected, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.step(SDVariable in, double cutoff)
SDVariable	DifferentialFunctionFactory.stridedSlice(SDVariable input, int[] begin, int[] end, int[] strides)
SDVariable	DifferentialFunctionFactory.stridedSlice(SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	DifferentialFunctionFactory.stridedSlice(SDVariable input, long[] begin, long[] end, long[] strides)
SDVariable	DifferentialFunctionFactory.stridedSlice(SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	DifferentialFunctionFactory.stridedSliceBp(SDVariable in, SDVariable grad, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	DifferentialFunctionFactory.sub(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.sub(SDVariable differentialFunction, SDVariable i_v)
List<SDVariable>	DifferentialFunctionFactory.subBp(SDVariable x, SDVariable y, SDVariable grad)
SDVariable	DifferentialFunctionFactory.subi(SDVariable differentialFunction, double i_v)
SDVariable	DifferentialFunctionFactory.subi(SDVariable differentialFunction, SDVariable i_v)
SDVariable	DifferentialFunctionFactory.sum(SDVariable i_x, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.sumBp(SDVariable i_x, SDVariable grad, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.swish(SDVariable iX)
SDVariable	DifferentialFunctionFactory.swishDerivative(SDVariable iX)
SDVariable	DifferentialFunctionFactory.tan(SDVariable iX)
SDVariable	DifferentialFunctionFactory.tanh(SDVariable iX)
SDVariable	DifferentialFunctionFactory.tanhDerivative(SDVariable iX, SDVariable wrt)
SDVariable	DifferentialFunctionFactory.tanhRational(SDVariable in)
SDVariable	DifferentialFunctionFactory.tanhRationalDerivative(SDVariable in)
SDVariable	DifferentialFunctionFactory.tanhRectified(SDVariable in)
SDVariable	DifferentialFunctionFactory.tanhRectifiedDerivative(SDVariable in)
SDVariable	DifferentialFunctionFactory.tensorMmul(SDVariable x, SDVariable y, int[][] dimensions)
SDVariable	DifferentialFunctionFactory.tile(SDVariable iX, int[] repeat)
SDVariable	DifferentialFunctionFactory.tileBp(SDVariable in, SDVariable grad, int[] repeat)
SDVariable	DifferentialFunctionFactory.trace(SDVariable in)
SDVariable	DifferentialFunctionFactory.transpose(SDVariable iX)
SDVariable	DifferentialFunctionFactory.truncatedDiv(SDVariable differentialFunction, SDVariable i_v)
SDVariable[]	DifferentialFunctionFactory.unstack(SDVariable value, int axis)
SDVariable[]	DifferentialFunctionFactory.unstack(SDVariable value, int axis, int num)
SDVariable	DifferentialFunctionFactory.upsampling2d(SDVariable input, boolean nchw, int scaleH, int scaleW)
SDVariable	DifferentialFunctionFactory.upsampling2dBp(SDVariable input, SDVariable gradient, boolean nchw, int scaleH, int scaleW)
Constant	DifferentialFunctionFactory.val(SDVariable iX)
void	DifferentialFunctionFactory.validateDifferentialFunctionGraph(SDVariable function)
void	DifferentialFunctionFactory.validateDifferentialFunctionsameDiff(SDVariable function)
SDVariable	DifferentialFunctionFactory.var(String iName, SDVariable iX)
SDVariable	DifferentialFunctionFactory.variance(SDVariable i_x, boolean biasCorrected, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.varianceBp(SDVariable stdInput, SDVariable gradient, boolean biasCorrected, boolean keepDims, int... dimensions)
SDVariable	DifferentialFunctionFactory.weightedCrossEntropyWithLogits(SDVariable targets, SDVariable inputs, SDVariable weights)
SDVariable	DifferentialFunctionFactory.xor(SDVariable ix, SDVariable iy)
SDVariable	DifferentialFunctionFactory.xwPlusB(SDVariable input, SDVariable weights, SDVariable bias)
SDVariable	DifferentialFunctionFactory.zeroFraction(SDVariable input)
SDVariable	DifferentialFunctionFactory.zerosLike(SDVariable input)
SDVariable	DifferentialFunctionFactory.zerosLike(String name, SDVariable input)

Method parameters in org.nd4j.autodiff.functions with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	DifferentialFunction.diff(List<SDVariable> i_v1) Perform automatic differentiation wrt the input variables
abstract List<SDVariable>	DifferentialFunction.doDiff(List<SDVariable> f1) The actual implementation for automatic differentiation.

Constructors in org.nd4j.autodiff.functions with parameters of type SDVariable

Constructor and Description
DifferentialFunction(SameDiff sameDiff, boolean inPlace, SDVariable[] args) Add the various arguments for this function
DifferentialFunction(SameDiff sameDiff, SDVariable[] args)

Uses of SDVariable in org.nd4j.autodiff.loss

Methods in org.nd4j.autodiff.loss with parameters of type SDVariable

Modifier and Type	Method and Description
static LossInfo	LossFunctions.l1(String outputName, SDVariable predictions, SDVariable label, SDVariable weights, LossFunctions.Reduction reduction, int... dimensions) L1 loss - sum of absolute errors.
static LossInfo	LossFunctions.l2(String outputName, SDVariable predictions, SDVariable label, SDVariable weights, LossFunctions.Reduction reduction, int... dimensions) L2 loss function: i.e., sum of squared errors, L = sum_i (actual_i - predicted)^2
static LossInfo	LossFunctions.mcxent(String outputName, SDVariable predictions, SDVariable label, SDVariable weights, LossFunctions.Reduction reduction, int... dimensions) Multi-Class Cross Entropy loss function: L = sum_i actual_i * log( predicted_i )
static LossInfo	LossFunctions.mse(String outputName, SDVariable predictions, SDVariable label, SDVariable weights, LossFunctions.Reduction reduction, int... dimensions) Mean squared error: L = mean( (predicted - label)^2)
static LossInfo	LossFunctions.negativeLogLikelihood(String outputName, SDVariable predictions, SDVariable label, SDVariable weights, LossFunctions.Reduction reduction, int... dimensions)

Uses of SDVariable in org.nd4j.autodiff.samediff

Methods in org.nd4j.autodiff.samediff with type parameters of type SDVariable

Modifier and Type	Method and Description
<X extends SDVariable> X	SameDiff.setupFunction(X function) Attempts to insert the DifferentialFunction reference in to this SameDiff instance.

Methods in org.nd4j.autodiff.samediff that return SDVariable

Modifier and Type	Method and Description
SDVariable	SameDiff.abs(SDVariable x) Elementwise absolute value operation: out = abs(x)
SDVariable	SameDiff.abs(String name, SDVariable x) Elementwise absolute value operation: out = abs(x)
SDVariable	SameDiff.acos(SDVariable x) Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
SDVariable	SameDiff.acos(String name, SDVariable x) Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
SDVariable	SameDiff.acosh(SDVariable x) Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
SDVariable	SameDiff.acosh(String name, SDVariable x) Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
SDVariable	SDVariable.add(double sameDiffVariable)
SDVariable	SDVariable.add(SDVariable sameDiffVariable)
SDVariable	SDVariable.add(String varName, double sameDiffVariable)
SDVariable	SDVariable.add(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.addi(double sameDiffVariable)
SDVariable	SDVariable.addi(SDVariable sameDiffVariable)
SDVariable	SDVariable.addi(String varName, double sameDiffVariable)
SDVariable	SDVariable.addi(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.amax(SDVariable in, int... dimensions) Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
SDVariable	SameDiff.amax(String name, SDVariable in, int... dimensions) Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
SDVariable	SameDiff.amean(SDVariable in, int... dimensions) Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
SDVariable	SameDiff.amean(String name, SDVariable in, int... dimensions) Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
SDVariable	SameDiff.amin(SDVariable in, int... dimensions) Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
SDVariable	SameDiff.amin(String name, SDVariable in, int... dimensions) Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
SDVariable	SameDiff.and(SDVariable x, SDVariable y) Boolean AND operation: elementwise (x != 0) && (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.and(String name, SDVariable x, SDVariable y) Boolean AND operation: elementwise (x != 0) && (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.arg()
SDVariable	SDVariable.argmax(int... dimensions)
SDVariable	SameDiff.argmax(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	SameDiff.argmax(SDVariable in, int... dimensions) Argmax array reduction operation, optionally along specified dimensions. Output values are the index of the maximum value of each slice along the specified dimension
SDVariable	SDVariable.argmax(String name, int... dimensions)
SDVariable	SameDiff.argmax(String name, SDVariable in, boolean keepDims, int... dimensions) Argmax array reduction operation, optionally along specified dimensions. Output values are the index of the maximum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.argmax(String name, SDVariable in, int... dimensions) Argmax array reduction operation, optionally along specified dimensions. Output values are the index of the maximum value of each slice along the specified dimension
SDVariable	SDVariable.argmin(int... dimensions)
SDVariable	SameDiff.argmin(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	SameDiff.argmin(SDVariable in, int... dimensions) Argmin array reduction operation, optionally along specified dimensions. Output values are the index of the minimum value of each slice along the specified dimension
SDVariable	SDVariable.argmin(String name, int... dimensions)
SDVariable	SameDiff.argmin(String name, SDVariable in, boolean keepDims, int... dimensions) Argmin array reduction operation, optionally along specified dimensions. Output values are the index of the minimum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.argmin(String name, SDVariable in, int... dimensions) Argmin array reduction operation, optionally along specified dimensions. Output values are the index of the minimum value of each slice along the specified dimension
SDVariable[]	SDVariable.args()
SDVariable	SameDiff.asin(SDVariable x) Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
SDVariable	SameDiff.asin(String name, SDVariable x) Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
SDVariable	SameDiff.asinh(SDVariable x) Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
SDVariable	SameDiff.asinh(String name, SDVariable x) Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
SDVariable	SDVariable.assign(Number value)
SDVariable	SameDiff.assign(SDVariable in, Number value) Return an array with equal shape to the input, but all elements set to 'value'
SDVariable	SameDiff.assign(SDVariable x, SDVariable y) Assign/copy op: out = x.assign(y).
SDVariable	SameDiff.assign(String name, SDVariable in, Number value) Return an array with equal shape to the input, but all elements set to 'value'
SDVariable	SameDiff.assign(String name, SDVariable x, SDVariable y) Assign/copy op: out = x.assign(y).
SDVariable	SameDiff.asum(SDVariable in, int... dimensions) Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
SDVariable	SameDiff.asum(String name, SDVariable in, int... dimensions) Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
SDVariable	SameDiff.atan(SDVariable x) Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
SDVariable	SameDiff.atan(String name, SDVariable x) Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
SDVariable	SameDiff.atan2(SDVariable y, SDVariable x) Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
SDVariable	SameDiff.atan2(String name, SDVariable y, SDVariable x) Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
SDVariable	SameDiff.atanh(SDVariable x) Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
SDVariable	SameDiff.atanh(String name, SDVariable x) Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
SDVariable	SameDiff.avgPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig) 2D Convolution layer operation - average pooling 2d
SDVariable	SameDiff.avgPooling2d(String name, SDVariable input, Pooling2DConfig pooling2DConfig) 2D Convolution layer operation - average pooling 2d
SDVariable	SameDiff.avgPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig) 3D convolution layer operation - average pooling 3d
SDVariable	SameDiff.avgPooling3d(String name, SDVariable input, Pooling3DConfig pooling3DConfig) 3D convolution layer operation - average pooling 3d
SDVariable[]	SameDiff.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB) Matrix multiply a batch of matrices.
SDVariable[]	SameDiff.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB) Matrix multiply a batch of matrices.
SDVariable[]	SameDiff.batchMmul(String[] names, SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB) Matrix multiply a batch of matrices.
SDVariable	SameDiff.batchNorm(SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon) Batch norm operation.
SDVariable	SameDiff.batchNorm(String name, SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon) Batch norm operation.
SDVariable	SameDiff.batchToSpace(SDVariable x, int[] blocks, int[][] crops)
SDVariable	SameDiff.batchToSpace(String name, SDVariable x, int[] blocks, int[][] crops) Convolution 2d layer batch to space operation on 4d input.
SDVariable	SameDiff.biasAdd(SDVariable input, SDVariable bias)
SDVariable	SameDiff.biasAdd(String name, SDVariable input, SDVariable bias) Bias addition operation: a special case of addition, typically used with CNN 4D activations and a 1D bias vector
SDVariable	SameDiff.ceil(SDVariable x) Element-wise ceiling function: out = ceil(x).
SDVariable	SameDiff.ceil(String name, SDVariable x) Element-wise ceiling function: out = ceil(x).
SDVariable	SameDiff.clipByNorm(SDVariable x, double clipValue) Clipping by L2 norm if l2Norm(x) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
SDVariable	SameDiff.clipByNorm(SDVariable x, double clipValue, int... dimensions) Clipping by L2 norm, optionally along dimension(s) if l2Norm(x,dimension) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according to the corresponding l2Norm along the specified dimensions
SDVariable	SameDiff.clipByNorm(String name, SDVariable x, double clipValue) Clipping by L2 norm if l2Norm(x) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
SDVariable	SameDiff.clipByNorm(String name, SDVariable x, double clipValue, int... dimensions) Clipping by L2 norm, optionally along dimension(s) if l2Norm(x,dimension) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according to the corresponding l2Norm along the specified dimensions
SDVariable	SameDiff.clipByValue(SDVariable x, double clipValueMin, double clipValueMax) Element-wise clipping function: out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax out[i] = clipValueMin if in[i] < clipValueMin out[i] = clipValueMax if in[i] > clipValueMax
SDVariable	SameDiff.clipByValue(String name, SDVariable x, double clipValueMin, double clipValueMax) Element-wise clipping function: out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax out[i] = clipValueMin if in[i] < clipValueMin out[i] = clipValueMax if in[i] > clipValueMax
SDVariable	SameDiff.col2Im(SDVariable in, Conv2DConfig config) col2im operation for use in 2D convolution operations.
SDVariable	SameDiff.col2Im(String name, SDVariable in, Conv2DConfig config) col2im operation for use in 2D convolution operations.
SDVariable	SameDiff.concat(int dimension, SDVariable... inputs)
SDVariable	SameDiff.concat(String name, int dimension, SDVariable... inputs) Concatenate a set of inputs along the specified dimension. Note that inputs must have identical rank and identical dimensions, other than the dimension to stack on. For example, if 2 inputs have shape [a, x, c] and [a, y, c] and dimension = 1, then the output has shape [a, x+y, c]
SDVariable	SameDiff.confusionMatrix(SDVariable labels, SDVariable predictions)
SDVariable	SameDiff.confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses)
SDVariable	SameDiff.confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)
SDVariable	SameDiff.confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights)
SDVariable	SameDiff.confusionMatrix(String name, SDVariable labels, SDVariable pred) Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values.
SDVariable	SameDiff.confusionMatrix(String name, SDVariable labels, SDVariable pred, Integer numClasses) Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values. For example, if labels = [0, 1, 1], predicted = [0, 2, 1], and numClasses=4 then output is: [1, 0, 0, 0] [0, 1, 1, 0] [0, 0, 0, 0] [0, 0, 0, 0]
SDVariable	SameDiff.confusionMatrix(String name, SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights) Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values. For example, if labels = [0, 1, 1], predicted = [0, 2, 1], numClasses = 4, and weights = [1, 2, 3] [1, 0, 0, 0] [0, 3, 2, 0] [0, 0, 0, 0] [0, 0, 0, 0]
SDVariable	SameDiff.confusionMatrix(String name, SDVariable labels, SDVariable pred, SDVariable weights) Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values.
SDVariable	SameDiff.constant(SDVariable value, long... shape) Return a variable of given shape in which all values have a given constant value.
SDVariable	SameDiff.constant(String name, SDVariable value, long... shape) Return a variable of given shape in which all values have a given constant value.
SDVariable	SameDiff.conv1d(SDVariable input, SDVariable weights, Conv1DConfig conv1DConfig) 1D Convolution layer operation - Conv1d
SDVariable	SameDiff.conv1d(String name, SDVariable input, SDVariable weights, Conv1DConfig conv1DConfig) Conv1d operation.
SDVariable	SameDiff.conv2d(SDVariable[] inputs, Conv2DConfig config) 2D Convolution operation with optional bias
SDVariable	SameDiff.conv2d(SDVariable layerInput, SDVariable weights, Conv2DConfig config) 2D Convolution operation (without bias)
SDVariable	SameDiff.conv2d(SDVariable layerInput, SDVariable weights, SDVariable bias, Conv2DConfig config) 2D Convolution operation with optional bias
SDVariable	SameDiff.conv2d(String name, SDVariable[] inputs, Conv2DConfig config) 2D Convolution operation with optional bias
SDVariable	SameDiff.conv3d(SDVariable input, SDVariable weights, Conv3DConfig conv3DConfig) Convolution 3D operation without bias
SDVariable	SameDiff.conv3d(SDVariable input, SDVariable weights, SDVariable bias, Conv3DConfig conv3DConfig) Convolution 3D operation with optional bias
SDVariable	SameDiff.conv3d(String name, SDVariable input, SDVariable weights, Conv3DConfig conv3DConfig) Convolution 3D operation without bias
SDVariable	SameDiff.conv3d(String name, SDVariable input, SDVariable weights, SDVariable bias, Conv3DConfig conv3DConfig) Convolution 3D operation with optional bias
SDVariable	SameDiff.cos(SDVariable x) Elementwise cosine operation: out = cos(x)
SDVariable	SameDiff.cos(String name, SDVariable x) Elementwise cosine operation: out = cos(x)
SDVariable	SameDiff.cosh(SDVariable x) Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
SDVariable	SameDiff.cosh(String name, SDVariable x) Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
SDVariable	SameDiff.cosineDistance(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.cosineDistance(String name, SDVariable x, SDVariable y, int... dimensions) Cosine distance reduction operation.
SDVariable	SameDiff.cosineSimilarity(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.cosineSimilarity(String name, SDVariable x, SDVariable y, int... dimensions) Cosine similarity pairwise reduction operation.
SDVariable	SameDiff.countNonZero(SDVariable input, int... dimensions) Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
SDVariable	SameDiff.countNonZero(String name, SDVariable input, int... dimensions) Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
SDVariable	SameDiff.countZero(SDVariable input, int... dimensions) Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
SDVariable	SameDiff.countZero(String name, SDVariable input, int... dimensions) Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
SDVariable	SameDiff.cross(SDVariable a, SDVariable b)
SDVariable	SameDiff.cross(String name, SDVariable a, SDVariable b) Returns the pair-wise cross product of equal size arrays a and b: a x b = ||a||x||b|| sin(theta).
SDVariable	SameDiff.cube(SDVariable x) Element-wise cube function: out = x^3
SDVariable	SameDiff.cube(String name, SDVariable x) Element-wise cube function: out = x^3
SDVariable	SameDiff.cumprod(SDVariable in, boolean exclusive, boolean reverse, int... axis)
SDVariable	SameDiff.cumprod(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis) Cumulative product operation. For input: [ a, b, c], output is: exclusize=false, reverse=false: [a, a*b, a*b*c] exclusive=true, reverse=false, [0, a, a*b] exclusive=false, reverse=true: [a*b*c, b*c, c] exclusive=true, reverse=true: [b*c, c, 0]
SDVariable	SameDiff.cumsum(SDVariable in, boolean exclusive, boolean reverse, int... axis)
SDVariable	SameDiff.cumsum(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis) Cumulative sum operation. For input: [ a, b, c], output is: exclusize=false, reverse=false: [a, a+b, a+b+c] exclusive=true, reverse=false, [0, a, a+b] exclusive=false, reverse=true: [a+b+c, b+c, c] exclusive=true, reverse=true: [b+c, c, 0]
SDVariable	SameDiff.deconv2d(SDVariable[] inputs, DeConv2DConfig deconv2DConfig) 2D deconvolution operation with or without optional bias
SDVariable	SameDiff.deconv2d(SDVariable layerInput, SDVariable weights, DeConv2DConfig deconv2DConfig) 2D deconvolution operation without bias
SDVariable	SameDiff.deconv2d(SDVariable layerInput, SDVariable weights, SDVariable bias, DeConv2DConfig deconv2DConfig) 2D deconvolution operation with optional bias
SDVariable	SameDiff.deconv2d(String name, SDVariable[] inputs, DeConv2DConfig deconv2DConfig) 2D deconvolution operation with or without optional bias
SDVariable[]	SameDiffFunctionDefinition.define(SameDiff sameDiff, Map<String,INDArray> inputs, SDVariable[] variableInputs)
SDVariable	SameDiff.depthToSpace(SDVariable x, int blockSize, String dataFormat) Convolution 2d layer batch to space operation on 4d input. Reduces input channels dimension by rearranging data into a larger spatial dimensions Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2] = [mb, 2, 4, 4]
SDVariable	SameDiff.depthToSpace(String name, SDVariable x, int blockSize, String dataFormat) Convolution 2d layer batch to space operation on 4d input. Reduces input channels dimension by rearranging data into a larger spatial dimensions Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2] = [mb, 2, 4, 4]
SDVariable	SameDiff.depthWiseConv2d(SDVariable[] inputs, Conv2DConfig depthConv2DConfig) Depth-wise convolution 2D operation.
SDVariable	SameDiff.depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, Conv2DConfig config) Depth-wise 2D convolution operation without bias
SDVariable	SameDiff.depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable bias, Conv2DConfig config) Depth-wise 2D convolution operation with optional bias
SDVariable	SameDiff.depthWiseConv2d(String name, SDVariable[] inputs, Conv2DConfig depthConv2DConfig) Depth-wise convolution 2D operation.
SDVariable	SameDiff.diag(SDVariable x)
SDVariable	SameDiff.diag(String name, SDVariable x) Returns an output variable with diagonal values equal to the specified values; off-diagonal values will be set to 0 For example, if input = [1,2,3], then output is given by: [ 1, 0, 0] [ 0, 2, 0] [ 0, 0, 3] Higher input ranks are also supported: if input has shape [a,...,R-1] then output[i,...,k,i,...,k] = input[i,...,k].
SDVariable	SameDiff.diagPart(SDVariable x)
SDVariable	SameDiff.diagPart(String name, SDVariable x) Extract the diagonal part from the input array. If input is [ 1, 0, 0] [ 0, 2, 0] [ 0, 0, 3] then output is [1, 2, 3]. Supports higher dimensions: in general, out[i,...,k] = in[i,...,k,i,...,k]
SDVariable	SameDiff.dilation2D(SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode) TODO doc string
SDVariable	SameDiff.dilation2D(String name, SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode) TODO doc string
SDVariable	SDVariable.div(double sameDiffVariable)
SDVariable	SDVariable.div(SDVariable sameDiffVariable)
SDVariable	SDVariable.div(String varName, double sameDiffVariable)
SDVariable	SDVariable.div(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.divi(double sameDiffVariable)
SDVariable	SDVariable.divi(SDVariable sameDiffVariable)
SDVariable	SDVariable.divi(String varName, double sameDiffVariable)
SDVariable	SDVariable.divi(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.dot(SDVariable x, SDVariable y, int... dimensions) TODO doc string
SDVariable	SameDiff.dot(String name, SDVariable x, SDVariable y, int... dimensions) TODO doc string
SDVariable	SameDiff.dropout(SDVariable input, double inputRetainProbability)
SDVariable	SameDiff.dropout(String name, SDVariable input, double inputRetainProbability)
SDVariable	SDVariable.dup()
SDVariable[]	SameDiff.dynamicPartition(SDVariable x, SDVariable partitions, int numPartitions)
SDVariable[]	SameDiff.dynamicPartition(String[] name, SDVariable x, SDVariable partitions, int numPartitions) Dynamically partition the input variable values into the specified number of paritions, using the indices. Example:
SDVariable	SameDiff.dynamicStitch(SDVariable[] indices, SDVariable[] x)
SDVariable	SameDiff.dynamicStitch(String name, SDVariable[] indices, SDVariable[] x) Dynamically merge the specified input arrays into a single array, using the specified indices
SDVariable	SameDiff.elu(SDVariable x) Element-wise exponential linear unit (ELU) function: out = x if x > 0 out = a * (exp(x) - 1) if x <= 0 with constant a = 1.0
SDVariable	SameDiff.elu(String name, SDVariable x) Element-wise exponential linear unit (ELU) function: out = x if x > 0 out = a * (exp(x) - 1) if x <= 0 with constant a = 1.0
SDVariable	SameDiff.eluDerivative(SDVariable x) Element-wise derivative exponential linear unit (ELU) function, dOut/dIn given input.
SDVariable	SameDiff.eluDerivative(String name, SDVariable x) Element-wise derivative exponential linear unit (ELU) function, dOut/dIn given input.
SDVariable	SameDiff.entropy(SDVariable in, int... dimensions) Entropy reduction: -sum(x * log(x))
SDVariable	SameDiff.entropy(String name, SDVariable in, int... dimensions) Entropy reduction: -sum(x * log(x))
SDVariable	SDVariable.eq(double value)
SDVariable	SDVariable.eq(SDVariable other)
SDVariable	SameDiff.eq(SDVariable x, double y) Equals operation: elementwise x == y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.eq(SDVariable x, SDVariable y) Equal to operation: elementwise x == y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.eq(String name, double value)
SDVariable	SDVariable.eq(String name, SDVariable other)
SDVariable	SameDiff.eq(String name, SDVariable x, double y) Equals operation: elementwise x == y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.eq(String name, SDVariable x, SDVariable y) Equal to operation: elementwise x == y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.erf(SDVariable x) Element-wise Gaussian error function - out = erf(in)
SDVariable	SameDiff.erf(String name, SDVariable x) Element-wise Gaussian error function - out = erf(in)
SDVariable	SameDiff.erfc(SDVariable x) Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
SDVariable	SameDiff.erfc(String name, SDVariable x) Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
SDVariable	SameDiff.euclideanDistance(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.euclideanDistance(String name, SDVariable x, SDVariable y, int... dimensions) Euclidean distance (l2 norm, l2 distance) reduction operation.
SDVariable	SameDiffConditional.eval(SameDiff context, SameDiffFunctionDefinition body, SDVariable[] inputVars)
SDVariable	SameDiff.exp(SDVariable x) Elementwise exponent function: out = exp(x) = 2.71828...^x
SDVariable	SameDiff.exp(String name, SDVariable x) Elementwise exponent function: out = exp(x) = 2.71828...^x
SDVariable	SameDiff.expandDims(SDVariable x, int axis)
SDVariable	SameDiff.expandDims(String name, SDVariable x, int axis) Reshape the input by adding a 1 at the specified location. For example, if input has shape [a, b], then output shape is: axis = 0: [1, a, b] axis = 1: [a, 1, b] axis = 2: [a, b, 1]
SDVariable	SameDiff.expm1(SDVariable x) Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
SDVariable	SameDiff.expm1(String name, SDVariable x) Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
SDVariable	SameDiff.eye(int rows) Generate a square identity matrix with the specified number of rows.
SDVariable	SameDiff.eye(int rows, int cols)
SDVariable	SameDiff.eye(int rows, int cols, int... batchDimension) see SameDiff.eye(String, int, int, int...)
SDVariable	SameDiff.eye(SDVariable rows) As per SameDiff.eye(int) but with the number of rows specified as a scalar SDVariable
SDVariable	SameDiff.eye(SDVariable rows, SDVariable cols) As per SameDiff.eye(int, int) bit with the number of rows/columns specified as scalar SDVariables
SDVariable	SameDiff.eye(SDVariable rows, SDVariable cols, SDVariable batchDimension) As per SameDiff.eye(int, int, int...) bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
SDVariable	SameDiff.eye(String name, int rows) Generate an identity matrix with the specified number of rows and columns.
SDVariable	SameDiff.eye(String name, int rows, int cols) Generate an identity matrix with the specified number of rows and columns Example:
SDVariable	SameDiff.eye(String name, int rows, int cols, int... batchDimension) Generate an identity matrix with the specified number of rows and columns, with optional leading dims Example: batchShape: [3,3] numRows: 2 numCols: 4 returns a tensor of shape (3, 3, 2, 4) that consists of 3 * 3 batches of (2,4)-shaped identity matrices: 1 0 0 0 0 1 0 0
SDVariable	SameDiff.eye(String name, SDVariable rows) As per SameDiff.eye(String, int) but with the number of rows specified as a scalar SDVariable
SDVariable	SameDiff.eye(String name, SDVariable rows, SDVariable cols) As per SameDiff.eye(String, int, int) bit with the number of rows/columns specified as scalar SDVariables
SDVariable	SameDiff.eye(String name, SDVariable rows, SDVariable cols, SDVariable batchDimension) As per SameDiff.eye(String, int, int, int...) bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
SDVariable	SameDiff.fill(SDVariable shape, double value) Generate an output variable with the specified (dynamic) shape with all elements set to the specified value
SDVariable	SameDiff.fill(String name, SDVariable shape, double value) Generate an output variable with the specified (dynamic) shape with all elements set to the specified value
SDVariable	SameDiff.firstIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)
SDVariable	SameDiff.firstIndex(SDVariable in, Condition condition, int... dimensions)
SDVariable	SameDiff.firstIndex(String name, SDVariable in, Condition condition, boolean keepDims, int... dimensions) First index reduction operation. Returns a variable that contains the index of the first element that matches the specified condition (for each slice along the specified dimensions) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.firstIndex(String name, SDVariable in, Condition condition, int... dimensions) First index reduction operation. Returns a variable that contains the index of the first element that matches the specified condition (for each slice along the specified dimensions)
SDVariable	SameDiff.floor(SDVariable x) Element-wise floor function: out = floor(x).
SDVariable	SameDiff.floor(String name, SDVariable x) Element-wise floor function: out = floor(x).
SDVariable	SameDiff.gather(SDVariable df, int[] indices, int axis)
SDVariable	SameDiff.gather(SDVariable df, SDVariable indices, int axis)
SDVariable	SameDiff.gather(String name, SDVariable df, int[] indices, int axis) Gather slices from the input variable where the indices are specified as fixed int[] values. Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.
SDVariable	SameDiff.gather(String name, SDVariable df, SDVariable indices, int axis) Gather slices from the input variable where the indices are specified as dynamic SDVariable values. Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.
SDVariable	SameDiff.gatherNd(SDVariable df, SDVariable indices) TODO doc string
SDVariable	SameDiff.gatherNd(String name, SDVariable df, SDVariable indices) TODO doc string
SDVariable[]	SameDiff.generateOutputVariableForOp(DifferentialFunction function) Generate the variables based on the given input op and return the output variable names.
SDVariable[]	SameDiff.generateOutputVariableForOp(DifferentialFunction function, String baseName) Generate the variables based on the given input op and return the output variable names.
SDVariable	SDVariable.get(SDIndex... indices)
SDVariable	SameDiff.getForwardVariableForVertexId(int vertexId) Get the forward variable for gradient based on the gradient's vertex id
SDVariable	SameDiff.getGradForVariable(String varName) Get the gradient for the given vertex id
SDVariable	SDVariable.getGradient() A getter for the variable gradient.
SDVariable[]	SameDiff.getInputVariablesForFunction(DifferentialFunction function) Get the input variable(s) for the specified differential function
SDVariable[]	SameDiff.getOutputVariablesForFunction(DifferentialFunction function) Get the output variable(s) for the specified differential function
SDVariable	SameDiff.getVariable(String name) Get the variable based on the opName
SDVariable	SameDiff.grad(String varName) Get the gradient for the variable with the specified variable name.
SDVariable	SDVariable.gradient() Nicer looking alias for the gradient variable.
SDVariable	SameDiff.gradientBackwardsMarker(SDVariable x) Intended for internal/developer use
SDVariable	SameDiff.gradientBackwardsMarker(String name, SDVariable x) Intended for internal/developer use
SDVariable	SameDiff.gru(GRUCellConfiguration configuration) The gru cell
SDVariable	SameDiff.gru(String baseName, GRUCellConfiguration configuration) The gru cell
SDVariable	SDVariable.gt(double value)
SDVariable	SDVariable.gt(SDVariable other)
SDVariable	SameDiff.gt(SDVariable x, double y) Greater than operation: elementwise x > y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.gt(SDVariable x, SDVariable y) Greater than operation: elementwise x > y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.gt(String name, double value)
SDVariable	SDVariable.gt(String name, SDVariable other)
SDVariable	SameDiff.gt(String name, SDVariable x, double y) Greater than operation: elementwise x > y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.gt(String name, SDVariable x, SDVariable y) Greater than operation: elementwise x > y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.gte(double value)
SDVariable	SDVariable.gte(SDVariable other)
SDVariable	SameDiff.gte(SDVariable x, double y) Greater than or equals operation: elementwise x >= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.gte(SDVariable x, SDVariable y) Greater than or equal to operation: elementwise x >= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.gte(String name, double value)
SDVariable	SDVariable.gte(String name, SDVariable other)
SDVariable	SameDiff.gte(String name, SDVariable x, double y) Greater than or equals operation: elementwise x >= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.gte(String name, SDVariable x, SDVariable y) Greater than or equal to operation: elementwise x >= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.hammingDistance(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.hammingDistance(String name, SDVariable x, SDVariable y, int... dimensions) Hamming distance reduction operation.
SDVariable	SameDiff.hardSigmoid(SDVariable in) Element-wise hard sigmoid function: out[i] = 0 if in[i] <= -2.5 out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5 out[i] = 1 if in[i] >= 2.5
SDVariable	SameDiff.hardSigmoid(String name, SDVariable in) Element-wise hard sigmoid function: out[i] = 0 if in[i] <= -2.5 out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5 out[i] = 1 if in[i] >= 2.5
SDVariable	SameDiff.hardTanh(SDVariable in) Element-wise hard tanh function: out[i] = -1 if in[i] <= -1 out[1] = in[i] if -1 < in[i] < 1 out[i] = 1 if in[i] >= 1
SDVariable	SameDiff.hardTanh(String name, SDVariable in) Element-wise hard tanh function: out[i] = -1 if in[i] <= -1 out[1] = in[i] if -1 < in[i] < 1 out[i] = 1 if in[i] >= 1
SDVariable	SameDiff.hardTanhDerivative(SDVariable x) Derivative (dOut/dIn) of the element-wise hard Tanh function - SameDiff.hardTanh(SDVariable)
SDVariable	SameDiff.hardTanhDerivative(String name, SDVariable x) Derivative (dOut/dIn) of the element-wise hard Tanh function - SameDiff.hardTanh(SDVariable)
SDVariable	SameDiff.iamax(SDVariable in, boolean keepDims, int... dimensions) Index of the max absolute value: argmax(abs(in))
SDVariable	SameDiff.iamax(SDVariable in, int... dimensions) Index of the max absolute value: argmax(abs(in))
SDVariable	SameDiff.iamax(String name, SDVariable in, boolean keepDims, int... dimensions) Index of the max absolute value: argmax(abs(in))
SDVariable	SameDiff.iamax(String name, SDVariable in, int... dimensions) Index of the max absolute value: argmax(abs(in))
SDVariable	SameDiff.iamin(SDVariable in, boolean keepDims, int... dimensions) Index of the min absolute value: argmin(abs(in))
SDVariable	SameDiff.iamin(SDVariable in, int... dimensions) Index of the min absolute value: argmin(abs(in))
SDVariable	SameDiff.iamin(String name, SDVariable in, boolean keepDims, int... dimensions) Index of the min absolute value: argmin(abs(in))
SDVariable	SameDiff.iamin(String name, SDVariable in, int... dimensions) Index of the min absolute value: argmin(abs(in))
SDVariable	SameDiff.identity(SDVariable input) Elementwise identity operation: out = x
SDVariable	SameDiff.identity(String name, SDVariable input) Elementwise identity operation: out = x
SDVariable	SameDiff.im2Col(SDVariable in, Conv2DConfig config) im2col operation for use in 2D convolution operations.
SDVariable	SameDiff.im2Col(String name, SDVariable in, Conv2DConfig config) im2col operation for use in 2D convolution operations.
SDVariable	SameDiff.invertPermutation(SDVariable input) Compute the inverse permutation indices for a permutation operation Example: if input is [2, 0, 1] then output is [1, 2, 0] The idea is that x.permute(input).permute(invertPermutation(input)) == x
SDVariable	SameDiff.invertPermutation(String name, SDVariable input) Compute the inverse permutation indices for a permutation operation Example: if input is [2, 0, 1] then output is [1, 2, 0] The idea is that x.permute(input).permute(invertPermutation(input)) == x
SDVariable	SameDiff.invoke(Op op, SDVariable x) Invoke an op by opName
SDVariable	SameDiff.invoke(Op op, SDVariable x, SDVariable y) Invoke an op by opName
SDVariable	SameDiff.invokeFunctionOn(String functionName, SameDiff with)
SDVariable	SameDiff.invokeGraphOn(SameDiff sameDiff)
SDVariable	SameDiff.isFinite(SDVariable x) Is finite operation: elementwise isFinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isFinite(String name, SDVariable x) Is finite operation: elementwise isFinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isInfinite(SDVariable x) Is infinite operation: elementwise isInfinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isInfinite(String name, SDVariable x) Is infinite operation: elementwise isInfinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isMax(SDVariable x) Is maximum operation: elementwise x == max(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isMax(String name, SDVariable x) Is maximum operation: elementwise x == max(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isNaN(SDVariable x) Is Not a Number operation: elementwise isNaN(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isNaN(String name, SDVariable x) Is Not a Number operation: elementwise isNaN(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isNonDecreasing(SDVariable x) Is the array non decreasing? An array is non-decreasing if for every valid i, x[i] <= x[i+1].
SDVariable	SameDiff.isNonDecreasing(String name, SDVariable x) Is the array non decreasing? An array is non-decreasing if for every valid i, x[i] <= x[i+1].
SDVariable	SameDiff.isNumericTensor(SDVariable x) Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1
SDVariable	SameDiff.isNumericTensor(String name, SDVariable x) Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1
SDVariable	SameDiff.isStrictlyIncreasing(SDVariable x) Is the array strictly increasing? An array is strictly increasing if for every valid i, x[i] < x[i+1].
SDVariable	SameDiff.isStrictlyIncreasing(String name, SDVariable x) Is the array strictly increasing? An array is strictly increasing if for every valid i, x[i] < x[i+1].
SDVariable	SameDiff.jaccardDistance(SDVariable x, SDVariable y, int... dimensions) Jaccard similarity reduction operation.
SDVariable	SameDiff.jaccardDistance(String name, SDVariable x, SDVariable y, int... dimensions) Jaccard similarity reduction operation.
SDVariable	SameDiff.lastIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)
SDVariable	SameDiff.lastIndex(SDVariable in, Condition condition, int... dimensions)
SDVariable	SameDiff.lastIndex(String name, SDVariable in, Condition condition, boolean keepDims, int... dimensions) Last index reduction operation. Returns a variable that contains the index of the last element that matches the specified condition (for each slice along the specified dimensions) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.lastIndex(String name, SDVariable in, Condition condition, int... dimensions) Last index reduction operation. Returns a variable that contains the index of the last element that matches the specified condition (for each slice along the specified dimensions)
SDVariable	SameDiff.leakyRelu(SDVariable x, double alpha) Element-wise leaky ReLU function: out = x if x >= 0.0 out = alpha * x if x < cutoff Alpha value is most commonly set to 0.01
SDVariable	SameDiff.leakyRelu(String name, SDVariable x, double alpha) Element-wise leaky ReLU function: out = x if x >= 0.0 out = alpha * x if x < cutoff Alpha value is most commonly set to 0.01
SDVariable	SameDiff.leakyReluDerivative(String name, SDVariable x, double alpha) Leaky ReLU derivative: dOut/dIn given input. See SameDiff.leakyRelu(String, SDVariable, double)
SDVariable	SameDiff.linear(SDVariable input, SDVariable weights, SDVariable bias)
SDVariable	SameDiff.linear(String name, SDVariable input, SDVariable weights, SDVariable bias) Linear layer operation: out = mmul(in,w) + bias Note that bias array is optional
SDVariable	SameDiff.linspace(double start, double stop, long number) Create a new 1d array with values evenly spaced between values 'start' and 'stop' For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0]
SDVariable	SameDiff.linspace(String name, double start, double stop, long number) Create a new 1d array with values evenly spaced between values 'start' and 'stop' For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0]
SDVariable	SameDiff.localResponseNormalization(SDVariable inputs, LocalResponseNormalizationConfig lrnConfig) 2D convolution layer operation - local response normalization
SDVariable	SameDiff.localResponseNormalization(String name, SDVariable input, LocalResponseNormalizationConfig lrnConfig) 2D convolution layer operation - local response normalization
SDVariable	SameDiff.log(SDVariable x) Element-wise logarithm function (base e - natural logarithm): out = log(x)
SDVariable	SameDiff.log(SDVariable in, double base) Element-wise logarithm function (with specified base): out = log_{base}(x)
SDVariable	SameDiff.log(String name, SDVariable x) Element-wise logarithm function (base e - natural logarithm): out = log(x)
SDVariable	SameDiff.log(String name, SDVariable in, double base) Element-wise logarithm function (with specified base): out = log_{base}(x)
SDVariable	SameDiff.log1p(SDVariable x) Elementwise natural logarithm function: out = log_e (1 + x)
SDVariable	SameDiff.log1p(String name, SDVariable x) Elementwise natural logarithm function: out = log_e (1 + x)
SDVariable	SameDiff.logEntropy(SDVariable in, int... dimensions) Log entropy reduction: log(-sum(x * log(x)))
SDVariable	SameDiff.logEntropy(String name, SDVariable in, int... dimensions) Log entropy reduction: log(-sum(x * log(x)))
SDVariable	SameDiff.logSigmoid(SDVariable x) Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))
SDVariable	SameDiff.logSigmoid(String name, SDVariable x) Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))
SDVariable	SameDiff.logSoftmax(SDVariable x) Log softmax activation
SDVariable	SameDiff.logSoftmax(String name, SDVariable x) Log softmax activation
SDVariable	SameDiff.logSumExp(SDVariable input, int... dimensions) Log-sum-exp reduction (optionally along dimension).
SDVariable	SameDiff.logSumExp(String name, SDVariable input, int... dimensions) Log-sum-exp reduction (optionally along dimension).
SDVariable	SameDiff.lossBinaryXENT(SDVariable x, SDVariable y, int... dimensions) Binary cross entropy loss.
SDVariable	SameDiff.lossBinaryXENT(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossCosineSimilarity(SDVariable x, SDVariable y, int... dimensions) TODO doc string
SDVariable	SameDiff.lossCosineSimilarity(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossHinge(SDVariable x, SDVariable y, int... dimensions) Hinge loss
SDVariable	SameDiff.lossHinge(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossKLD(SDVariable x, SDVariable y, int... dimensions) Kullback-Leibler divergence loss
SDVariable	SameDiff.lossKLD(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossL1(SDVariable x, SDVariable y, int... dimensions) L1 loss
SDVariable	SameDiff.lossL1(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossL2(SDVariable x, SDVariable y, int... dimensions) L2 loss
SDVariable	SameDiff.lossL2(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMAE(SDVariable x, SDVariable y, int... dimensions) Mean absolute error loss
SDVariable	SameDiff.lossMAE(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMCXENT(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMCXENT(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMSE(SDVariable x, SDVariable y, int... dimensions) Mean squared error loss
SDVariable	SameDiff.lossMSE(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMSLE(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMSLE(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossNegativeLogLikelihood(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossNegativeLogLikelihood(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossPoisson(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossPoisson(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossSquaredHinge(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossSquaredHinge(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lstm(String baseName, LSTMCellConfiguration configuration) LSTM unit
SDVariable	SDVariable.lt(double value)
SDVariable	SDVariable.lt(SDVariable other)
SDVariable	SameDiff.lt(SDVariable x, double y) Less than operation: elementwise x < y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.lt(SDVariable x, SDVariable y) Less than operation: elementwise x < y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.lt(String name, double value)
SDVariable	SDVariable.lt(String name, SDVariable other)
SDVariable	SameDiff.lt(String name, SDVariable x, double y) Less than operation: elementwise x < y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.lt(String name, SDVariable x, SDVariable y) Less than operation: elementwise x < y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.lte(double value)
SDVariable	SDVariable.lte(SDVariable other)
SDVariable	SameDiff.lte(SDVariable x, double y) Less than or equals operation: elementwise x <= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.lte(SDVariable x, SDVariable y) Less than or equal to operation: elementwise x <= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.lte(String name, double value)
SDVariable	SDVariable.lte(String name, SDVariable other)
SDVariable	SameDiff.lte(String name, SDVariable x, double y) Less than or equals operation: elementwise x <= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.lte(String name, SDVariable x, SDVariable y) Less than or equal to operation: elementwise x <= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.manhattanDistance(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.manhattanDistance(String name, SDVariable x, SDVariable y, int... dimensions) Manhattan distance (l1 norm, l1 distance) reduction operation.
SDVariable	SameDiff.matchCondition(SDVariable in, Condition condition) Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
SDVariable	SameDiff.matchCondition(String name, SDVariable in, Condition condition) Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
SDVariable	SameDiff.matchConditionCount(SDVariable in, Condition condition) Returns a count of the number of elements that satisfy the condition
SDVariable	SameDiff.matchConditionCount(String name, SDVariable in, Condition condition) Returns a count of the number of elements that satisfy the condition
SDVariable	SameDiff.matchConditionCount(String name, SDVariable in, Condition condition, boolean keepDim, int... dimensions) Returns a count of the number of elements that satisfy the condition (for each slice along the specified dimensions) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.matrixDeterminant(SDVariable in)
SDVariable	SameDiff.matrixDeterminant(String name, SDVariable in) Matrix determinant op.
SDVariable	SameDiff.matrixInverse(SDVariable in)
SDVariable	SameDiff.matrixInverse(String name, SDVariable in) Matrix inverse op.
SDVariable	SDVariable.max(boolean keepDims, int... dimensions)
SDVariable	SDVariable.max(int... dimensions)
SDVariable	SameDiff.max(SDVariable x, int... dimensions) Max array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.max(SDVariable first, SDVariable second) Element-wise maximum operation: out[i] = max(first[i], second[i]) Supports broadcasting
SDVariable	SDVariable.max(String name, boolean keepDims, int... dimensions)
SDVariable	SDVariable.max(String name, int... dimensions)
SDVariable	SameDiff.max(String name, SDVariable x, boolean keepDims, int... dimensions) Max array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.max(String name, SDVariable x, int... dimensions) Max array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.max(String name, SDVariable first, SDVariable second) Element-wise maximum operation: out[i] = max(first[i], second[i]) Supports broadcasting
SDVariable	SameDiff.maxPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig) 2D Convolution layer operation - max pooling 2d
SDVariable	SameDiff.maxPooling2d(String name, SDVariable input, Pooling2DConfig pooling2DConfig) 2D Convolution layer operation - max pooling 2d
SDVariable	SameDiff.maxPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig) 3D convolution layer operation - max pooling 3d operation.
SDVariable	SameDiff.maxPooling3d(String name, SDVariable input, Pooling3DConfig pooling3DConfig) 3D convolution layer operation - max pooling 3d operation.
SDVariable	SDVariable.mean(boolean keepDims, int... dimensions)
SDVariable	SDVariable.mean(int... dimensions)
SDVariable	SameDiff.mean(SDVariable x) Full array mean reduction operation
SDVariable	SameDiff.mean(SDVariable x, int... dimension) Mean (average) array reduction operation, optionally along specified dimensions
SDVariable	SDVariable.mean(String name, boolean keepDims, int... dimensions)
SDVariable	SDVariable.mean(String name, int... dimensions)
SDVariable	SameDiff.mean(String name, SDVariable x, boolean keepDims, int... dimension) Mean (average) array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.mean(String name, SDVariable x, int... dimension) Mean (average) array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.mergeAdd(SDVariable... x) Merge add function: merges an arbitrary number of equal shaped arrays using elementwise addition: out = sum_i in[i]
SDVariable	SameDiff.mergeAdd(String name, SDVariable... inputs) Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition: out = sum_i in[i]
SDVariable	SameDiff.mergeAvg(SDVariable... inputs) Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
SDVariable	SameDiff.mergeAvg(String name, SDVariable... inputs) Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
SDVariable	SameDiff.mergeMax(SDVariable... x) Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
SDVariable	SameDiff.mergeMax(String name, SDVariable... inputs) Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
SDVariable[]	SameDiff.meshgrid(List<String> names, boolean cartesian, SDVariable... inputs)
SDVariable[]	SameDiff.meshgrid(List<String> names, SDVariable... inputs) Broadcast the 1D input variables onto an n-dimensional grid. The resulting variable can be used for example for evaluating functions at all locations on a grid. Example:
SDVariable[]	SameDiff.meshgrid(SDVariable... inputs)
SDVariable	SDVariable.min(boolean keepDims, int... dimensions)
SDVariable	SDVariable.min(int... dimensions)
SDVariable	SameDiff.min(SDVariable x, int... dimensions) Minimum array reduction operation, optionally along specified dimensions.
SDVariable	SameDiff.min(SDVariable first, SDVariable second) Element-wise minimum operation: out[i] = min(first[i], second[i]) Supports broadcasting
SDVariable	SDVariable.min(String name, boolean keepDims, int... dimensions)
SDVariable	SDVariable.min(String name, int... dimensions)
SDVariable	SameDiff.min(String name, SDVariable x, boolean keepDims, int... dimensions) Minimum array reduction operation, optionally along specified dimensions.
SDVariable	SameDiff.min(String name, SDVariable x, int... dimensions) Minimum array reduction operation, optionally along specified dimensions.
SDVariable	SameDiff.min(String name, SDVariable first, SDVariable second) Element-wise minimum operation: out[i] = min(first[i], second[i]) Supports broadcasting
SDVariable	SDVariable.mmul(SDVariable other)
SDVariable	SameDiff.mmul(SDVariable x, SDVariable y) Matrix multiplication: out = mmul(x,y)
SDVariable	SameDiff.mmul(SDVariable x, SDVariable y, MMulTranspose transpose) Matrix multiplication: out = mmul(x,y) Supports specifying a MMulTranspose argument to perform operation such as mmul(a^T, b), etc.
SDVariable	SameDiff.mmul(String name, SDVariable x, SDVariable y) Matrix multiplication: out = mmul(x,y)
SDVariable	SameDiff.mmul(String name, SDVariable x, SDVariable y, MMulTranspose transpose) Matrix multiplication: out = mmul(x,y) Supports specifying a MMulTranspose argument to perform operation such as mmul(a^T, b), etc.
SDVariable[]	SameDiff.moments(SDVariable input, int... axes)
SDVariable[]	SameDiff.moments(String[] name, SDVariable input, int... axes) Calculate the mean and (population) variance for the input variable, for the specified axis
SDVariable	SDVariable.mul(double sameDiffVariable)
SDVariable	SDVariable.mul(SDVariable sameDiffVariable)
SDVariable	SDVariable.mul(String varName, double value)
SDVariable	SDVariable.mul(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.muli(double sameDiffVariable)
SDVariable	SDVariable.muli(SDVariable sameDiffVariable)
SDVariable	SDVariable.muli(String varName, double sameDiffVariable)
SDVariable	SDVariable.muli(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.neg() Negate op
SDVariable	SameDiff.neg(SDVariable x) Elementwise negative operation: out = -x
SDVariable	SDVariable.neg(String name) Negate op
SDVariable	SameDiff.neg(String name, SDVariable x) Elementwise negative operation: out = -x
SDVariable	SDVariable.neq(double value)
SDVariable	SDVariable.neq(SDVariable other)
SDVariable	SameDiff.neq(SDVariable x, double y) Not equals operation: elementwise x != y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.neq(SDVariable x, SDVariable y) Not equal to operation: elementwise x != y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.neq(String name, double value)
SDVariable	SDVariable.neq(String name, SDVariable other)
SDVariable	SameDiff.neq(String name, SDVariable x, double y) Not equals operation: elementwise x != y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.neq(String name, SDVariable x, SDVariable y) Not equal to operation: elementwise x != y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.norm1(boolean keepDims, int... dimensions)
SDVariable	SDVariable.norm1(int... dimensions)
SDVariable	SDVariable.norm1(String name, boolean keepDims, int... dimensions)
SDVariable	SDVariable.norm1(String name, int... dimensions)
SDVariable	SameDiff.norm1(String name, SDVariable x, boolean keepDims, int... dimensions) Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions: out = sum_i abs(x[i]) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.norm1(String name, SDVariable x, int... dimensions) Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions: out = sum_i abs(x[i])
SDVariable	SDVariable.norm2(boolean keepDims, int... dimensions)
SDVariable	SDVariable.norm2(int... dimensions)
SDVariable	SDVariable.norm2(String name, boolean keepDims, int... dimensions)
SDVariable	SDVariable.norm2(String name, int... dimensions)
SDVariable	SameDiff.norm2(String name, SDVariable x, boolean keepDims, int... dimensions) Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions: out = sqrt(sum_i x[i]^2) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.norm2(String name, SDVariable x, int... dimensions) Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions: out = sqrt(sum_i x[i]^2)
SDVariable[]	SameDiff.normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)
SDVariable[]	SameDiff.normalizeMoments(String[] name, SDVariable counts, SDVariable means, SDVariable variances, double shift) Calculate the mean and variance from the sufficient statistics
SDVariable	SDVariable.normmax(boolean keepDims, int... dimensions)
SDVariable	SDVariable.normmax(int... dimensions)
SDVariable	SDVariable.normmax(String name, boolean keepDims, int... dimensions)
SDVariable	SDVariable.normmax(String name, int... dimensions)
SDVariable	SameDiff.normmax(String name, SDVariable x, boolean keepDims, int... dimensions) Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the specified dimensions: out = max(abs(x[i])) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.normmax(String name, SDVariable x, int... dimensions) Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the specified dimensions
SDVariable	SameDiff.one(String name, int[] shape) Create a new variable with the specified shape, with all values initialized to 1.0
SDVariable	SameDiff.one(String name, long[] shape) Create a new variable with the specified shape, with all values initialized to 1.0
SDVariable	SameDiff.oneHot(SDVariable indices, int depth)
SDVariable	SameDiff.oneHot(SDVariable indices, int depth, int axis, double on, double off)
SDVariable	SameDiff.oneHot(String name, SDVariable indices, int depth) Convert the array to a one-hot array with walues 0 and 1 for each entry If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with out[i, ..., j, in[i,...,j]] = 1 with other values being set to 0
SDVariable	SameDiff.oneHot(String name, SDVariable indices, int depth, int axis, double on, double off) Convert the array to a one-hot array with walues on and off for each entry If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with out[i, ..., j, in[i,...,j]] = on with other values being set to off
SDVariable	SameDiff.onesLike(SDVariable input) Return a variable of all 1s, with the same shape as the input variable.
SDVariable	SameDiff.onesLike(String name, SDVariable input) Return a variable of all 1s, with the same shape as the input variable.
SDVariable	SameDiff.or(SDVariable x, SDVariable y) Boolean OR operation: elementwise (x != 0) || (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.or(String name, SDVariable x, SDVariable y) Boolean OR operation: elementwise (x != 0) || (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable[]	SDVariable.outputVariables()
SDVariable[]	SDVariable.outputVariables(String baseName)
SDVariable	SameDiff.parallel_stack(SDVariable[] values)
SDVariable	SameDiff.parallel_stack(String name, SDVariable[] values)
SDVariable	SameDiff.permute(SDVariable x, int... dimensions) Array permutation operation: permute the dimensions according to the specified permutation indices. Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]
SDVariable	SameDiff.permute(String name, SDVariable x, int... dimensions) Array permutation operation: permute the dimensions according to the specified permutation indices. Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]
SDVariable	SDVariable.pow(double value)
SDVariable	SameDiff.pow(SDVariable x, double value) Element-wise power function: out = x^value
SDVariable	SDVariable.pow(String varName, double value)
SDVariable	SameDiff.pow(String name, SDVariable x, double value) Element-wise power function: out = x^value
SDVariable	SDVariable.prod(boolean keepDims, int... dimensions)
SDVariable	SDVariable.prod(int... dimensions)
SDVariable	SameDiff.prod(SDVariable x, int... dimensions) Product array reduction operation, optionally along specified dimensions
SDVariable	SDVariable.prod(String name, boolean keepDims, int... dimensions)
SDVariable	SDVariable.prod(String name, int... dimensions)
SDVariable	SameDiff.prod(String name, SDVariable x, boolean keepDims, int... dimensions) Product array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.prod(String name, SDVariable x, int... dimensions) Product array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.randomBernoulli(double p, long... shape)
SDVariable	SameDiff.randomBernoulli(double p, SDVariable shape)
SDVariable	SameDiff.randomBernoulli(String name, double p, long... shape) Generate a new random SDVariable, where values are randomly sampled according to a Bernoulli distribution, with the specified probability.
SDVariable	SameDiff.randomBernoulli(String name, double p, SDVariable shape) Generate a new random SDVariable, where values are randomly sampled according to a Bernoulli distribution, with the specified probability.
SDVariable	SameDiff.randomBinomial(int nTrials, double p, long... shape) Generate a new random SDVariable, where values are randomly sampled according to a Binomial distribution, with the specified number of trials and probability.
SDVariable	SameDiff.randomBinomial(String name, int nTrials, double p, long... shape) Generate a new random SDVariable, where values are randomly sampled according to a Binomial distribution, with the specified number of trials and probability.
SDVariable	SameDiff.randomExponential(double lambda, SDVariable shape) Generate a new random SDVariable, where values are randomly sampled according to a exponential distribution: P(x) = lambda * exp(-lambda * x)
SDVariable	SameDiff.randomExponential(String name, double lambda, SDVariable shape) Generate a new random SDVariable, where values are randomly sampled according to a exponential distribution: P(x) = lambda * exp(-lambda * x)
SDVariable	SameDiff.randomLogNormal(double mean, double stddev, long... shape)
SDVariable	SameDiff.randomLogNormal(String name, double mean, double stddev, long... shape) Generate a new random SDVariable, where values are randomly sampled according to a Log Normal distribution, i.e., log(x) ~ N(mean, stdev)
SDVariable	SameDiff.randomNormal(double mean, double stddev, long... shape)
SDVariable	SameDiff.randomNormal(double mean, double stddev, SDVariable shape)
SDVariable	SameDiff.randomNormal(String name, double mean, double stddev, long... shape) Generate a new random SDVariable, where values are randomly sampled according to a Gaussian (normal) distribution, N(mean, stdev) See SameDiff.randomNormal(String, double, double, SDVariable) for the equivalent function where the shape is specified as a long[] instead
SDVariable	SameDiff.randomNormal(String name, double mean, double stddev, SDVariable shape) Generate a new random SDVariable, where values are randomly sampled according to a Gaussian (normal) distribution, N(mean, stdev) See SameDiff.randomNormal(String, double, double, long...) for the equivalent function where the shape is specified as a long[] instead
SDVariable	SameDiff.randomNormalTruncated(double mean, double stddev, long... shape)
SDVariable	SameDiff.randomNormalTruncated(String name, double mean, double stddev, long... shape) Generate a new random SDVariable, where values are randomly sampled according to a Gaussian (normal) distribution, N(mean, stdev).
SDVariable	SameDiff.randomUniform(double min, double max, long... shape)
SDVariable	SameDiff.randomUniform(double min, double max, SDVariable shape)
SDVariable	SameDiff.randomUniform(String name, double min, double max, long... shape) Generate a new random SDVariable, where values are randomly sampled according to a uniform distribution, U(min,max) See SameDiff.randomUniform(double, double, long...) for the equivalent function where the shape is specified as a SDVariable instead
SDVariable	SameDiff.randomUniform(String name, double min, double max, SDVariable shape) Generate a new random SDVariable, where values are randomly sampled according to a uniform distribution, U(min,max) See SameDiff.randomUniform(double, double, long...) for the equivalent function where the shape is specified as a long[] instead
SDVariable	SameDiff.range(double from, double to, double step) Create a new variable with a 1d array, where the values start at from and increment by step up to (but not including) limit. For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5]
SDVariable	SameDiff.range(String name, double from, double to, double step) Create a new variable with a 1d array, where the values start at from and increment by step up to (but not including) limit. For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5]
SDVariable	SameDiff.rank(SDVariable in) Returns the rank (number of dimensions, i.e., length(shape)) of the specified SDVariable as a 0D scalar variable
SDVariable	SameDiff.rank(String name, SDVariable in) Returns the rank (number of dimensions, i.e., length(shape)) of the specified SDVariable as a 0D scalar variable
SDVariable	SDVariable.rdiv(double sameDiffVariable)
SDVariable	SDVariable.rdiv(SDVariable sameDiffVariable)
SDVariable	SDVariable.rdiv(String varName, double sameDiffVariable)
SDVariable	SDVariable.rdiv(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.rdivi(double sameDiffVariable)
SDVariable	SDVariable.rdivi(SDVariable sameDiffVariable)
SDVariable	SDVariable.rdivi(String varName, double sameDiffVariable)
SDVariable	SDVariable.rdivi(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.reciprocal(SDVariable a) Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
SDVariable	SameDiff.reciprocal(String name, SDVariable a) Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
SDVariable	SameDiff.relu(SDVariable x, double cutoff) Element-wise rectified linear function with specified cutoff: out[i] = in[i] if in[i] >= cutoff out[i] = 0 otherwise
SDVariable	SameDiff.relu(String name, SDVariable x, double cutoff) Element-wise rectified linear function with specified cutoff: out[i] = in[i] if in[i] >= cutoff out[i] = 0 otherwise
SDVariable	SameDiff.relu6(SDVariable x, double cutoff) Element-wise "rectified linear 6" function with specified cutoff: out[i] = min(max(in, cutoff), 6)
SDVariable	SameDiff.relu6(String name, SDVariable x, double cutoff) Element-wise "rectified linear 6" function with specified cutoff: out[i] = min(max(in, cutoff), 6)
SDVariable	SameDiff.reluLayer(SDVariable input, SDVariable weights, SDVariable bias)
SDVariable	SameDiff.reluLayer(String name, SDVariable input, SDVariable weights, SDVariable bias) ReLU (Rectified Linear Unit) layer operation: out = relu(mmul(in,w) + bias) Note that bias array is optional
SDVariable	SameDiff.repeat(SDVariable df, int axis)
SDVariable	SameDiff.repeat(String name, SDVariable df, int axis)
SDVariable	SameDiff.replaceWhere(SDVariable update, Number value, Condition condition) Element-wise replace where condition: out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
SDVariable	SameDiff.replaceWhere(SDVariable update, SDVariable from, Condition condition) Element-wise replace where condition: out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
SDVariable	SameDiff.replaceWhere(String name, SDVariable update, Number value, Condition condition) Element-wise replace where condition: out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
SDVariable	SameDiff.replaceWhere(String name, SDVariable update, SDVariable from, Condition condition) Element-wise replace where condition: out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
SDVariable	SameDiff.reshape(SDVariable x, int... shape) Reshape the input variable to the specified (fixed) shape.
SDVariable	SameDiff.reshape(SDVariable x, long... shape) Reshape the input variable to the specified (fixed) shape.
SDVariable	SameDiff.reshape(SDVariable x, SDVariable shape) Reshape the input variable to the specified (dynamic) shape.
SDVariable	SameDiff.reshape(String name, SDVariable x, int... shape) Reshape the input variable to the specified (fixed) shape.
SDVariable	SameDiff.reshape(String name, SDVariable x, long... shape) Reshape the input variable to the specified (fixed) shape.
SDVariable	SameDiff.reshape(String name, SDVariable x, SDVariable shape) Reshape the input variable to the specified (dynamic) shape.
SDVariable	SameDiff.reverse(SDVariable x, int... dimensions)
SDVariable	SameDiff.reverse(String name, SDVariable x, int... dimensions) Reverse the values of an array for the specified dimensions If input is: [ 1, 2, 3] [ 4, 5, 6] then reverse(in, 0): [3, 2, 1] [6, 5, 4] reverse(in, 0): [4, 5, 6] [1, 2 3]
SDVariable	SameDiff.reverseSequence(SDVariable x, SDVariable seq_lengths)
SDVariable	SameDiff.reverseSequence(SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)
SDVariable	SameDiff.reverseSequence(String name, SDVariable x, SDVariable seq_lengths)
SDVariable	SameDiff.reverseSequence(String name, SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim) Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversed
SDVariable	SameDiff.rollAxis(SDVariable x, int axis)
SDVariable	SameDiff.rollAxis(String name, SDVariable x, int axis)
SDVariable	SameDiff.round(SDVariable x) Elementwise round function: out = round(x).
SDVariable	SameDiff.round(String name, SDVariable x) Element-wise round function: out = round(x).
SDVariable	SameDiff.rsqrt(SDVariable x) Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
SDVariable	SameDiff.rsqrt(String name, SDVariable x) Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
SDVariable	SDVariable.rsub(double sameDiffVariable)
SDVariable	SDVariable.rsub(SDVariable sameDiffVariable)
SDVariable	SDVariable.rsub(String varName, double sameDiffVariable)
SDVariable	SDVariable.rsub(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.rsubi(double sameDiffVariable)
SDVariable	SDVariable.rsubi(SDVariable sameDiffVariable)
SDVariable	SDVariable.rsubi(String varName, double sameDiffVariable)
SDVariable	SDVariable.rsubi(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.scalar(String name, double value) Create a new scalar (rank 0) SDVariable with the specified value
SDVariable	SameDiff.scalarFloorMod(SDVariable in, Number value) Element-wise scalar floor modulus operation: out = floorMod(in, value).
SDVariable	SameDiff.scalarFloorMod(String name, SDVariable in, Number value) Element-wise scalar floor modulus operation: out = floorMod(in, value).
SDVariable	SameDiff.scalarMax(SDVariable in, Number value) Element-wise scalar maximum operation: out = max(in, value)
SDVariable	SameDiff.scalarMax(String name, SDVariable in, Number value) Element-wise scalar maximum operation: out = max(in, value)
SDVariable	SameDiff.scalarMin(SDVariable in, Number value) Element-wise scalar minimum operation: out = min(in, value)
SDVariable	SameDiff.scalarMin(String name, SDVariable in, Number value) Element-wise scalar minimum operation: out = min(in, value)
SDVariable	SameDiff.scalarSet(SDVariable in, Number set) Return an array with equal shape to the input, but all elements set to value 'set'
SDVariable	SameDiff.scalarSet(String name, SDVariable in, Number set) Return an arary with equal shape to the input, but all elements set to value 'set'
SDVariable	SameDiff.scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterAdd(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter addition operation. If indices is rank 0 (a scalar), then out[index, ...] += updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] += updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] += updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterDiv(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter division operation. If indices is rank 0 (a scalar), then out[index, ...] /= updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] /= updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] /= updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterMax(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterMax(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter max operation. If indices is rank 0 (a scalar), then out[index, ...] = max(updates[...], in[index,...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = max(updates[i,...], in[indices[i],...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = max(updates[i, ..., k, ...], in[indices[i], ..., indices[k], ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterMin(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterMin(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter min operation. If indices is rank 0 (a scalar), then out[index, ...] = min(updates[...], in[index,...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = min(updates[i,...], in[indices[i],...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = min(updates[i, ..., k, ...], in[indices[i], ..., indices[k], ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterMul(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter multiplication operation. If indices is rank 0 (a scalar), then out[index, ...] *= updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] *= updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] *= updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterSub(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter subtraction operation. If indices is rank 0 (a scalar), then out[index, ...] -= updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] -= updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] -= updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterUpdate(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterUpdate(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter update operation. If indices is rank 0 (a scalar), then out[index, ...] = updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the output at those locations is undefined - different updates may occur in different orders
SDVariable	SameDiff.sconv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig) Separable 2D convolution operation with/without optional bias
SDVariable	SameDiff.sconv2d(String name, SDVariable[] inputs, Conv2DConfig conv2DConfig) Separable 2D convolution operation with/without optional bias
SDVariable	SameDiff.segmentMax(SDVariable data, SDVariable segmentIds)
SDVariable	SameDiff.segmentMax(String name, SDVariable data, SDVariable segmentIds) Segment max operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [max(3,6), max(1,4,9), max(2,8)
SDVariable	SameDiff.segmentMean(SDVariable data, SDVariable segmentIds)
SDVariable	SameDiff.segmentMean(String name, SDVariable data, SDVariable segmentIds) Segment mean operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [4.5, 4.666, 5] = [mean(3,6), mean(1,4,9), mean(2,8)
SDVariable	SameDiff.segmentMin(SDVariable data, SDVariable segmentIds)
SDVariable	SameDiff.segmentMin(String name, SDVariable data, SDVariable segmentIds) Segment min operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [3, 1, 2] = [min(3,6), min(1,4,9), min(2,8)
SDVariable	SameDiff.segmentProd(SDVariable data, SDVariable segmentIds)
SDVariable	SameDiff.segmentProd(String name, SDVariable data, SDVariable segmentIds) Segment product operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [18, 36, 16] = [prod(3,6), prod(1,4,9), prod(2,8)
SDVariable	SameDiff.segmentSum(SDVariable data, SDVariable segmentIds)
SDVariable	SameDiff.segmentSum(String name, SDVariable data, SDVariable segmentIds) Segment sum operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [9, 14, 10] = [sum(3,6), sum(1,4,9), sum(2,8)
SDVariable	SameDiff.selu(SDVariable x) Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0 Uses default lcale and alpha values.
SDVariable	SameDiff.selu(String name, SDVariable x) Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0 Uses default lcale and alpha values.
SDVariable	SameDiff.separableConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, Conv2DConfig config) Separable 2D convolution operation without bias
SDVariable	SameDiff.separableConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, SDVariable bias, Conv2DConfig config) Separable 2D convolution operation with optional bias
SDVariable	SameDiff.sequenceMask(SDVariable lengths)
SDVariable	SameDiff.sequenceMask(SDVariable lengths, int maxLen)
SDVariable	SameDiff.sequenceMask(SDVariable lengths, SDVariable maxLen)
SDVariable	SameDiff.sequenceMask(String name, SDVariable lengths)
SDVariable	SameDiff.sequenceMask(String name, SDVariable lengths, int maxLen)
SDVariable	SameDiff.sequenceMask(String name, SDVariable lengths, SDVariable maxLen) Generate a sequence mask (with values 0 or 1) based on the specified lengths Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)
SDVariable	SDVariable.setArray(INDArray array)
SDVariable	SameDiff.setDiag(SDVariable in, SDVariable diag)
SDVariable	SameDiff.setDiag(String name, SDVariable in, SDVariable diag) Set the diagonal value to the specified values If input is [ a, b, c] [ d, e, f] [ g, h, i] and diag = [ 1, 2, 3] then output is [ 1, b, c] [ d, 2, f] [ g, h, 3]
SDVariable	SameDiff.shannonEntropy(SDVariable in, int... dimensions) Shannon Entropy reduction: -sum(x * log2(x))
SDVariable	SameDiff.shannonEntropy(String name, SDVariable in, int... dimensions) Shannon Entropy reduction: -sum(x * log2(x))
SDVariable	SameDiff.shape(SDVariable input) Returns the shape of the specified SDVariable as a 1D SDVariable
SDVariable	SameDiff.shape(String name, SDVariable input) Returns the shape of the specified SDVariable as a 1D SDVariable
SDVariable	SameDiff.sigmoid(SDVariable x) Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))
SDVariable	SameDiff.sigmoid(String name, SDVariable x) Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))
SDVariable	SameDiff.sigmoidCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing) TODO
SDVariable	SameDiff.sigmoidCrossEntropyWithLogits(String name, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing) TODO
SDVariable	SameDiff.sigmoidDerivative(SDVariable x, SDVariable wrt) Element-wise sigmoid function derivative: dL/dIn given input and dL/dOut
SDVariable	SameDiff.sigmoidDerivative(String name, SDVariable x, SDVariable wrt) Element-wise sigmoid function derivative: dL/dIn given input and dL/dOut
SDVariable	SameDiff.sign(SDVariable x) Element-wise sign (signum) function: out = -1 if in < 0 out = 0 if in = 0 out = 1 if in > 0
SDVariable	SameDiff.sign(String name, SDVariable x) Element-wise sign (signum) function: out = -1 if in < 0 out = 0 if in = 0 out = 1 if in > 0
SDVariable	SameDiff.sin(SDVariable x) Elementwise sine operation: out = sin(x)
SDVariable	SameDiff.sin(String name, SDVariable x) Elementwise sine operation: out = sin(x)
SDVariable	SameDiff.sinh(SDVariable x) Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
SDVariable	SameDiff.sinh(String name, SDVariable x) Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
SDVariable	SameDiff.size(SDVariable in) Returns the size (number of elements, i.e., prod(shape)) of the specified SDVariable as a 0D scalar variable
SDVariable	SameDiff.size(String name, SDVariable in) Returns the size (number of elements, i.e., prod(shape)) of the specified SDVariable as a 0D scalar variable
SDVariable	SameDiff.sizeAt(SDVariable in, int dimension)
SDVariable	SameDiff.sizeAt(String name, SDVariable in, int dimension) Returns a rank 0 (scalar) variable for the size of the specified dimension.
SDVariable	SameDiff.slice(SDVariable input, int[] begin, int[] size)
SDVariable	SameDiff.slice(String name, SDVariable input, int[] begin, int[] size) Get a subset of the specified input, by specifying the first element and the size of the array. For example, if input is: [a, b, c] [d, e, f] then slice(input, begin=[0,1], size=[2,1] will return: [b] [e] Note that for each dimension i, begin[i] + size[i] <= input.size(i)
SDVariable	SameDiff.softmax(SDVariable x) Softmax activation
SDVariable	SameDiff.softmax(String name, SDVariable x) Softmax activation
SDVariable	SameDiff.softmaxCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing) TODO
SDVariable	SameDiff.softmaxCrossEntropyWithLogits(String name, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing) TODO
SDVariable	SameDiff.softmaxDerivative(String name, SDVariable x, SDVariable wrt)
SDVariable	SameDiff.softmaxDerivative(String name, SDVariable x, SDVariable wrt, Integer dimension)
SDVariable	SameDiff.softplus(SDVariable x) Element-wise softplus function: out = log(exp(x) + 1)
SDVariable	SameDiff.softplus(String name, SDVariable x) Element-wise softplus function: out = log(exp(x) + 1)
SDVariable	SameDiff.softsign(SDVariable x) Element-wise softsign function: out = x / (abs(x) + 1)
SDVariable	SameDiff.softsign(String name, SDVariable x) Element-wise softsign function: out = x / (abs(x) + 1)
SDVariable	SameDiff.softsignDerivative(SDVariable x) Element-wise derivative (dOut/dIn) of the softsign function SameDiff.softsign(SDVariable)
SDVariable	SameDiff.softsignDerivative(String name, SDVariable x) Element-wise derivative (dOut/dIn) of the softsign function SameDiff.softsign(SDVariable)
SDVariable	SameDiff.spaceToBatch(SDVariable x, int[] blocks, int[][] padding)
SDVariable	SameDiff.spaceToBatch(String name, SDVariable x, int[] blocks, int[][] padding) Convolution 2d layer space to batch operation on 4d input.
SDVariable	SameDiff.spaceToDepth(SDVariable x, int blockSize, String dataFormat)
SDVariable	SameDiff.spaceToDepth(String name, SDVariable x, int blockSize, String dataFormat) Convolution 2d layer space to depth operation on 4d input. Increases input channels (reduced spatial dimensions) by rearranging data into a larger channels dimension Example: if input has shape [mb, 2, 4, 4] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2] = [mb, 2, 4, 4]
SDVariable	SameDiff.sqrt(SDVariable x) Element-wise square root function: out = sqrt(x)
SDVariable	SameDiff.sqrt(String name, SDVariable x) Element-wise square root function: out = sqrt(x)
SDVariable	SameDiff.square(SDVariable x) Element-wise square function: out = x^2
SDVariable	SameDiff.square(String name, SDVariable x) Element-wise square function: out = x^2
SDVariable	SDVariable.squaredDifference(SDVariable sameDiffVariable)
SDVariable	SDVariable.squaredDifference(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.squaredNorm(SDVariable x, boolean keepDims, int... dimensions) Squared L2 norm: see SameDiff.norm2(String, SDVariable, boolean, int...)
SDVariable	SameDiff.squaredNorm(SDVariable x, int... dimensions) Squared L2 norm: see SameDiff.norm2(String, SDVariable, int...)
SDVariable	SameDiff.squaredNorm(String name, SDVariable x, boolean keepDims, int... dimensions) Squared L2 norm: see SameDiff.norm2(String, SDVariable, boolean, int...)
SDVariable	SameDiff.squaredNorm(String name, SDVariable x, int... dimensions) Squared L2 norm: see SameDiff.norm2(String, SDVariable, int...)
SDVariable	SameDiff.squeeze(SDVariable x, int axis)
SDVariable	SameDiff.squeeze(String name, SDVariable x, int axis) Remove a single dimension of size 1.
SDVariable	SameDiff.sru(SRUConfiguration configuration) Simple recurrent unit
SDVariable	SameDiff.sru(String baseName, SRUConfiguration configuration) Simiple recurrent unit
SDVariable	SameDiff.sruCell(SRUCellConfiguration configuration) An sru cell
SDVariable	SameDiff.sruCell(String baseName, SRUCellConfiguration configuration) An sru cell
SDVariable	SameDiff.stack(int axis, SDVariable... values)
SDVariable	SameDiff.stack(String name, int axis, SDVariable... values) Stack a set of N SDVariables of rank X into one rank X+1 variable.
SDVariable	SameDiff.standardDeviation(SDVariable x, boolean biasCorrected, int... dimensions)
SDVariable	SameDiff.standardDeviation(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions) Stardard deviation array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.standardDeviation(String name, SDVariable x, boolean biasCorrected, int... dimensions) Stardard deviation array reduction operation, optionally along specified dimensions
SDVariable	SDVariable.std(boolean biasCorrected, int... dimensions)
SDVariable	SDVariable.std(String name, boolean biasCorrected, boolean keepDims, int... dimensions)
SDVariable	SDVariable.std(String name, boolean biasCorrected, int... dimensions)
SDVariable	SameDiff.step(SDVariable in, double cutoff) Elementwise step function: out(x) = 1 if x >= cutoff out(x) = 0 otherwise
SDVariable	SameDiff.step(String name, SDVariable in, double cutoff) Elementwise step function: out(x) = 1 if x >= cutoff out(x) = 0 otherwise
SDVariable	SameDiff.stridedSlice(SDVariable input, int[] begin, int[] end, int[] strides)
SDVariable	SameDiff.stridedSlice(SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	SameDiff.stridedSlice(SDVariable input, long[] begin, long[] end, long[] strides)
SDVariable	SameDiff.stridedSlice(SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	SameDiff.stridedSlice(String name, SDVariable input, int[] begin, int[] end, int[] strides)
SDVariable	SameDiff.stridedSlice(String name, SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	SameDiff.stridedSlice(String name, SDVariable input, long[] begin, long[] end, long[] strides) Get a subset of the specified input, by specifying the first element, last element, and the strides. For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1]) will return: [b, c] [h, i]
SDVariable	SameDiff.stridedSlice(String name, SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask) Get a subset of the specified input, by specifying the first element, last element, and the strides. Operates as described in SameDiff.stridedSlice(SDVariable, long[], long[], long[]) with some extra mask arrays as described below.
SDVariable	SDVariable.sub(double sameDiffVariable)
SDVariable	SDVariable.sub(SDVariable sameDiffVariable)
SDVariable	SDVariable.sub(String varName, double sameDiffVariable)
SDVariable	SDVariable.sub(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.subi(double sameDiffVariable)
SDVariable	SDVariable.subi(SDVariable sameDiffVariable)
SDVariable	SDVariable.subi(String varName, double sameDiffVariable)
SDVariable	SDVariable.subi(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.sum(boolean keepDims, int... dimensions)
SDVariable	SDVariable.sum(int... dimensions)
SDVariable	SameDiff.sum(SDVariable x, boolean keepDims, int... dimensions)
SDVariable	SameDiff.sum(SDVariable x, int... dimensions) Sum array reduction operation, optionally along specified dimensions
SDVariable	SDVariable.sum(String name, boolean keepDims, int... dimensions)
SDVariable	SDVariable.sum(String name, int... dimensions)
SDVariable	SameDiff.sum(String name, SDVariable x, boolean keepDims, int... dimensions) Sum array reduction operation, optionally along specified dimensions. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.sum(String name, SDVariable x, int... dimensions) Sum array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.swish(SDVariable x) Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0 See: https://arxiv.org/abs/1710.05941
SDVariable	SameDiff.swish(String name, SDVariable x) Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0 See: https://arxiv.org/abs/1710.05941
SDVariable	SameDiff.tan(SDVariable x) Elementwise tangent operation: out = tan(x)
SDVariable	SameDiff.tan(String name, SDVariable x) Elementwise tangent operation: out = tan(x)
SDVariable	SameDiff.tanh(SDVariable x) Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
SDVariable	SameDiff.tanh(String name, SDVariable x) Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
SDVariable	SameDiff.tensorMmul(SDVariable x, SDVariable y, int[][] dimensions)
SDVariable	SameDiff.tensorMmul(String name, SDVariable x, SDVariable y, int[][] dimensions)
SDVariable	SameDiff.tile(SDVariable x, int[] repeat)
SDVariable	SameDiff.tile(String name, SDVariable x, int[] repeat) Repeat (tile) the input tensor the specified number of times. For example, if input is [1, 2] [3, 4] and repeat is [2, 3] then output is [1, 2, 1, 2, 1, 2] [3, 4, 3, 4, 3, 4] [1, 2, 1, 2, 1, 2] [3, 4, 3, 4, 3, 4]
SDVariable	SameDiff.trace(SDVariable in)
SDVariable	SameDiff.trace(String name, SDVariable in) Matrix trace operation For rank 2 matrices, the output is a scalar vith the trace - i.e., sum of the main diagonal. For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])
SDVariable	SameDiff.transpose(SDVariable x) Matrix transpose operation: If input has shape [a,b] output has shape [b,a]
SDVariable	SameDiff.transpose(String name, SDVariable x) Matrix transpose operation: If input has shape [a,b] output has shape [b,a]
SDVariable	SDVariable.truncatedDiv(SDVariable sameDiffVariable)
SDVariable	SDVariable.truncatedDiv(String varName, SDVariable sameDiffVariable)
SDVariable[]	SameDiff.unstack(SDVariable value, int axis)
SDVariable[]	SameDiff.unstack(SDVariable value, int axis, int num)
SDVariable[]	SameDiff.unstack(String[] names, SDVariable value, int axis)
SDVariable[]	SameDiff.unstack(String[] names, SDVariable value, int axis, int num) Unstack a variable of rank X into N rank X-1 variables by taking slices along the specified axis.
SDVariable	SameDiff.updateVariableNameAndReference(SDVariable varToUpdate, String newVarName) Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.
SDVariable[]	SameDiff.updateVariableNamesAndReferences(SDVariable[] variablesToUpdate, String[] newVariableNames) Updates the variable name property on the passed in variables, its reference in samediff, and returns the variable.
SDVariable	SameDiff.upsampling2d(SDVariable input, boolean nchw, int scaleH, int scaleW) 2D Convolution layer operation - Upsampling 2d
SDVariable	SameDiff.upsampling2d(SDVariable input, int scale) 2D Convolution layer operation - Upsampling 2d with same scale for both dimensions.
SDVariable	SameDiff.upsampling2d(String name, SDVariable input, boolean nchw, int scaleH, int scaleW) 2D Convolution layer operation - Upsampling 2d
SDVariable	SameDiff.upsampling2d(String name, SDVariable input, int scale) 2D Convolution layer operation - Upsampling 2d with same scale for both dimensions.
SDVariable	SameDiff.var(INDArray arr) Create an SDVariable with a generated name, and assocate the specified array with it
SDVariable	SameDiff.var(int... shape) Creates a SDVariable with the specified shape and a generated name Any array will be generated with all zeros for the values
SDVariable	SameDiff.var(long... shape) Creates a SDVariable with the specified shape and a generated name Any array will be generated with all zeros for the values
SDVariable	SameDiff.var(SDVariable arr) Initialize a SDVariable reference tying this variable to this samediff instance.
SDVariable	SameDiff.var(String name, INDArray arr) Create an SDVariable with the specified name, and assocate the specified array with it
SDVariable	SameDiff.var(String name, int... shape) Creates a SDVariable with the given shape and name Any array will be generated with all zeros for the values
SDVariable	SameDiff.var(String name, long... shape) Creates a SDVariable with the given shape and name Any array will be generated with all zeros for the values
SDVariable	SameDiff.var(String name, long[] shape, WeightInitScheme weightInitScheme) Variable initialization with a specified WeightInitScheme
SDVariable	SameDiff.var(WeightInitScheme weightInitScheme, long... shape) Creates a SDVariable with the specified shape and a generated name.
SDVariable	SameDiff.variance(SDVariable x, boolean biasCorrected, int... dimensions)
SDVariable	SameDiff.variance(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions) Variance array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.variance(String name, SDVariable x, boolean biasCorrected, int... dimensions) Variance array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.weightedCrossEntropyWithLogits(SDVariable targets, SDVariable inputs, SDVariable weights) TODO
SDVariable	SameDiff.weightedCrossEntropyWithLogits(String name, SDVariable targets, SDVariable inputs, SDVariable weights) TODO
SDVariable	SameDiff.xor(SDVariable x, SDVariable y) Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.xor(String name, SDVariable x, SDVariable y) Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.zero(String name, int[] shape) Create a new variable with the specified shape, with all values initialized to 0
SDVariable	SameDiff.zero(String name, long[] shape) Create a new variable with the specified shape, with all values initialized to 0
SDVariable	SameDiff.zeroFraction(SDVariable input) Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
SDVariable	SameDiff.zeroFraction(String name, SDVariable input) Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
SDVariable	SameDiff.zerosLike(SDVariable input) Return a variable of all 0s, with the same shape as the input variable.
SDVariable	SameDiff.zerosLike(String name, SDVariable input) Return a variable of all 0s, with the same shape as the input variable.

Methods in org.nd4j.autodiff.samediff that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	SDVariable.doDiff(List<SDVariable> f1)
org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>	SameDiff.exec() Execute the SameDiff instance using the current state After execution, the arrays for variables can be obtained using SameDiff.getArrForVarName(String) or getArr()
org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>	SameDiff.exec(String functionName) Execute the specified SameDiff function instance
org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>	SameDiff.execBackwards() Execute the gradient (backward pass) function on this graph. Constructs a backwards graph (differentiating the defined graph) if it does not already exist, and the executes the operations on that graph, calculating gradients for all variables. Note that after execBackwards() has completed, the gradient arrays for a each variable can be accessed using getGradient() followed by getArr() or by using SameDiff.getGradForVariable(String)
org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>	SameDiff.execWithPlaceHolder(Map<String,INDArray> inputs) Creates and executes a list of operations based on the given variables passed in. SameDiff.resolveVariablesWith(Map) is called
List<SDVariable>	SameDiff.getVariablesAssociatedWithFunctions(List<DifferentialFunction> functions) Get the SDVariable associated with each function based on the DifferentialFunction.outputVariables() ()}
Map<String,SDVariable>	SameDiff.variableMap() Return the internal variable map
List<SDVariable>	SameDiff.variables() The list of all variables in the graph

Methods in org.nd4j.autodiff.samediff with parameters of type SDVariable

Modifier and Type	Method and Description
SDVariable	SameDiff.abs(SDVariable x) Elementwise absolute value operation: out = abs(x)
SDVariable	SameDiff.abs(String name, SDVariable x) Elementwise absolute value operation: out = abs(x)
SDVariable	SameDiff.acos(SDVariable x) Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
SDVariable	SameDiff.acos(String name, SDVariable x) Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
SDVariable	SameDiff.acosh(SDVariable x) Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
SDVariable	SameDiff.acosh(String name, SDVariable x) Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
SDVariable	SDVariable.add(SDVariable sameDiffVariable)
SDVariable	SDVariable.add(String varName, SDVariable sameDiffVariable)
void	SameDiff.addArgsFor(SDVariable[] variables, DifferentialFunction function) Adds incoming arguments for the specified differential function to the graph
SDVariable	SDVariable.addi(SDVariable sameDiffVariable)
SDVariable	SDVariable.addi(String varName, SDVariable sameDiffVariable)
void	SameDiff.addOutgoingFor(SDVariable[] variables, DifferentialFunction function) Adds outgoing arguments to the graph for the specified DifferentialFunction Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
void	SameDiff.addVariable(SDVariable variable) Add the specified variable to this SameDiff instance
SDVariable	SameDiff.amax(SDVariable in, int... dimensions) Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
SDVariable	SameDiff.amax(String name, SDVariable in, int... dimensions) Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
SDVariable	SameDiff.amean(SDVariable in, int... dimensions) Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
SDVariable	SameDiff.amean(String name, SDVariable in, int... dimensions) Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
SDVariable	SameDiff.amin(SDVariable in, int... dimensions) Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
SDVariable	SameDiff.amin(String name, SDVariable in, int... dimensions) Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
SDVariable	SameDiff.and(SDVariable x, SDVariable y) Boolean AND operation: elementwise (x != 0) && (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.and(String name, SDVariable x, SDVariable y) Boolean AND operation: elementwise (x != 0) && (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.argmax(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	SameDiff.argmax(SDVariable in, int... dimensions) Argmax array reduction operation, optionally along specified dimensions. Output values are the index of the maximum value of each slice along the specified dimension
SDVariable	SameDiff.argmax(String name, SDVariable in, boolean keepDims, int... dimensions) Argmax array reduction operation, optionally along specified dimensions. Output values are the index of the maximum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.argmax(String name, SDVariable in, int... dimensions) Argmax array reduction operation, optionally along specified dimensions. Output values are the index of the maximum value of each slice along the specified dimension
SDVariable	SameDiff.argmin(SDVariable in, boolean keepDims, int... dimensions)
SDVariable	SameDiff.argmin(SDVariable in, int... dimensions) Argmin array reduction operation, optionally along specified dimensions. Output values are the index of the minimum value of each slice along the specified dimension
SDVariable	SameDiff.argmin(String name, SDVariable in, boolean keepDims, int... dimensions) Argmin array reduction operation, optionally along specified dimensions. Output values are the index of the minimum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.argmin(String name, SDVariable in, int... dimensions) Argmin array reduction operation, optionally along specified dimensions. Output values are the index of the minimum value of each slice along the specified dimension
SDVariable	SameDiff.asin(SDVariable x) Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
SDVariable	SameDiff.asin(String name, SDVariable x) Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
SDVariable	SameDiff.asinh(SDVariable x) Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
SDVariable	SameDiff.asinh(String name, SDVariable x) Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
SDVariable	SameDiff.assign(SDVariable in, Number value) Return an array with equal shape to the input, but all elements set to 'value'
SDVariable	SameDiff.assign(SDVariable x, SDVariable y) Assign/copy op: out = x.assign(y).
SDVariable	SameDiff.assign(String name, SDVariable in, Number value) Return an array with equal shape to the input, but all elements set to 'value'
SDVariable	SameDiff.assign(String name, SDVariable x, SDVariable y) Assign/copy op: out = x.assign(y).
void	SameDiff.associateArrayWithVariable(INDArray arr, SDVariable variable) Associate the array with the given variable.
SDVariable	SameDiff.asum(SDVariable in, int... dimensions) Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
SDVariable	SameDiff.asum(String name, SDVariable in, int... dimensions) Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
SDVariable	SameDiff.atan(SDVariable x) Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
SDVariable	SameDiff.atan(String name, SDVariable x) Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
SDVariable	SameDiff.atan2(SDVariable y, SDVariable x) Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
SDVariable	SameDiff.atan2(String name, SDVariable y, SDVariable x) Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
SDVariable	SameDiff.atanh(SDVariable x) Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
SDVariable	SameDiff.atanh(String name, SDVariable x) Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
SDVariable	SameDiff.avgPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig) 2D Convolution layer operation - average pooling 2d
SDVariable	SameDiff.avgPooling2d(String name, SDVariable input, Pooling2DConfig pooling2DConfig) 2D Convolution layer operation - average pooling 2d
SDVariable	SameDiff.avgPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig) 3D convolution layer operation - average pooling 3d
SDVariable	SameDiff.avgPooling3d(String name, SDVariable input, Pooling3DConfig pooling3DConfig) 3D convolution layer operation - average pooling 3d
SDVariable[]	SameDiff.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB) Matrix multiply a batch of matrices.
SDVariable[]	SameDiff.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB) Matrix multiply a batch of matrices.
SDVariable[]	SameDiff.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB) Matrix multiply a batch of matrices.
SDVariable[]	SameDiff.batchMmul(SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB) Matrix multiply a batch of matrices.
SDVariable[]	SameDiff.batchMmul(String[] names, SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB) Matrix multiply a batch of matrices.
SDVariable[]	SameDiff.batchMmul(String[] names, SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB) Matrix multiply a batch of matrices.
SDVariable	SameDiff.batchNorm(SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon) Batch norm operation.
SDVariable	SameDiff.batchNorm(String name, SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon) Batch norm operation.
SDVariable	SameDiff.batchToSpace(SDVariable x, int[] blocks, int[][] crops)
SDVariable	SameDiff.batchToSpace(String name, SDVariable x, int[] blocks, int[][] crops) Convolution 2d layer batch to space operation on 4d input.
SDVariable	SameDiff.biasAdd(SDVariable input, SDVariable bias)
SDVariable	SameDiff.biasAdd(String name, SDVariable input, SDVariable bias) Bias addition operation: a special case of addition, typically used with CNN 4D activations and a 1D bias vector
SDVariable	SameDiff.ceil(SDVariable x) Element-wise ceiling function: out = ceil(x).
SDVariable	SameDiff.ceil(String name, SDVariable x) Element-wise ceiling function: out = ceil(x).
SDVariable	SameDiff.clipByNorm(SDVariable x, double clipValue) Clipping by L2 norm if l2Norm(x) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
SDVariable	SameDiff.clipByNorm(SDVariable x, double clipValue, int... dimensions) Clipping by L2 norm, optionally along dimension(s) if l2Norm(x,dimension) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according to the corresponding l2Norm along the specified dimensions
SDVariable	SameDiff.clipByNorm(String name, SDVariable x, double clipValue) Clipping by L2 norm if l2Norm(x) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
SDVariable	SameDiff.clipByNorm(String name, SDVariable x, double clipValue, int... dimensions) Clipping by L2 norm, optionally along dimension(s) if l2Norm(x,dimension) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according to the corresponding l2Norm along the specified dimensions
SDVariable	SameDiff.clipByValue(SDVariable x, double clipValueMin, double clipValueMax) Element-wise clipping function: out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax out[i] = clipValueMin if in[i] < clipValueMin out[i] = clipValueMax if in[i] > clipValueMax
SDVariable	SameDiff.clipByValue(String name, SDVariable x, double clipValueMin, double clipValueMax) Element-wise clipping function: out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax out[i] = clipValueMin if in[i] < clipValueMin out[i] = clipValueMax if in[i] > clipValueMax
SDVariable	SameDiff.col2Im(SDVariable in, Conv2DConfig config) col2im operation for use in 2D convolution operations.
SDVariable	SameDiff.col2Im(String name, SDVariable in, Conv2DConfig config) col2im operation for use in 2D convolution operations.
SDVariable	SameDiff.concat(int dimension, SDVariable... inputs)
SDVariable	SameDiff.concat(String name, int dimension, SDVariable... inputs) Concatenate a set of inputs along the specified dimension. Note that inputs must have identical rank and identical dimensions, other than the dimension to stack on. For example, if 2 inputs have shape [a, x, c] and [a, y, c] and dimension = 1, then the output has shape [a, x+y, c]
SDVariable	SameDiff.confusionMatrix(SDVariable labels, SDVariable predictions)
SDVariable	SameDiff.confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses)
SDVariable	SameDiff.confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)
SDVariable	SameDiff.confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights)
SDVariable	SameDiff.confusionMatrix(String name, SDVariable labels, SDVariable pred) Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values.
SDVariable	SameDiff.confusionMatrix(String name, SDVariable labels, SDVariable pred, Integer numClasses) Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values. For example, if labels = [0, 1, 1], predicted = [0, 2, 1], and numClasses=4 then output is: [1, 0, 0, 0] [0, 1, 1, 0] [0, 0, 0, 0] [0, 0, 0, 0]
SDVariable	SameDiff.confusionMatrix(String name, SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights) Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values. For example, if labels = [0, 1, 1], predicted = [0, 2, 1], numClasses = 4, and weights = [1, 2, 3] [1, 0, 0, 0] [0, 3, 2, 0] [0, 0, 0, 0] [0, 0, 0, 0]
SDVariable	SameDiff.confusionMatrix(String name, SDVariable labels, SDVariable pred, SDVariable weights) Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values.
SDVariable	SameDiff.constant(SDVariable value, long... shape) Return a variable of given shape in which all values have a given constant value.
SDVariable	SameDiff.constant(String name, SDVariable value, long... shape) Return a variable of given shape in which all values have a given constant value.
SDVariable	SameDiff.conv1d(SDVariable input, SDVariable weights, Conv1DConfig conv1DConfig) 1D Convolution layer operation - Conv1d
SDVariable	SameDiff.conv1d(String name, SDVariable input, SDVariable weights, Conv1DConfig conv1DConfig) Conv1d operation.
SDVariable	SameDiff.conv2d(SDVariable[] inputs, Conv2DConfig config) 2D Convolution operation with optional bias
SDVariable	SameDiff.conv2d(SDVariable layerInput, SDVariable weights, Conv2DConfig config) 2D Convolution operation (without bias)
SDVariable	SameDiff.conv2d(SDVariable layerInput, SDVariable weights, SDVariable bias, Conv2DConfig config) 2D Convolution operation with optional bias
SDVariable	SameDiff.conv2d(String name, SDVariable[] inputs, Conv2DConfig config) 2D Convolution operation with optional bias
SDVariable	SameDiff.conv3d(SDVariable input, SDVariable weights, Conv3DConfig conv3DConfig) Convolution 3D operation without bias
SDVariable	SameDiff.conv3d(SDVariable input, SDVariable weights, SDVariable bias, Conv3DConfig conv3DConfig) Convolution 3D operation with optional bias
SDVariable	SameDiff.conv3d(String name, SDVariable input, SDVariable weights, Conv3DConfig conv3DConfig) Convolution 3D operation without bias
SDVariable	SameDiff.conv3d(String name, SDVariable input, SDVariable weights, SDVariable bias, Conv3DConfig conv3DConfig) Convolution 3D operation with optional bias
SDVariable	SameDiff.cos(SDVariable x) Elementwise cosine operation: out = cos(x)
SDVariable	SameDiff.cos(String name, SDVariable x) Elementwise cosine operation: out = cos(x)
SDVariable	SameDiff.cosh(SDVariable x) Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
SDVariable	SameDiff.cosh(String name, SDVariable x) Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
SDVariable	SameDiff.cosineDistance(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.cosineDistance(String name, SDVariable x, SDVariable y, int... dimensions) Cosine distance reduction operation.
SDVariable	SameDiff.cosineSimilarity(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.cosineSimilarity(String name, SDVariable x, SDVariable y, int... dimensions) Cosine similarity pairwise reduction operation.
SDVariable	SameDiff.countNonZero(SDVariable input, int... dimensions) Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
SDVariable	SameDiff.countNonZero(String name, SDVariable input, int... dimensions) Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
SDVariable	SameDiff.countZero(SDVariable input, int... dimensions) Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
SDVariable	SameDiff.countZero(String name, SDVariable input, int... dimensions) Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
SDVariable	SameDiff.cross(SDVariable a, SDVariable b)
SDVariable	SameDiff.cross(String name, SDVariable a, SDVariable b) Returns the pair-wise cross product of equal size arrays a and b: a x b = ||a||x||b|| sin(theta).
SDVariable	SameDiff.cube(SDVariable x) Element-wise cube function: out = x^3
SDVariable	SameDiff.cube(String name, SDVariable x) Element-wise cube function: out = x^3
SDVariable	SameDiff.cumprod(SDVariable in, boolean exclusive, boolean reverse, int... axis)
SDVariable	SameDiff.cumprod(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis) Cumulative product operation. For input: [ a, b, c], output is: exclusize=false, reverse=false: [a, a*b, a*b*c] exclusive=true, reverse=false, [0, a, a*b] exclusive=false, reverse=true: [a*b*c, b*c, c] exclusive=true, reverse=true: [b*c, c, 0]
SDVariable	SameDiff.cumsum(SDVariable in, boolean exclusive, boolean reverse, int... axis)
SDVariable	SameDiff.cumsum(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis) Cumulative sum operation. For input: [ a, b, c], output is: exclusize=false, reverse=false: [a, a+b, a+b+c] exclusive=true, reverse=false, [0, a, a+b] exclusive=false, reverse=true: [a+b+c, b+c, c] exclusive=true, reverse=true: [b+c, c, 0]
SDVariable	SameDiff.deconv2d(SDVariable[] inputs, DeConv2DConfig deconv2DConfig) 2D deconvolution operation with or without optional bias
SDVariable	SameDiff.deconv2d(SDVariable layerInput, SDVariable weights, DeConv2DConfig deconv2DConfig) 2D deconvolution operation without bias
SDVariable	SameDiff.deconv2d(SDVariable layerInput, SDVariable weights, SDVariable bias, DeConv2DConfig deconv2DConfig) 2D deconvolution operation with optional bias
SDVariable	SameDiff.deconv2d(String name, SDVariable[] inputs, DeConv2DConfig deconv2DConfig) 2D deconvolution operation with or without optional bias
SDVariable[]	SameDiffFunctionDefinition.define(SameDiff sameDiff, Map<String,INDArray> inputs, SDVariable[] variableInputs)
SameDiff	SameDiff.defineFunction(String function, SameDiffFunctionDefinition functionDefinition, SDVariable[] variables)
SDVariable	SameDiff.depthToSpace(SDVariable x, int blockSize, String dataFormat) Convolution 2d layer batch to space operation on 4d input. Reduces input channels dimension by rearranging data into a larger spatial dimensions Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2] = [mb, 2, 4, 4]
SDVariable	SameDiff.depthToSpace(String name, SDVariable x, int blockSize, String dataFormat) Convolution 2d layer batch to space operation on 4d input. Reduces input channels dimension by rearranging data into a larger spatial dimensions Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2] = [mb, 2, 4, 4]
SDVariable	SameDiff.depthWiseConv2d(SDVariable[] inputs, Conv2DConfig depthConv2DConfig) Depth-wise convolution 2D operation.
SDVariable	SameDiff.depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, Conv2DConfig config) Depth-wise 2D convolution operation without bias
SDVariable	SameDiff.depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable bias, Conv2DConfig config) Depth-wise 2D convolution operation with optional bias
SDVariable	SameDiff.depthWiseConv2d(String name, SDVariable[] inputs, Conv2DConfig depthConv2DConfig) Depth-wise convolution 2D operation.
SDVariable	SameDiff.diag(SDVariable x)
SDVariable	SameDiff.diag(String name, SDVariable x) Returns an output variable with diagonal values equal to the specified values; off-diagonal values will be set to 0 For example, if input = [1,2,3], then output is given by: [ 1, 0, 0] [ 0, 2, 0] [ 0, 0, 3] Higher input ranks are also supported: if input has shape [a,...,R-1] then output[i,...,k,i,...,k] = input[i,...,k].
SDVariable	SameDiff.diagPart(SDVariable x)
SDVariable	SameDiff.diagPart(String name, SDVariable x) Extract the diagonal part from the input array. If input is [ 1, 0, 0] [ 0, 2, 0] [ 0, 0, 3] then output is [1, 2, 3]. Supports higher dimensions: in general, out[i,...,k] = in[i,...,k,i,...,k]
SDVariable	SameDiff.dilation2D(SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode) TODO doc string
SDVariable	SameDiff.dilation2D(String name, SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode) TODO doc string
SDVariable	SDVariable.div(SDVariable sameDiffVariable)
SDVariable	SDVariable.div(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.divi(SDVariable sameDiffVariable)
SDVariable	SDVariable.divi(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.dot(SDVariable x, SDVariable y, int... dimensions) TODO doc string
SDVariable	SameDiff.dot(String name, SDVariable x, SDVariable y, int... dimensions) TODO doc string
SDVariable	SameDiff.dropout(SDVariable input, double inputRetainProbability)
SDVariable	SameDiff.dropout(String name, SDVariable input, double inputRetainProbability)
SDVariable[]	SameDiff.dynamicPartition(SDVariable x, SDVariable partitions, int numPartitions)
SDVariable[]	SameDiff.dynamicPartition(String[] name, SDVariable x, SDVariable partitions, int numPartitions) Dynamically partition the input variable values into the specified number of paritions, using the indices. Example:
SDVariable	SameDiff.dynamicStitch(SDVariable[] indices, SDVariable[] x)
SDVariable	SameDiff.dynamicStitch(SDVariable[] indices, SDVariable[] x)
SDVariable	SameDiff.dynamicStitch(String name, SDVariable[] indices, SDVariable[] x) Dynamically merge the specified input arrays into a single array, using the specified indices
SDVariable	SameDiff.dynamicStitch(String name, SDVariable[] indices, SDVariable[] x) Dynamically merge the specified input arrays into a single array, using the specified indices
SDVariable	SameDiff.elu(SDVariable x) Element-wise exponential linear unit (ELU) function: out = x if x > 0 out = a * (exp(x) - 1) if x <= 0 with constant a = 1.0
SDVariable	SameDiff.elu(String name, SDVariable x) Element-wise exponential linear unit (ELU) function: out = x if x > 0 out = a * (exp(x) - 1) if x <= 0 with constant a = 1.0
SDVariable	SameDiff.eluDerivative(SDVariable x) Element-wise derivative exponential linear unit (ELU) function, dOut/dIn given input.
SDVariable	SameDiff.eluDerivative(String name, SDVariable x) Element-wise derivative exponential linear unit (ELU) function, dOut/dIn given input.
SDVariable	SameDiff.entropy(SDVariable in, int... dimensions) Entropy reduction: -sum(x * log(x))
SDVariable	SameDiff.entropy(String name, SDVariable in, int... dimensions) Entropy reduction: -sum(x * log(x))
SDVariable	SDVariable.eq(SDVariable other)
SDVariable	SameDiff.eq(SDVariable x, double y) Equals operation: elementwise x == y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.eq(SDVariable x, SDVariable y) Equal to operation: elementwise x == y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.eq(String name, SDVariable other)
SDVariable	SameDiff.eq(String name, SDVariable x, double y) Equals operation: elementwise x == y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.eq(String name, SDVariable x, SDVariable y) Equal to operation: elementwise x == y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.erf(SDVariable x) Element-wise Gaussian error function - out = erf(in)
SDVariable	SameDiff.erf(String name, SDVariable x) Element-wise Gaussian error function - out = erf(in)
SDVariable	SameDiff.erfc(SDVariable x) Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
SDVariable	SameDiff.erfc(String name, SDVariable x) Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
SDVariable	SameDiff.euclideanDistance(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.euclideanDistance(String name, SDVariable x, SDVariable y, int... dimensions) Euclidean distance (l2 norm, l2 distance) reduction operation.
SDVariable	SameDiffConditional.eval(SameDiff context, SameDiffFunctionDefinition body, SDVariable[] inputVars)
SDVariable	SameDiff.exp(SDVariable x) Elementwise exponent function: out = exp(x) = 2.71828...^x
SDVariable	SameDiff.exp(String name, SDVariable x) Elementwise exponent function: out = exp(x) = 2.71828...^x
SDVariable	SameDiff.expandDims(SDVariable x, int axis)
SDVariable	SameDiff.expandDims(String name, SDVariable x, int axis) Reshape the input by adding a 1 at the specified location. For example, if input has shape [a, b], then output shape is: axis = 0: [1, a, b] axis = 1: [a, 1, b] axis = 2: [a, b, 1]
SDVariable	SameDiff.expm1(SDVariable x) Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
SDVariable	SameDiff.expm1(String name, SDVariable x) Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
SDVariable	SameDiff.eye(SDVariable rows) As per SameDiff.eye(int) but with the number of rows specified as a scalar SDVariable
SDVariable	SameDiff.eye(SDVariable rows, SDVariable cols) As per SameDiff.eye(int, int) bit with the number of rows/columns specified as scalar SDVariables
SDVariable	SameDiff.eye(SDVariable rows, SDVariable cols, SDVariable batchDimension) As per SameDiff.eye(int, int, int...) bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
SDVariable	SameDiff.eye(String name, SDVariable rows) As per SameDiff.eye(String, int) but with the number of rows specified as a scalar SDVariable
SDVariable	SameDiff.eye(String name, SDVariable rows, SDVariable cols) As per SameDiff.eye(String, int, int) bit with the number of rows/columns specified as scalar SDVariables
SDVariable	SameDiff.eye(String name, SDVariable rows, SDVariable cols, SDVariable batchDimension) As per SameDiff.eye(String, int, int, int...) bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
SDVariable	SameDiff.fill(SDVariable shape, double value) Generate an output variable with the specified (dynamic) shape with all elements set to the specified value
SDVariable	SameDiff.fill(String name, SDVariable shape, double value) Generate an output variable with the specified (dynamic) shape with all elements set to the specified value
SDVariable	SameDiff.firstIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)
SDVariable	SameDiff.firstIndex(SDVariable in, Condition condition, int... dimensions)
SDVariable	SameDiff.firstIndex(String name, SDVariable in, Condition condition, boolean keepDims, int... dimensions) First index reduction operation. Returns a variable that contains the index of the first element that matches the specified condition (for each slice along the specified dimensions) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.firstIndex(String name, SDVariable in, Condition condition, int... dimensions) First index reduction operation. Returns a variable that contains the index of the first element that matches the specified condition (for each slice along the specified dimensions)
SDVariable	SameDiff.floor(SDVariable x) Element-wise floor function: out = floor(x).
SDVariable	SameDiff.floor(String name, SDVariable x) Element-wise floor function: out = floor(x).
SDVariable	SameDiff.gather(SDVariable df, int[] indices, int axis)
SDVariable	SameDiff.gather(SDVariable df, SDVariable indices, int axis)
SDVariable	SameDiff.gather(String name, SDVariable df, int[] indices, int axis) Gather slices from the input variable where the indices are specified as fixed int[] values. Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.
SDVariable	SameDiff.gather(String name, SDVariable df, SDVariable indices, int axis) Gather slices from the input variable where the indices are specified as dynamic SDVariable values. Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.
SDVariable	SameDiff.gatherNd(SDVariable df, SDVariable indices) TODO doc string
SDVariable	SameDiff.gatherNd(String name, SDVariable df, SDVariable indices) TODO doc string
SDVariable	SameDiff.gradientBackwardsMarker(SDVariable x) Intended for internal/developer use
SDVariable	SameDiff.gradientBackwardsMarker(String name, SDVariable x) Intended for internal/developer use
SDVariable	SDVariable.gt(SDVariable other)
SDVariable	SameDiff.gt(SDVariable x, double y) Greater than operation: elementwise x > y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.gt(SDVariable x, SDVariable y) Greater than operation: elementwise x > y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.gt(String name, SDVariable other)
SDVariable	SameDiff.gt(String name, SDVariable x, double y) Greater than operation: elementwise x > y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.gt(String name, SDVariable x, SDVariable y) Greater than operation: elementwise x > y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.gte(SDVariable other)
SDVariable	SameDiff.gte(SDVariable x, double y) Greater than or equals operation: elementwise x >= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.gte(SDVariable x, SDVariable y) Greater than or equal to operation: elementwise x >= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.gte(String name, SDVariable other)
SDVariable	SameDiff.gte(String name, SDVariable x, double y) Greater than or equals operation: elementwise x >= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.gte(String name, SDVariable x, SDVariable y) Greater than or equal to operation: elementwise x >= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.hammingDistance(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.hammingDistance(String name, SDVariable x, SDVariable y, int... dimensions) Hamming distance reduction operation.
SDVariable	SameDiff.hardSigmoid(SDVariable in) Element-wise hard sigmoid function: out[i] = 0 if in[i] <= -2.5 out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5 out[i] = 1 if in[i] >= 2.5
SDVariable	SameDiff.hardSigmoid(String name, SDVariable in) Element-wise hard sigmoid function: out[i] = 0 if in[i] <= -2.5 out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5 out[i] = 1 if in[i] >= 2.5
SDVariable	SameDiff.hardTanh(SDVariable in) Element-wise hard tanh function: out[i] = -1 if in[i] <= -1 out[1] = in[i] if -1 < in[i] < 1 out[i] = 1 if in[i] >= 1
SDVariable	SameDiff.hardTanh(String name, SDVariable in) Element-wise hard tanh function: out[i] = -1 if in[i] <= -1 out[1] = in[i] if -1 < in[i] < 1 out[i] = 1 if in[i] >= 1
SDVariable	SameDiff.hardTanhDerivative(SDVariable x) Derivative (dOut/dIn) of the element-wise hard Tanh function - SameDiff.hardTanh(SDVariable)
SDVariable	SameDiff.hardTanhDerivative(String name, SDVariable x) Derivative (dOut/dIn) of the element-wise hard Tanh function - SameDiff.hardTanh(SDVariable)
SDVariable	SameDiff.iamax(SDVariable in, boolean keepDims, int... dimensions) Index of the max absolute value: argmax(abs(in))
SDVariable	SameDiff.iamax(SDVariable in, int... dimensions) Index of the max absolute value: argmax(abs(in))
SDVariable	SameDiff.iamax(String name, SDVariable in, boolean keepDims, int... dimensions) Index of the max absolute value: argmax(abs(in))
SDVariable	SameDiff.iamax(String name, SDVariable in, int... dimensions) Index of the max absolute value: argmax(abs(in))
SDVariable	SameDiff.iamin(SDVariable in, boolean keepDims, int... dimensions) Index of the min absolute value: argmin(abs(in))
SDVariable	SameDiff.iamin(SDVariable in, int... dimensions) Index of the min absolute value: argmin(abs(in))
SDVariable	SameDiff.iamin(String name, SDVariable in, boolean keepDims, int... dimensions) Index of the min absolute value: argmin(abs(in))
SDVariable	SameDiff.iamin(String name, SDVariable in, int... dimensions) Index of the min absolute value: argmin(abs(in))
SDVariable	SameDiff.identity(SDVariable input) Elementwise identity operation: out = x
SDVariable	SameDiff.identity(String name, SDVariable input) Elementwise identity operation: out = x
If	SameDiff.ifStatement(SameDiffConditional conditional, SameDiffFunctionDefinition conditionBody, SameDiffFunctionDefinition trueBody, SameDiffFunctionDefinition falseBody, SDVariable[] inputVars)
SDVariable	SameDiff.im2Col(SDVariable in, Conv2DConfig config) im2col operation for use in 2D convolution operations.
SDVariable	SameDiff.im2Col(String name, SDVariable in, Conv2DConfig config) im2col operation for use in 2D convolution operations.
SDVariable	SameDiff.invertPermutation(SDVariable input) Compute the inverse permutation indices for a permutation operation Example: if input is [2, 0, 1] then output is [1, 2, 0] The idea is that x.permute(input).permute(invertPermutation(input)) == x
SDVariable	SameDiff.invertPermutation(String name, SDVariable input) Compute the inverse permutation indices for a permutation operation Example: if input is [2, 0, 1] then output is [1, 2, 0] The idea is that x.permute(input).permute(invertPermutation(input)) == x
SDVariable	SameDiff.invoke(Op op, SDVariable x) Invoke an op by opName
SDVariable	SameDiff.invoke(Op op, SDVariable x, SDVariable y) Invoke an op by opName
SDVariable	SameDiff.isFinite(SDVariable x) Is finite operation: elementwise isFinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isFinite(String name, SDVariable x) Is finite operation: elementwise isFinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isInfinite(SDVariable x) Is infinite operation: elementwise isInfinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isInfinite(String name, SDVariable x) Is infinite operation: elementwise isInfinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isMax(SDVariable x) Is maximum operation: elementwise x == max(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isMax(String name, SDVariable x) Is maximum operation: elementwise x == max(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isNaN(SDVariable x) Is Not a Number operation: elementwise isNaN(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isNaN(String name, SDVariable x) Is Not a Number operation: elementwise isNaN(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.isNonDecreasing(SDVariable x) Is the array non decreasing? An array is non-decreasing if for every valid i, x[i] <= x[i+1].
SDVariable	SameDiff.isNonDecreasing(String name, SDVariable x) Is the array non decreasing? An array is non-decreasing if for every valid i, x[i] <= x[i+1].
SDVariable	SameDiff.isNumericTensor(SDVariable x) Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1
SDVariable	SameDiff.isNumericTensor(String name, SDVariable x) Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1
SDVariable	SameDiff.isStrictlyIncreasing(SDVariable x) Is the array strictly increasing? An array is strictly increasing if for every valid i, x[i] < x[i+1].
SDVariable	SameDiff.isStrictlyIncreasing(String name, SDVariable x) Is the array strictly increasing? An array is strictly increasing if for every valid i, x[i] < x[i+1].
SDVariable	SameDiff.jaccardDistance(SDVariable x, SDVariable y, int... dimensions) Jaccard similarity reduction operation.
SDVariable	SameDiff.jaccardDistance(String name, SDVariable x, SDVariable y, int... dimensions) Jaccard similarity reduction operation.
SDVariable	SameDiff.lastIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)
SDVariable	SameDiff.lastIndex(SDVariable in, Condition condition, int... dimensions)
SDVariable	SameDiff.lastIndex(String name, SDVariable in, Condition condition, boolean keepDims, int... dimensions) Last index reduction operation. Returns a variable that contains the index of the last element that matches the specified condition (for each slice along the specified dimensions) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.lastIndex(String name, SDVariable in, Condition condition, int... dimensions) Last index reduction operation. Returns a variable that contains the index of the last element that matches the specified condition (for each slice along the specified dimensions)
SDVariable	SameDiff.leakyRelu(SDVariable x, double alpha) Element-wise leaky ReLU function: out = x if x >= 0.0 out = alpha * x if x < cutoff Alpha value is most commonly set to 0.01
SDVariable	SameDiff.leakyRelu(String name, SDVariable x, double alpha) Element-wise leaky ReLU function: out = x if x >= 0.0 out = alpha * x if x < cutoff Alpha value is most commonly set to 0.01
SDVariable	SameDiff.leakyReluDerivative(String name, SDVariable x, double alpha) Leaky ReLU derivative: dOut/dIn given input. See SameDiff.leakyRelu(String, SDVariable, double)
SDVariable	SameDiff.linear(SDVariable input, SDVariable weights, SDVariable bias)
SDVariable	SameDiff.linear(String name, SDVariable input, SDVariable weights, SDVariable bias) Linear layer operation: out = mmul(in,w) + bias Note that bias array is optional
SDVariable	SameDiff.localResponseNormalization(SDVariable inputs, LocalResponseNormalizationConfig lrnConfig) 2D convolution layer operation - local response normalization
SDVariable	SameDiff.localResponseNormalization(String name, SDVariable input, LocalResponseNormalizationConfig lrnConfig) 2D convolution layer operation - local response normalization
SDVariable	SameDiff.log(SDVariable x) Element-wise logarithm function (base e - natural logarithm): out = log(x)
SDVariable	SameDiff.log(SDVariable in, double base) Element-wise logarithm function (with specified base): out = log_{base}(x)
SDVariable	SameDiff.log(String name, SDVariable x) Element-wise logarithm function (base e - natural logarithm): out = log(x)
SDVariable	SameDiff.log(String name, SDVariable in, double base) Element-wise logarithm function (with specified base): out = log_{base}(x)
SDVariable	SameDiff.log1p(SDVariable x) Elementwise natural logarithm function: out = log_e (1 + x)
SDVariable	SameDiff.log1p(String name, SDVariable x) Elementwise natural logarithm function: out = log_e (1 + x)
SDVariable	SameDiff.logEntropy(SDVariable in, int... dimensions) Log entropy reduction: log(-sum(x * log(x)))
SDVariable	SameDiff.logEntropy(String name, SDVariable in, int... dimensions) Log entropy reduction: log(-sum(x * log(x)))
SDVariable	SameDiff.logSigmoid(SDVariable x) Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))
SDVariable	SameDiff.logSigmoid(String name, SDVariable x) Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))
SDVariable	SameDiff.logSoftmax(SDVariable x) Log softmax activation
SDVariable	SameDiff.logSoftmax(String name, SDVariable x) Log softmax activation
SDVariable	SameDiff.logSumExp(SDVariable input, int... dimensions) Log-sum-exp reduction (optionally along dimension).
SDVariable	SameDiff.logSumExp(String name, SDVariable input, int... dimensions) Log-sum-exp reduction (optionally along dimension).
SDVariable	SameDiff.lossBinaryXENT(SDVariable x, SDVariable y, int... dimensions) Binary cross entropy loss.
SDVariable	SameDiff.lossBinaryXENT(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossCosineSimilarity(SDVariable x, SDVariable y, int... dimensions) TODO doc string
SDVariable	SameDiff.lossCosineSimilarity(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossHinge(SDVariable x, SDVariable y, int... dimensions) Hinge loss
SDVariable	SameDiff.lossHinge(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossKLD(SDVariable x, SDVariable y, int... dimensions) Kullback-Leibler divergence loss
SDVariable	SameDiff.lossKLD(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossL1(SDVariable x, SDVariable y, int... dimensions) L1 loss
SDVariable	SameDiff.lossL1(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossL2(SDVariable x, SDVariable y, int... dimensions) L2 loss
SDVariable	SameDiff.lossL2(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMAE(SDVariable x, SDVariable y, int... dimensions) Mean absolute error loss
SDVariable	SameDiff.lossMAE(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMCXENT(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMCXENT(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMSE(SDVariable x, SDVariable y, int... dimensions) Mean squared error loss
SDVariable	SameDiff.lossMSE(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMSLE(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossMSLE(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossNegativeLogLikelihood(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossNegativeLogLikelihood(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossPoisson(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossPoisson(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossSquaredHinge(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.lossSquaredHinge(String name, SDVariable x, SDVariable y, int... dimensions)
SDVariable	SDVariable.lt(SDVariable other)
SDVariable	SameDiff.lt(SDVariable x, double y) Less than operation: elementwise x < y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.lt(SDVariable x, SDVariable y) Less than operation: elementwise x < y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.lt(String name, SDVariable other)
SDVariable	SameDiff.lt(String name, SDVariable x, double y) Less than operation: elementwise x < y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.lt(String name, SDVariable x, SDVariable y) Less than operation: elementwise x < y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.lte(SDVariable other)
SDVariable	SameDiff.lte(SDVariable x, double y) Less than or equals operation: elementwise x <= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.lte(SDVariable x, SDVariable y) Less than or equal to operation: elementwise x <= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.lte(String name, SDVariable other)
SDVariable	SameDiff.lte(String name, SDVariable x, double y) Less than or equals operation: elementwise x <= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.lte(String name, SDVariable x, SDVariable y) Less than or equal to operation: elementwise x <= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.manhattanDistance(SDVariable x, SDVariable y, int... dimensions)
SDVariable	SameDiff.manhattanDistance(String name, SDVariable x, SDVariable y, int... dimensions) Manhattan distance (l1 norm, l1 distance) reduction operation.
SDVariable	SameDiff.matchCondition(SDVariable in, Condition condition) Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
SDVariable	SameDiff.matchCondition(String name, SDVariable in, Condition condition) Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
SDVariable	SameDiff.matchConditionCount(SDVariable in, Condition condition) Returns a count of the number of elements that satisfy the condition
SDVariable	SameDiff.matchConditionCount(String name, SDVariable in, Condition condition) Returns a count of the number of elements that satisfy the condition
SDVariable	SameDiff.matchConditionCount(String name, SDVariable in, Condition condition, boolean keepDim, int... dimensions) Returns a count of the number of elements that satisfy the condition (for each slice along the specified dimensions) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.matrixDeterminant(SDVariable in)
SDVariable	SameDiff.matrixDeterminant(String name, SDVariable in) Matrix determinant op.
SDVariable	SameDiff.matrixInverse(SDVariable in)
SDVariable	SameDiff.matrixInverse(String name, SDVariable in) Matrix inverse op.
SDVariable	SameDiff.max(SDVariable x, int... dimensions) Max array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.max(SDVariable first, SDVariable second) Element-wise maximum operation: out[i] = max(first[i], second[i]) Supports broadcasting
SDVariable	SameDiff.max(String name, SDVariable x, boolean keepDims, int... dimensions) Max array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.max(String name, SDVariable x, int... dimensions) Max array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.max(String name, SDVariable first, SDVariable second) Element-wise maximum operation: out[i] = max(first[i], second[i]) Supports broadcasting
SDVariable	SameDiff.maxPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig) 2D Convolution layer operation - max pooling 2d
SDVariable	SameDiff.maxPooling2d(String name, SDVariable input, Pooling2DConfig pooling2DConfig) 2D Convolution layer operation - max pooling 2d
SDVariable	SameDiff.maxPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig) 3D convolution layer operation - max pooling 3d operation.
SDVariable	SameDiff.maxPooling3d(String name, SDVariable input, Pooling3DConfig pooling3DConfig) 3D convolution layer operation - max pooling 3d operation.
SDVariable	SameDiff.mean(SDVariable x) Full array mean reduction operation
SDVariable	SameDiff.mean(SDVariable x, int... dimension) Mean (average) array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.mean(String name, SDVariable x, boolean keepDims, int... dimension) Mean (average) array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.mean(String name, SDVariable x, int... dimension) Mean (average) array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.mergeAdd(SDVariable... x) Merge add function: merges an arbitrary number of equal shaped arrays using elementwise addition: out = sum_i in[i]
SDVariable	SameDiff.mergeAdd(String name, SDVariable... inputs) Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition: out = sum_i in[i]
SDVariable	SameDiff.mergeAvg(SDVariable... inputs) Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
SDVariable	SameDiff.mergeAvg(String name, SDVariable... inputs) Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
SDVariable	SameDiff.mergeMax(SDVariable... x) Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
SDVariable	SameDiff.mergeMax(String name, SDVariable... inputs) Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
SDVariable[]	SameDiff.meshgrid(List<String> names, boolean cartesian, SDVariable... inputs)
SDVariable[]	SameDiff.meshgrid(List<String> names, SDVariable... inputs) Broadcast the 1D input variables onto an n-dimensional grid. The resulting variable can be used for example for evaluating functions at all locations on a grid. Example:
SDVariable[]	SameDiff.meshgrid(SDVariable... inputs)
SDVariable	SameDiff.min(SDVariable x, int... dimensions) Minimum array reduction operation, optionally along specified dimensions.
SDVariable	SameDiff.min(SDVariable first, SDVariable second) Element-wise minimum operation: out[i] = min(first[i], second[i]) Supports broadcasting
SDVariable	SameDiff.min(String name, SDVariable x, boolean keepDims, int... dimensions) Minimum array reduction operation, optionally along specified dimensions.
SDVariable	SameDiff.min(String name, SDVariable x, int... dimensions) Minimum array reduction operation, optionally along specified dimensions.
SDVariable	SameDiff.min(String name, SDVariable first, SDVariable second) Element-wise minimum operation: out[i] = min(first[i], second[i]) Supports broadcasting
SDVariable	SDVariable.mmul(SDVariable other)
SDVariable	SameDiff.mmul(SDVariable x, SDVariable y) Matrix multiplication: out = mmul(x,y)
SDVariable	SameDiff.mmul(SDVariable x, SDVariable y, MMulTranspose transpose) Matrix multiplication: out = mmul(x,y) Supports specifying a MMulTranspose argument to perform operation such as mmul(a^T, b), etc.
SDVariable	SameDiff.mmul(String name, SDVariable x, SDVariable y) Matrix multiplication: out = mmul(x,y)
SDVariable	SameDiff.mmul(String name, SDVariable x, SDVariable y, MMulTranspose transpose) Matrix multiplication: out = mmul(x,y) Supports specifying a MMulTranspose argument to perform operation such as mmul(a^T, b), etc.
SDVariable[]	SameDiff.moments(SDVariable input, int... axes)
SDVariable[]	SameDiff.moments(String[] name, SDVariable input, int... axes) Calculate the mean and (population) variance for the input variable, for the specified axis
SDVariable	SDVariable.mul(SDVariable sameDiffVariable)
SDVariable	SDVariable.mul(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.muli(SDVariable sameDiffVariable)
SDVariable	SDVariable.muli(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.neg(SDVariable x) Elementwise negative operation: out = -x
SDVariable	SameDiff.neg(String name, SDVariable x) Elementwise negative operation: out = -x
SDVariable	SDVariable.neq(SDVariable other)
SDVariable	SameDiff.neq(SDVariable x, double y) Not equals operation: elementwise x != y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.neq(SDVariable x, SDVariable y) Not equal to operation: elementwise x != y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SDVariable.neq(String name, SDVariable other)
SDVariable	SameDiff.neq(String name, SDVariable x, double y) Not equals operation: elementwise x != y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
SDVariable	SameDiff.neq(String name, SDVariable x, SDVariable y) Not equal to operation: elementwise x != y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.norm1(String name, SDVariable x, boolean keepDims, int... dimensions) Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions: out = sum_i abs(x[i]) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.norm1(String name, SDVariable x, int... dimensions) Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions: out = sum_i abs(x[i])
SDVariable	SameDiff.norm2(String name, SDVariable x, boolean keepDims, int... dimensions) Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions: out = sqrt(sum_i x[i]^2) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.norm2(String name, SDVariable x, int... dimensions) Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions: out = sqrt(sum_i x[i]^2)
SDVariable[]	SameDiff.normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)
SDVariable[]	SameDiff.normalizeMoments(String[] name, SDVariable counts, SDVariable means, SDVariable variances, double shift) Calculate the mean and variance from the sufficient statistics
SDVariable	SameDiff.normmax(String name, SDVariable x, boolean keepDims, int... dimensions) Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the specified dimensions: out = max(abs(x[i])) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.normmax(String name, SDVariable x, int... dimensions) Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the specified dimensions
SDVariable	SameDiff.oneHot(SDVariable indices, int depth)
SDVariable	SameDiff.oneHot(SDVariable indices, int depth, int axis, double on, double off)
SDVariable	SameDiff.oneHot(String name, SDVariable indices, int depth) Convert the array to a one-hot array with walues 0 and 1 for each entry If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with out[i, ..., j, in[i,...,j]] = 1 with other values being set to 0
SDVariable	SameDiff.oneHot(String name, SDVariable indices, int depth, int axis, double on, double off) Convert the array to a one-hot array with walues on and off for each entry If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with out[i, ..., j, in[i,...,j]] = on with other values being set to off
SDVariable	SameDiff.onesLike(SDVariable input) Return a variable of all 1s, with the same shape as the input variable.
SDVariable	SameDiff.onesLike(String name, SDVariable input) Return a variable of all 1s, with the same shape as the input variable.
SDVariable	SameDiff.or(SDVariable x, SDVariable y) Boolean OR operation: elementwise (x != 0) || (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.or(String name, SDVariable x, SDVariable y) Boolean OR operation: elementwise (x != 0) || (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.parallel_stack(SDVariable[] values)
SDVariable	SameDiff.parallel_stack(String name, SDVariable[] values)
SDVariable	SameDiff.permute(SDVariable x, int... dimensions) Array permutation operation: permute the dimensions according to the specified permutation indices. Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]
SDVariable	SameDiff.permute(String name, SDVariable x, int... dimensions) Array permutation operation: permute the dimensions according to the specified permutation indices. Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]
SDVariable	SameDiff.pow(SDVariable x, double value) Element-wise power function: out = x^value
SDVariable	SameDiff.pow(String name, SDVariable x, double value) Element-wise power function: out = x^value
SDVariable	SameDiff.prod(SDVariable x, int... dimensions) Product array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.prod(String name, SDVariable x, boolean keepDims, int... dimensions) Product array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.prod(String name, SDVariable x, int... dimensions) Product array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.randomBernoulli(double p, SDVariable shape)
SDVariable	SameDiff.randomBernoulli(String name, double p, SDVariable shape) Generate a new random SDVariable, where values are randomly sampled according to a Bernoulli distribution, with the specified probability.
SDVariable	SameDiff.randomExponential(double lambda, SDVariable shape) Generate a new random SDVariable, where values are randomly sampled according to a exponential distribution: P(x) = lambda * exp(-lambda * x)
SDVariable	SameDiff.randomExponential(String name, double lambda, SDVariable shape) Generate a new random SDVariable, where values are randomly sampled according to a exponential distribution: P(x) = lambda * exp(-lambda * x)
SDVariable	SameDiff.randomNormal(double mean, double stddev, SDVariable shape)
SDVariable	SameDiff.randomNormal(String name, double mean, double stddev, SDVariable shape) Generate a new random SDVariable, where values are randomly sampled according to a Gaussian (normal) distribution, N(mean, stdev) See SameDiff.randomNormal(String, double, double, long...) for the equivalent function where the shape is specified as a long[] instead
SDVariable	SameDiff.randomUniform(double min, double max, SDVariable shape)
SDVariable	SameDiff.randomUniform(String name, double min, double max, SDVariable shape) Generate a new random SDVariable, where values are randomly sampled according to a uniform distribution, U(min,max) See SameDiff.randomUniform(double, double, long...) for the equivalent function where the shape is specified as a long[] instead
SDVariable	SameDiff.rank(SDVariable in) Returns the rank (number of dimensions, i.e., length(shape)) of the specified SDVariable as a 0D scalar variable
SDVariable	SameDiff.rank(String name, SDVariable in) Returns the rank (number of dimensions, i.e., length(shape)) of the specified SDVariable as a 0D scalar variable
SDVariable	SDVariable.rdiv(SDVariable sameDiffVariable)
SDVariable	SDVariable.rdiv(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.rdivi(SDVariable sameDiffVariable)
SDVariable	SDVariable.rdivi(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.reciprocal(SDVariable a) Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
SDVariable	SameDiff.reciprocal(String name, SDVariable a) Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
SDVariable	SameDiff.relu(SDVariable x, double cutoff) Element-wise rectified linear function with specified cutoff: out[i] = in[i] if in[i] >= cutoff out[i] = 0 otherwise
SDVariable	SameDiff.relu(String name, SDVariable x, double cutoff) Element-wise rectified linear function with specified cutoff: out[i] = in[i] if in[i] >= cutoff out[i] = 0 otherwise
SDVariable	SameDiff.relu6(SDVariable x, double cutoff) Element-wise "rectified linear 6" function with specified cutoff: out[i] = min(max(in, cutoff), 6)
SDVariable	SameDiff.relu6(String name, SDVariable x, double cutoff) Element-wise "rectified linear 6" function with specified cutoff: out[i] = min(max(in, cutoff), 6)
SDVariable	SameDiff.reluLayer(SDVariable input, SDVariable weights, SDVariable bias)
SDVariable	SameDiff.reluLayer(String name, SDVariable input, SDVariable weights, SDVariable bias) ReLU (Rectified Linear Unit) layer operation: out = relu(mmul(in,w) + bias) Note that bias array is optional
SDVariable	SameDiff.repeat(SDVariable df, int axis)
SDVariable	SameDiff.repeat(String name, SDVariable df, int axis)
SDVariable	SameDiff.replaceWhere(SDVariable update, Number value, Condition condition) Element-wise replace where condition: out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
SDVariable	SameDiff.replaceWhere(SDVariable update, SDVariable from, Condition condition) Element-wise replace where condition: out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
SDVariable	SameDiff.replaceWhere(String name, SDVariable update, Number value, Condition condition) Element-wise replace where condition: out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
SDVariable	SameDiff.replaceWhere(String name, SDVariable update, SDVariable from, Condition condition) Element-wise replace where condition: out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
SDVariable	SameDiff.reshape(SDVariable x, int... shape) Reshape the input variable to the specified (fixed) shape.
SDVariable	SameDiff.reshape(SDVariable x, long... shape) Reshape the input variable to the specified (fixed) shape.
SDVariable	SameDiff.reshape(SDVariable x, SDVariable shape) Reshape the input variable to the specified (dynamic) shape.
SDVariable	SameDiff.reshape(String name, SDVariable x, int... shape) Reshape the input variable to the specified (fixed) shape.
SDVariable	SameDiff.reshape(String name, SDVariable x, long... shape) Reshape the input variable to the specified (fixed) shape.
SDVariable	SameDiff.reshape(String name, SDVariable x, SDVariable shape) Reshape the input variable to the specified (dynamic) shape.
SDVariable	SameDiff.reverse(SDVariable x, int... dimensions)
SDVariable	SameDiff.reverse(String name, SDVariable x, int... dimensions) Reverse the values of an array for the specified dimensions If input is: [ 1, 2, 3] [ 4, 5, 6] then reverse(in, 0): [3, 2, 1] [6, 5, 4] reverse(in, 0): [4, 5, 6] [1, 2 3]
SDVariable	SameDiff.reverseSequence(SDVariable x, SDVariable seq_lengths)
SDVariable	SameDiff.reverseSequence(SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)
SDVariable	SameDiff.reverseSequence(String name, SDVariable x, SDVariable seq_lengths)
SDVariable	SameDiff.reverseSequence(String name, SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim) Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversed
SDVariable	SameDiff.rollAxis(SDVariable x, int axis)
SDVariable	SameDiff.rollAxis(String name, SDVariable x, int axis)
SDVariable	SameDiff.round(SDVariable x) Elementwise round function: out = round(x).
SDVariable	SameDiff.round(String name, SDVariable x) Element-wise round function: out = round(x).
SDVariable	SameDiff.rsqrt(SDVariable x) Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
SDVariable	SameDiff.rsqrt(String name, SDVariable x) Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
SDVariable	SDVariable.rsub(SDVariable sameDiffVariable)
SDVariable	SDVariable.rsub(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.rsubi(SDVariable sameDiffVariable)
SDVariable	SDVariable.rsubi(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.scalarFloorMod(SDVariable in, Number value) Element-wise scalar floor modulus operation: out = floorMod(in, value).
SDVariable	SameDiff.scalarFloorMod(String name, SDVariable in, Number value) Element-wise scalar floor modulus operation: out = floorMod(in, value).
SDVariable	SameDiff.scalarMax(SDVariable in, Number value) Element-wise scalar maximum operation: out = max(in, value)
SDVariable	SameDiff.scalarMax(String name, SDVariable in, Number value) Element-wise scalar maximum operation: out = max(in, value)
SDVariable	SameDiff.scalarMin(SDVariable in, Number value) Element-wise scalar minimum operation: out = min(in, value)
SDVariable	SameDiff.scalarMin(String name, SDVariable in, Number value) Element-wise scalar minimum operation: out = min(in, value)
SDVariable	SameDiff.scalarSet(SDVariable in, Number set) Return an array with equal shape to the input, but all elements set to value 'set'
SDVariable	SameDiff.scalarSet(String name, SDVariable in, Number set) Return an arary with equal shape to the input, but all elements set to value 'set'
SDVariable	SameDiff.scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterAdd(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter addition operation. If indices is rank 0 (a scalar), then out[index, ...] += updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] += updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] += updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterDiv(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter division operation. If indices is rank 0 (a scalar), then out[index, ...] /= updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] /= updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] /= updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterMax(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterMax(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter max operation. If indices is rank 0 (a scalar), then out[index, ...] = max(updates[...], in[index,...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = max(updates[i,...], in[indices[i],...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = max(updates[i, ..., k, ...], in[indices[i], ..., indices[k], ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterMin(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterMin(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter min operation. If indices is rank 0 (a scalar), then out[index, ...] = min(updates[...], in[index,...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = min(updates[i,...], in[indices[i],...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = min(updates[i, ..., k, ...], in[indices[i], ..., indices[k], ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterMul(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter multiplication operation. If indices is rank 0 (a scalar), then out[index, ...] *= updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] *= updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] *= updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterSub(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter subtraction operation. If indices is rank 0 (a scalar), then out[index, ...] -= updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] -= updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] -= updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
SDVariable	SameDiff.scatterUpdate(SDVariable ref, SDVariable indices, SDVariable updates)
SDVariable	SameDiff.scatterUpdate(String name, SDVariable ref, SDVariable indices, SDVariable updates) Scatter update operation. If indices is rank 0 (a scalar), then out[index, ...] = updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the output at those locations is undefined - different updates may occur in different orders
SDVariable	SameDiff.sconv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig) Separable 2D convolution operation with/without optional bias
SDVariable	SameDiff.sconv2d(String name, SDVariable[] inputs, Conv2DConfig conv2DConfig) Separable 2D convolution operation with/without optional bias
SDVariable	SameDiff.segmentMax(SDVariable data, SDVariable segmentIds)
SDVariable	SameDiff.segmentMax(String name, SDVariable data, SDVariable segmentIds) Segment max operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [max(3,6), max(1,4,9), max(2,8)
SDVariable	SameDiff.segmentMean(SDVariable data, SDVariable segmentIds)
SDVariable	SameDiff.segmentMean(String name, SDVariable data, SDVariable segmentIds) Segment mean operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [4.5, 4.666, 5] = [mean(3,6), mean(1,4,9), mean(2,8)
SDVariable	SameDiff.segmentMin(SDVariable data, SDVariable segmentIds)
SDVariable	SameDiff.segmentMin(String name, SDVariable data, SDVariable segmentIds) Segment min operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [3, 1, 2] = [min(3,6), min(1,4,9), min(2,8)
SDVariable	SameDiff.segmentProd(SDVariable data, SDVariable segmentIds)
SDVariable	SameDiff.segmentProd(String name, SDVariable data, SDVariable segmentIds) Segment product operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [18, 36, 16] = [prod(3,6), prod(1,4,9), prod(2,8)
SDVariable	SameDiff.segmentSum(SDVariable data, SDVariable segmentIds)
SDVariable	SameDiff.segmentSum(String name, SDVariable data, SDVariable segmentIds) Segment sum operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [9, 14, 10] = [sum(3,6), sum(1,4,9), sum(2,8)
SDVariable	SameDiff.selu(SDVariable x) Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0 Uses default lcale and alpha values.
SDVariable	SameDiff.selu(String name, SDVariable x) Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0 Uses default lcale and alpha values.
SDVariable	SameDiff.separableConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, Conv2DConfig config) Separable 2D convolution operation without bias
SDVariable	SameDiff.separableConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, SDVariable bias, Conv2DConfig config) Separable 2D convolution operation with optional bias
SDVariable	SameDiff.sequenceMask(SDVariable lengths)
SDVariable	SameDiff.sequenceMask(SDVariable lengths, int maxLen)
SDVariable	SameDiff.sequenceMask(SDVariable lengths, SDVariable maxLen)
SDVariable	SameDiff.sequenceMask(String name, SDVariable lengths)
SDVariable	SameDiff.sequenceMask(String name, SDVariable lengths, int maxLen)
SDVariable	SameDiff.sequenceMask(String name, SDVariable lengths, SDVariable maxLen) Generate a sequence mask (with values 0 or 1) based on the specified lengths Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)
SDVariable	SameDiff.setDiag(SDVariable in, SDVariable diag)
SDVariable	SameDiff.setDiag(String name, SDVariable in, SDVariable diag) Set the diagonal value to the specified values If input is [ a, b, c] [ d, e, f] [ g, h, i] and diag = [ 1, 2, 3] then output is [ 1, b, c] [ d, 2, f] [ g, h, 3]
void	SameDiff.setForwardVariableForVarName(String varName, SDVariable forwardVariable)
void	SameDiff.setGradientForVariableName(String variableName, SDVariable variable) Assign a SDVariable to represent the gradient of the SDVariable with the specified name
SDVariable	SameDiff.shannonEntropy(SDVariable in, int... dimensions) Shannon Entropy reduction: -sum(x * log2(x))
SDVariable	SameDiff.shannonEntropy(String name, SDVariable in, int... dimensions) Shannon Entropy reduction: -sum(x * log2(x))
SDVariable	SameDiff.shape(SDVariable input) Returns the shape of the specified SDVariable as a 1D SDVariable
SDVariable	SameDiff.shape(String name, SDVariable input) Returns the shape of the specified SDVariable as a 1D SDVariable
SDVariable	SameDiff.sigmoid(SDVariable x) Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))
SDVariable	SameDiff.sigmoid(String name, SDVariable x) Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))
SDVariable	SameDiff.sigmoidCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing) TODO
SDVariable	SameDiff.sigmoidCrossEntropyWithLogits(String name, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing) TODO
SDVariable	SameDiff.sigmoidDerivative(SDVariable x, SDVariable wrt) Element-wise sigmoid function derivative: dL/dIn given input and dL/dOut
SDVariable	SameDiff.sigmoidDerivative(String name, SDVariable x, SDVariable wrt) Element-wise sigmoid function derivative: dL/dIn given input and dL/dOut
SDVariable	SameDiff.sign(SDVariable x) Element-wise sign (signum) function: out = -1 if in < 0 out = 0 if in = 0 out = 1 if in > 0
SDVariable	SameDiff.sign(String name, SDVariable x) Element-wise sign (signum) function: out = -1 if in < 0 out = 0 if in = 0 out = 1 if in > 0
SDVariable	SameDiff.sin(SDVariable x) Elementwise sine operation: out = sin(x)
SDVariable	SameDiff.sin(String name, SDVariable x) Elementwise sine operation: out = sin(x)
SDVariable	SameDiff.sinh(SDVariable x) Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
SDVariable	SameDiff.sinh(String name, SDVariable x) Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
SDVariable	SameDiff.size(SDVariable in) Returns the size (number of elements, i.e., prod(shape)) of the specified SDVariable as a 0D scalar variable
SDVariable	SameDiff.size(String name, SDVariable in) Returns the size (number of elements, i.e., prod(shape)) of the specified SDVariable as a 0D scalar variable
SDVariable	SameDiff.sizeAt(SDVariable in, int dimension)
SDVariable	SameDiff.sizeAt(String name, SDVariable in, int dimension) Returns a rank 0 (scalar) variable for the size of the specified dimension.
SDVariable	SameDiff.slice(SDVariable input, int[] begin, int[] size)
SDVariable	SameDiff.slice(String name, SDVariable input, int[] begin, int[] size) Get a subset of the specified input, by specifying the first element and the size of the array. For example, if input is: [a, b, c] [d, e, f] then slice(input, begin=[0,1], size=[2,1] will return: [b] [e] Note that for each dimension i, begin[i] + size[i] <= input.size(i)
SDVariable	SameDiff.softmax(SDVariable x) Softmax activation
SDVariable	SameDiff.softmax(String name, SDVariable x) Softmax activation
SDVariable	SameDiff.softmaxCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing) TODO
SDVariable	SameDiff.softmaxCrossEntropyWithLogits(String name, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing) TODO
SDVariable	SameDiff.softmaxDerivative(String name, SDVariable x, SDVariable wrt)
SDVariable	SameDiff.softmaxDerivative(String name, SDVariable x, SDVariable wrt, Integer dimension)
SDVariable	SameDiff.softplus(SDVariable x) Element-wise softplus function: out = log(exp(x) + 1)
SDVariable	SameDiff.softplus(String name, SDVariable x) Element-wise softplus function: out = log(exp(x) + 1)
SDVariable	SameDiff.softsign(SDVariable x) Element-wise softsign function: out = x / (abs(x) + 1)
SDVariable	SameDiff.softsign(String name, SDVariable x) Element-wise softsign function: out = x / (abs(x) + 1)
SDVariable	SameDiff.softsignDerivative(SDVariable x) Element-wise derivative (dOut/dIn) of the softsign function SameDiff.softsign(SDVariable)
SDVariable	SameDiff.softsignDerivative(String name, SDVariable x) Element-wise derivative (dOut/dIn) of the softsign function SameDiff.softsign(SDVariable)
SDVariable	SameDiff.spaceToBatch(SDVariable x, int[] blocks, int[][] padding)
SDVariable	SameDiff.spaceToBatch(String name, SDVariable x, int[] blocks, int[][] padding) Convolution 2d layer space to batch operation on 4d input.
SDVariable	SameDiff.spaceToDepth(SDVariable x, int blockSize, String dataFormat)
SDVariable	SameDiff.spaceToDepth(String name, SDVariable x, int blockSize, String dataFormat) Convolution 2d layer space to depth operation on 4d input. Increases input channels (reduced spatial dimensions) by rearranging data into a larger channels dimension Example: if input has shape [mb, 2, 4, 4] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2] = [mb, 2, 4, 4]
SDVariable	SameDiff.sqrt(SDVariable x) Element-wise square root function: out = sqrt(x)
SDVariable	SameDiff.sqrt(String name, SDVariable x) Element-wise square root function: out = sqrt(x)
SDVariable	SameDiff.square(SDVariable x) Element-wise square function: out = x^2
SDVariable	SameDiff.square(String name, SDVariable x) Element-wise square function: out = x^2
SDVariable	SDVariable.squaredDifference(SDVariable sameDiffVariable)
SDVariable	SDVariable.squaredDifference(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.squaredNorm(SDVariable x, boolean keepDims, int... dimensions) Squared L2 norm: see SameDiff.norm2(String, SDVariable, boolean, int...)
SDVariable	SameDiff.squaredNorm(SDVariable x, int... dimensions) Squared L2 norm: see SameDiff.norm2(String, SDVariable, int...)
SDVariable	SameDiff.squaredNorm(String name, SDVariable x, boolean keepDims, int... dimensions) Squared L2 norm: see SameDiff.norm2(String, SDVariable, boolean, int...)
SDVariable	SameDiff.squaredNorm(String name, SDVariable x, int... dimensions) Squared L2 norm: see SameDiff.norm2(String, SDVariable, int...)
SDVariable	SameDiff.squeeze(SDVariable x, int axis)
SDVariable	SameDiff.squeeze(String name, SDVariable x, int axis) Remove a single dimension of size 1.
SDVariable	SameDiff.stack(int axis, SDVariable... values)
SDVariable	SameDiff.stack(String name, int axis, SDVariable... values) Stack a set of N SDVariables of rank X into one rank X+1 variable.
SDVariable	SameDiff.standardDeviation(SDVariable x, boolean biasCorrected, int... dimensions)
SDVariable	SameDiff.standardDeviation(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions) Stardard deviation array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.standardDeviation(String name, SDVariable x, boolean biasCorrected, int... dimensions) Stardard deviation array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.step(SDVariable in, double cutoff) Elementwise step function: out(x) = 1 if x >= cutoff out(x) = 0 otherwise
SDVariable	SameDiff.step(String name, SDVariable in, double cutoff) Elementwise step function: out(x) = 1 if x >= cutoff out(x) = 0 otherwise
SDVariable	SameDiff.stridedSlice(SDVariable input, int[] begin, int[] end, int[] strides)
SDVariable	SameDiff.stridedSlice(SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	SameDiff.stridedSlice(SDVariable input, long[] begin, long[] end, long[] strides)
SDVariable	SameDiff.stridedSlice(SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	SameDiff.stridedSlice(String name, SDVariable input, int[] begin, int[] end, int[] strides)
SDVariable	SameDiff.stridedSlice(String name, SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
SDVariable	SameDiff.stridedSlice(String name, SDVariable input, long[] begin, long[] end, long[] strides) Get a subset of the specified input, by specifying the first element, last element, and the strides. For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1]) will return: [b, c] [h, i]
SDVariable	SameDiff.stridedSlice(String name, SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask) Get a subset of the specified input, by specifying the first element, last element, and the strides. Operates as described in SameDiff.stridedSlice(SDVariable, long[], long[], long[]) with some extra mask arrays as described below.
SDVariable	SDVariable.sub(SDVariable sameDiffVariable)
SDVariable	SDVariable.sub(String varName, SDVariable sameDiffVariable)
SDVariable	SDVariable.subi(SDVariable sameDiffVariable)
SDVariable	SDVariable.subi(String varName, SDVariable sameDiffVariable)
SDVariable	SameDiff.sum(SDVariable x, boolean keepDims, int... dimensions)
SDVariable	SameDiff.sum(SDVariable x, int... dimensions) Sum array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.sum(String name, SDVariable x, boolean keepDims, int... dimensions) Sum array reduction operation, optionally along specified dimensions. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.sum(String name, SDVariable x, int... dimensions) Sum array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.swish(SDVariable x) Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0 See: https://arxiv.org/abs/1710.05941
SDVariable	SameDiff.swish(String name, SDVariable x) Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0 See: https://arxiv.org/abs/1710.05941
SDVariable	SameDiff.tan(SDVariable x) Elementwise tangent operation: out = tan(x)
SDVariable	SameDiff.tan(String name, SDVariable x) Elementwise tangent operation: out = tan(x)
SDVariable	SameDiff.tanh(SDVariable x) Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
SDVariable	SameDiff.tanh(String name, SDVariable x) Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
SDVariable	SameDiff.tensorMmul(SDVariable x, SDVariable y, int[][] dimensions)
SDVariable	SameDiff.tensorMmul(String name, SDVariable x, SDVariable y, int[][] dimensions)
SDVariable	SameDiff.tile(SDVariable x, int[] repeat)
SDVariable	SameDiff.tile(String name, SDVariable x, int[] repeat) Repeat (tile) the input tensor the specified number of times. For example, if input is [1, 2] [3, 4] and repeat is [2, 3] then output is [1, 2, 1, 2, 1, 2] [3, 4, 3, 4, 3, 4] [1, 2, 1, 2, 1, 2] [3, 4, 3, 4, 3, 4]
SDVariable	SameDiff.trace(SDVariable in)
SDVariable	SameDiff.trace(String name, SDVariable in) Matrix trace operation For rank 2 matrices, the output is a scalar vith the trace - i.e., sum of the main diagonal. For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])
SDVariable	SameDiff.transpose(SDVariable x) Matrix transpose operation: If input has shape [a,b] output has shape [b,a]
SDVariable	SameDiff.transpose(String name, SDVariable x) Matrix transpose operation: If input has shape [a,b] output has shape [b,a]
SDVariable	SDVariable.truncatedDiv(SDVariable sameDiffVariable)
SDVariable	SDVariable.truncatedDiv(String varName, SDVariable sameDiffVariable)
SDVariable[]	SameDiff.unstack(SDVariable value, int axis)
SDVariable[]	SameDiff.unstack(SDVariable value, int axis, int num)
SDVariable[]	SameDiff.unstack(String[] names, SDVariable value, int axis)
SDVariable[]	SameDiff.unstack(String[] names, SDVariable value, int axis, int num) Unstack a variable of rank X into N rank X-1 variables by taking slices along the specified axis.
SDVariable	SameDiff.updateVariableNameAndReference(SDVariable varToUpdate, String newVarName) Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.
SDVariable[]	SameDiff.updateVariableNamesAndReferences(SDVariable[] variablesToUpdate, String[] newVariableNames) Updates the variable name property on the passed in variables, its reference in samediff, and returns the variable.
SDVariable	SameDiff.upsampling2d(SDVariable input, boolean nchw, int scaleH, int scaleW) 2D Convolution layer operation - Upsampling 2d
SDVariable	SameDiff.upsampling2d(SDVariable input, int scale) 2D Convolution layer operation - Upsampling 2d with same scale for both dimensions.
SDVariable	SameDiff.upsampling2d(String name, SDVariable input, boolean nchw, int scaleH, int scaleW) 2D Convolution layer operation - Upsampling 2d
SDVariable	SameDiff.upsampling2d(String name, SDVariable input, int scale) 2D Convolution layer operation - Upsampling 2d with same scale for both dimensions.
SDVariable	SameDiff.var(SDVariable arr) Initialize a SDVariable reference tying this variable to this samediff instance.
SDVariable	SameDiff.variance(SDVariable x, boolean biasCorrected, int... dimensions)
SDVariable	SameDiff.variance(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions) Variance array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
SDVariable	SameDiff.variance(String name, SDVariable x, boolean biasCorrected, int... dimensions) Variance array reduction operation, optionally along specified dimensions
SDVariable	SameDiff.weightedCrossEntropyWithLogits(SDVariable targets, SDVariable inputs, SDVariable weights) TODO
SDVariable	SameDiff.weightedCrossEntropyWithLogits(String name, SDVariable targets, SDVariable inputs, SDVariable weights) TODO
While	SameDiff.whileStatement(SameDiffConditional sameDiffConditional, SameDiffFunctionDefinition conditionBody, SameDiffFunctionDefinition loopBody, SDVariable[] inputVars) Creates a while statement
SDVariable	SameDiff.xor(SDVariable x, SDVariable y) Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.xor(String name, SDVariable x, SDVariable y) Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
SDVariable	SameDiff.zeroFraction(SDVariable input) Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
SDVariable	SameDiff.zeroFraction(String name, SDVariable input) Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
SDVariable	SameDiff.zerosLike(SDVariable input) Return a variable of all 0s, with the same shape as the input variable.
SDVariable	SameDiff.zerosLike(String name, SDVariable input) Return a variable of all 0s, with the same shape as the input variable.

Method parameters in org.nd4j.autodiff.samediff with type arguments of type SDVariable

Modifier and Type	Method and Description
protected int	SameDiff.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)
List<SDVariable>	SDVariable.doDiff(List<SDVariable> f1)

Uses of SDVariable in org.nd4j.autodiff.samediff.impl

Methods in org.nd4j.autodiff.samediff.impl that return SDVariable

Modifier and Type	Method and Description
SDVariable	DefaultSameDiffConditional.eval(SameDiff context, SameDiffFunctionDefinition body, SDVariable[] inputVars)

Methods in org.nd4j.autodiff.samediff.impl with parameters of type SDVariable

Modifier and Type	Method and Description
SDVariable	DefaultSameDiffConditional.eval(SameDiff context, SameDiffFunctionDefinition body, SDVariable[] inputVars)

Uses of SDVariable in org.nd4j.autodiff.validation

Methods in org.nd4j.autodiff.validation with parameters of type SDVariable

Modifier and Type	Method and Description
static boolean	GradCheckUtil.checkGradients(SDVariable function, SDVariable wrt, double epsilon, double maxRelError, boolean print, Map<String,INDArray> inputParameters)
TestCase	TestCase.expected(SDVariable var, org.nd4j.linalg.function.Function<INDArray,String> validationFn)
TestCase	TestCase.expected(SDVariable var, INDArray output) Validate the output (forward pass) for a single variable using INDArray.equals(INDArray)

Uses of SDVariable in org.nd4j.linalg.activations

Methods in org.nd4j.linalg.activations that return SDVariable

Modifier and Type	Method and Description
SDVariable	Activation.asSameDiff(SameDiff sd, SDVariable input) Get the Activation as a SameDiff variable
SDVariable	Activation.asSameDiff(String variableName, SameDiff sd, SDVariable input) Get the Activation as a SameDiff variable

Methods in org.nd4j.linalg.activations with parameters of type SDVariable

Modifier and Type	Method and Description
SDVariable	Activation.asSameDiff(SameDiff sd, SDVariable input) Get the Activation as a SameDiff variable
SDVariable	Activation.asSameDiff(String variableName, SameDiff sd, SDVariable input) Get the Activation as a SameDiff variable

Uses of SDVariable in org.nd4j.linalg.api.ops

Fields in org.nd4j.linalg.api.ops declared as SDVariable

Modifier and Type	Field and Description
protected SDVariable[]	DynamicCustomOp.outputVariables

Methods in org.nd4j.linalg.api.ops that return SDVariable

Modifier and Type	Method and Description
SDVariable[]	DynamicCustomOp.outputVariables()
SDVariable[]	BaseOp.outputVariables(String baseName)
SDVariable[]	DynamicCustomOp.outputVariables(String baseName)

Methods in org.nd4j.linalg.api.ops that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	NoOp.doDiff(List<SDVariable> f1)
List<SDVariable>	DefaultOpConverter.doDiff(List<SDVariable> f1)
List<SDVariable>	DynamicCustomOp.doDiff(List<SDVariable> f1)

Methods in org.nd4j.linalg.api.ops with parameters of type SDVariable

Modifier and Type	Method and Description
void	Module.execSameDiff(SDVariable... input)

Method parameters in org.nd4j.linalg.api.ops with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	NoOp.doDiff(List<SDVariable> f1)
List<SDVariable>	DefaultOpConverter.doDiff(List<SDVariable> f1)
List<SDVariable>	DynamicCustomOp.doDiff(List<SDVariable> f1)

Constructors in org.nd4j.linalg.api.ops with parameters of type SDVariable

Constructor and Description
BaseAccumulation(SameDiff sameDiff, SDVariable i_v)
BaseAccumulation(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
BaseAccumulation(SameDiff sameDiff, SDVariable i_v, int[] dimensions, boolean keepDims)
BaseAccumulation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
BaseAccumulation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)
BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BaseGradientOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
BaseGradientOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
BaseIndexAccumulation(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
BaseIndexAccumulation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, boolean keepDims, int[] dimensions)
BaseModule(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace, List<Module> modules)
BaseScalarOp(SameDiff sameDiff, SDVariable i_v, Number scalar)
BaseScalarOp(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
BaseScalarOp(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
BaseScalarOp(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
BaseTransformOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
BaseTransformOp(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
BaseTransformOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
BaseTransformOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
BaseTransformOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
BaseTransformOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
BaseTransformOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
DynamicCustomOp(String opName, SameDiff sameDiff, SDVariable[] args)
DynamicCustomOp(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace) Initialize this for SameDiff execution Any extra int or float arguments for operations must be added to the respective TArguments or IArguments lists upon construction
NoOp(SameDiff sd, SDVariable in)
ShapeOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
ShapeOp(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
ShapeOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.accum

Methods in org.nd4j.linalg.api.ops.impl.accum that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	LogEntropy.doDiff(List<SDVariable> f1)
List<SDVariable>	TensorMmul.doDiff(List<SDVariable> i_v1)
List<SDVariable>	AMin.doDiff(List<SDVariable> f1)
List<SDVariable>	SquaredNorm.doDiff(List<SDVariable> grad)
List<SDVariable>	Min.doDiff(List<SDVariable> grad)
List<SDVariable>	Prod.doDiff(List<SDVariable> grad)
List<SDVariable>	Moments.doDiff(List<SDVariable> grad)
List<SDVariable>	Norm2.doDiff(List<SDVariable> grad)
List<SDVariable>	NormMax.doDiff(List<SDVariable> grad)
List<SDVariable>	CountNonZero.doDiff(List<SDVariable> f1)
List<SDVariable>	Bias.doDiff(List<SDVariable> f1)
List<SDVariable>	Entropy.doDiff(List<SDVariable> f1)
List<SDVariable>	ShannonEntropy.doDiff(List<SDVariable> f1)
List<SDVariable>	AMean.doDiff(List<SDVariable> f1)
List<SDVariable>	CumSum.doDiff(List<SDVariable> grad)
List<SDVariable>	EqualsWithEps.doDiff(List<SDVariable> f1)
List<SDVariable>	CumProd.doDiff(List<SDVariable> grad)
List<SDVariable>	Sum.doDiff(List<SDVariable> i_v1)
List<SDVariable>	Any.doDiff(List<SDVariable> f1)
List<SDVariable>	Mmul.doDiff(List<SDVariable> i_v1)
List<SDVariable>	Dot.doDiff(List<SDVariable> f1)
List<SDVariable>	CountZero.doDiff(List<SDVariable> f1)
List<SDVariable>	MatchCondition.doDiff(List<SDVariable> f1)
List<SDVariable>	ASum.doDiff(List<SDVariable> f1)
List<SDVariable>	Max.doDiff(List<SDVariable> grad)
List<SDVariable>	LogSumExp.doDiff(List<SDVariable> f1)
List<SDVariable>	ZeroFraction.doDiff(List<SDVariable> grad)
List<SDVariable>	AMax.doDiff(List<SDVariable> f1)
List<SDVariable>	All.doDiff(List<SDVariable> f1)
List<SDVariable>	Norm1.doDiff(List<SDVariable> grad)
List<SDVariable>	Mean.doDiff(List<SDVariable> i_v1)
List<SDVariable>	BatchMmul.doDiff(List<SDVariable> grads)
List<SDVariable>	Variance.doDiff(List<SDVariable> grad)
List<SDVariable>	StandardDeviation.doDiff(List<SDVariable> grad)
static List<SDVariable>	Entropy.grad(DifferentialFunctionFactory f, SDVariable arg, SDVariable grad, int[] dimensions)

Methods in org.nd4j.linalg.api.ops.impl.accum with parameters of type SDVariable

Modifier and Type	Method and Description
static List<SDVariable>	Entropy.grad(DifferentialFunctionFactory f, SDVariable arg, SDVariable grad, int[] dimensions)

Method parameters in org.nd4j.linalg.api.ops.impl.accum with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	LogEntropy.doDiff(List<SDVariable> f1)
List<SDVariable>	TensorMmul.doDiff(List<SDVariable> i_v1)
List<SDVariable>	AMin.doDiff(List<SDVariable> f1)
List<SDVariable>	SquaredNorm.doDiff(List<SDVariable> grad)
List<SDVariable>	Min.doDiff(List<SDVariable> grad)
List<SDVariable>	Prod.doDiff(List<SDVariable> grad)
List<SDVariable>	Moments.doDiff(List<SDVariable> grad)
List<SDVariable>	Norm2.doDiff(List<SDVariable> grad)
List<SDVariable>	NormMax.doDiff(List<SDVariable> grad)
List<SDVariable>	CountNonZero.doDiff(List<SDVariable> f1)
List<SDVariable>	Bias.doDiff(List<SDVariable> f1)
List<SDVariable>	Entropy.doDiff(List<SDVariable> f1)
List<SDVariable>	ShannonEntropy.doDiff(List<SDVariable> f1)
List<SDVariable>	AMean.doDiff(List<SDVariable> f1)
List<SDVariable>	CumSum.doDiff(List<SDVariable> grad)
List<SDVariable>	EqualsWithEps.doDiff(List<SDVariable> f1)
List<SDVariable>	CumProd.doDiff(List<SDVariable> grad)
List<SDVariable>	Sum.doDiff(List<SDVariable> i_v1)
List<SDVariable>	Any.doDiff(List<SDVariable> f1)
List<SDVariable>	Mmul.doDiff(List<SDVariable> i_v1)
List<SDVariable>	Dot.doDiff(List<SDVariable> f1)
List<SDVariable>	CountZero.doDiff(List<SDVariable> f1)
List<SDVariable>	MatchCondition.doDiff(List<SDVariable> f1)
List<SDVariable>	ASum.doDiff(List<SDVariable> f1)
List<SDVariable>	Max.doDiff(List<SDVariable> grad)
List<SDVariable>	LogSumExp.doDiff(List<SDVariable> f1)
List<SDVariable>	ZeroFraction.doDiff(List<SDVariable> grad)
List<SDVariable>	AMax.doDiff(List<SDVariable> f1)
List<SDVariable>	All.doDiff(List<SDVariable> f1)
List<SDVariable>	Norm1.doDiff(List<SDVariable> grad)
List<SDVariable>	Mean.doDiff(List<SDVariable> i_v1)
List<SDVariable>	BatchMmul.doDiff(List<SDVariable> grads)
List<SDVariable>	Variance.doDiff(List<SDVariable> grad)
List<SDVariable>	StandardDeviation.doDiff(List<SDVariable> grad)

Constructors in org.nd4j.linalg.api.ops.impl.accum with parameters of type SDVariable

Constructor and Description
All(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
AMax(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
AMax(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
AMean(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
AMean(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
AMin(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
AMin(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
Any(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
ASum(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
ASum(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
BaseReduction(SameDiff sameDiff, SDVariable input, boolean keepDims, int... dimensions)
BaseReduction(SameDiff sameDiff, SDVariable input1, SDVariable input2, boolean keepDims, int... dimensions)
BatchMmul(SameDiff sameDiff, SDVariable[] matrices, boolean transposeA, boolean transposeB)
Bias(SameDiff sameDiff, SDVariable i_v, int[] dimensions, double mean)
Bias(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double mean)
CountNonZero(SameDiff sameDiff, SDVariable input, int... dimensions)
CountZero(SameDiff sameDiff, SDVariable input, int... dimensions)
CumProd(SameDiff sameDiff, SDVariable x, boolean exclusive, boolean reverse, int... axis)
CumProd(SameDiff sameDiff, SDVariable x, int... axis)
CumSum(SameDiff sameDiff, SDVariable x, boolean exclusive, boolean reverse, int... axis)
CumSum(SameDiff sameDiff, SDVariable x, int... axis)
Dot(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)
Entropy(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
EqualsWithEps(SameDiff sameDiff, SDVariable i_v, int[] dimensions, double eps)
EqualsWithEps(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double eps)
LogEntropy(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
LogSumExp(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
LogSumExp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
MatchCondition(SameDiff sameDiff, SDVariable in, Condition condition, boolean keepDims, int... dimensions)
Max(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
Max(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
Mean(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
Min(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
Mmul(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
Mmul(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, MMulTranspose mt)
Moments(SameDiff sameDiff, SDVariable input)
Moments(SameDiff sameDiff, SDVariable input, int[] axes)
Norm1(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
Norm2(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
NormalizeMoments(SameDiff sameDiff, SDVariable counts, SDVariable means, SDVariable variances)
NormalizeMoments(SameDiff sameDiff, SDVariable counts, SDVariable means, SDVariable variances, double shift)
NormMax(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
NormMax(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
Prod(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
Prod(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
ShannonEntropy(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
ShannonEntropy(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
SigmoidCrossEntropyLoss(SameDiff sameDiff, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode)
SigmoidCrossEntropyLoss(SameDiff sameDiff, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)
SoftmaxCrossEntropyLoss(SameDiff sameDiff, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode)
SoftmaxCrossEntropyLoss(SameDiff sameDiff, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)
SoftmaxCrossEntropyLossWithLogits(SameDiff sameDiff, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode)
SoftmaxCrossEntropyLossWithLogits(SameDiff sameDiff, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)
SquaredNorm(SameDiff sameDiff, SDVariable input, boolean keepDims, int... dimensions)
StandardDeviation(SameDiff sameDiff, SDVariable i_v, boolean biasCorrected, boolean keepDims, int[] dimensions)
Sum(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
Sum(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
TensorMmul(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[][] dimensions)
TensorMmul(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[][] dimensions, MMulTranspose mMulTranspose)
Variance(SameDiff sameDiff, SDVariable i_v, boolean biasCorrected, boolean keepDims, int[] dimensions)
WeightedCrossEntropyLoss(SameDiff sameDiff, SDVariable targets, SDVariable inputs, SDVariable weights)
ZeroFraction(SameDiff sameDiff, SDVariable input)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.accum.bp

Constructors in org.nd4j.linalg.api.ops.impl.accum.bp with parameters of type SDVariable

Constructor and Description
BaseReductionBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
BaseReductionBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
CumProdBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean exclusive, boolean reverse, int... axis)
CumSumBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean exclusive, boolean reverse, int... axis)
DotBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
MaxBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
MeanBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
MinBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
Norm1Bp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
Norm2Bp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
NormMaxBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
ProdBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
SquaredNormBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
StandardDeviationBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean biasCorrected, boolean keepDims, int... dimensions)
SumBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)
VarianceBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean biasCorrected, boolean keepDims, int... dimensions)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.accum.distances

Methods in org.nd4j.linalg.api.ops.impl.accum.distances that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	CosineSimilarity.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ManhattanDistance.doDiff(List<SDVariable> i_v1)
List<SDVariable>	JaccardDistance.doDiff(List<SDVariable> f1)
List<SDVariable>	CosineDistance.doDiff(List<SDVariable> i_v1)
List<SDVariable>	HammingDistance.doDiff(List<SDVariable> f1)
List<SDVariable>	EuclideanDistance.doDiff(List<SDVariable> i_v1)
static List<SDVariable>	CosineSimilarity.doDiff(SameDiff sameDiff, DifferentialFunctionFactory f, SDVariable x, SDVariable y, SDVariable gradOut, int... dimensions)

Methods in org.nd4j.linalg.api.ops.impl.accum.distances with parameters of type SDVariable

Modifier and Type	Method and Description
static List<SDVariable>	CosineSimilarity.doDiff(SameDiff sameDiff, DifferentialFunctionFactory f, SDVariable x, SDVariable y, SDVariable gradOut, int... dimensions)

Method parameters in org.nd4j.linalg.api.ops.impl.accum.distances with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	CosineSimilarity.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ManhattanDistance.doDiff(List<SDVariable> i_v1)
List<SDVariable>	JaccardDistance.doDiff(List<SDVariable> f1)
List<SDVariable>	CosineDistance.doDiff(List<SDVariable> i_v1)
List<SDVariable>	HammingDistance.doDiff(List<SDVariable> f1)
List<SDVariable>	EuclideanDistance.doDiff(List<SDVariable> i_v1)

Constructors in org.nd4j.linalg.api.ops.impl.accum.distances with parameters of type SDVariable

Constructor and Description
CosineDistance(SameDiff sameDiff, SDVariable i_v, int[] dimensions, Number constantNormalizedByNorm2X, Number constantNormalizedByNorm2Y)
CosineDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)
CosineSimilarity(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
CosineSimilarity(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
EuclideanDistance(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
EuclideanDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)
HammingDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)
JaccardDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)
ManhattanDistance(SameDiff sameDiff, SDVariable i_v, int[] dimensions)
ManhattanDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.broadcast

Methods in org.nd4j.linalg.api.ops.impl.broadcast that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	BroadcastAMin.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastLessThan.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastRDivOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastRSubOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastMin.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastGradientArgs.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastLessThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	BiasAddGrad.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastMulOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastGreaterThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastSubOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastGreaterThan.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastAddOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastNotEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastDivOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastMax.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastAMax.doDiff(List<SDVariable> f1)
List<SDVariable>	BiasAdd.doDiff(List<SDVariable> gradient)
List<SDVariable>	BroadcastEqualTo.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastCopyOp.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.api.ops.impl.broadcast with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	BroadcastAMin.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastLessThan.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastRDivOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastRSubOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastMin.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastGradientArgs.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastLessThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	BiasAddGrad.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastMulOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastGreaterThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastSubOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastGreaterThan.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastAddOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastNotEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastDivOp.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastMax.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastAMax.doDiff(List<SDVariable> f1)
List<SDVariable>	BiasAdd.doDiff(List<SDVariable> gradient)
List<SDVariable>	BroadcastEqualTo.doDiff(List<SDVariable> f1)
List<SDVariable>	BroadcastCopyOp.doDiff(List<SDVariable> f1)

Constructors in org.nd4j.linalg.api.ops.impl.broadcast with parameters of type SDVariable

Constructor and Description
BiasAdd(SameDiff sameDiff, SDVariable input, SDVariable bias)
BiasAddGrad(SameDiff sameDiff, SDVariable input, SDVariable bias, SDVariable gradient)
BroadcastAddOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastAddOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastAddOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastAMax(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastAMax(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastAMax(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastAMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastAMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastAMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastAMin(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastAMin(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastAMin(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastAMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastAMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastAMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastDivOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastDivOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastDivOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastEqualTo(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastEqualTo(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastEqualTo(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastEqualTo(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastEqualTo(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastEqualTo(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastGradientArgs(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastGradientArgs(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastGradientArgs(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastLessThan(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastLessThan(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastLessThan(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastLessThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastLessThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastLessThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastMax(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastMax(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastMax(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastMin(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastMin(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastMin(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastMulOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastMulOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastMulOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastMulOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastMulOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastMulOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)
BroadcastSubOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)
BroadcastSubOp(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)
BroadcastSubOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)
BroadcastSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)
BroadcastSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)
BroadcastSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.controlflow

Fields in org.nd4j.linalg.api.ops.impl.controlflow declared as SDVariable

Modifier and Type	Field and Description
protected SDVariable	While.dummyResult
protected SDVariable	If.dummyResult
protected SDVariable[]	While.inputVars
protected SDVariable[]	If.inputVars
protected SDVariable[]	While.outputVars
protected SDVariable[]	If.outputVars
protected SDVariable	While.targetBoolean
protected SDVariable	If.targetBoolean

Methods in org.nd4j.linalg.api.ops.impl.controlflow that return SDVariable

Modifier and Type	Method and Description
SDVariable[]	WhileDerivative.getInputVars()
SDVariable[]	While.outputVariables(String baseName)
SDVariable[]	If.outputVariables(String baseName)

Methods in org.nd4j.linalg.api.ops.impl.controlflow that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	IfDerivative.diff(List<SDVariable> i_v1)
List<SDVariable>	While.doDiff(List<SDVariable> f1)
List<SDVariable>	If.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.api.ops.impl.controlflow with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	IfDerivative.diff(List<SDVariable> i_v1)
List<SDVariable>	While.doDiff(List<SDVariable> f1)
List<SDVariable>	If.doDiff(List<SDVariable> f1)

Constructors in org.nd4j.linalg.api.ops.impl.controlflow with parameters of type SDVariable

Constructor and Description
If(String blockName, SameDiff parent, SDVariable[] inputVars, SameDiffFunctionDefinition conditionBody, SameDiffConditional predicate, SameDiffFunctionDefinition trueBody, SameDiffFunctionDefinition falseBody)
Select(SameDiff sameDiff, SDVariable[] args)
Select(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
Where(SameDiff sameDiff, SDVariable[] args)
Where(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
WhereNumpy(SameDiff sameDiff, SDVariable[] args)
WhereNumpy(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
While(String blockName, SameDiff parent, SDVariable[] inputVars, SameDiffConditional predicate, SameDiffFunctionDefinition condition, SameDiffFunctionDefinition trueBody)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.controlflow.compat

Methods in org.nd4j.linalg.api.ops.impl.controlflow.compat that return SDVariable

Modifier and Type	Method and Description
SDVariable[]	Merge.outputVariables()
SDVariable[]	LoopCond.outputVariables()
SDVariable[]	NextIteration.outputVariables()
SDVariable[]	Exit.outputVariables()
SDVariable[]	Switch.outputVariables()
SDVariable[]	Enter.outputVariables()

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.grid

Methods in org.nd4j.linalg.api.ops.impl.grid that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	FreeGridOp.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.api.ops.impl.grid with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	FreeGridOp.doDiff(List<SDVariable> f1)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.indexaccum

Methods in org.nd4j.linalg.api.ops.impl.indexaccum that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	FirstIndex.doDiff(List<SDVariable> f1)
List<SDVariable>	IAMin.doDiff(List<SDVariable> grad)
List<SDVariable>	IMax.doDiff(List<SDVariable> f1)
List<SDVariable>	LastIndex.doDiff(List<SDVariable> f1)
List<SDVariable>	IMin.doDiff(List<SDVariable> f1)
List<SDVariable>	IAMax.doDiff(List<SDVariable> grad)

Method parameters in org.nd4j.linalg.api.ops.impl.indexaccum with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	FirstIndex.doDiff(List<SDVariable> f1)
List<SDVariable>	IAMin.doDiff(List<SDVariable> grad)
List<SDVariable>	IMax.doDiff(List<SDVariable> f1)
List<SDVariable>	LastIndex.doDiff(List<SDVariable> f1)
List<SDVariable>	IMin.doDiff(List<SDVariable> f1)
List<SDVariable>	IAMax.doDiff(List<SDVariable> grad)

Constructors in org.nd4j.linalg.api.ops.impl.indexaccum with parameters of type SDVariable

Constructor and Description
FirstIndex(SameDiff sameDiff, SDVariable i_v, Condition condition, boolean keepDims, int... dimensions)
IAMax(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
IAMin(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
IMax(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
IMin(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)
LastIndex(SameDiff sameDiff, SDVariable i_v, Condition condition, boolean keepDims, int... dimensions)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.layers

Methods in org.nd4j.linalg.api.ops.impl.layers that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	Linear.doDiff(List<SDVariable> f1)

Methods in org.nd4j.linalg.api.ops.impl.layers with parameters of type SDVariable

Modifier and Type	Method and Description
void	Linear.execSameDiff(SDVariable... input)

Method parameters in org.nd4j.linalg.api.ops.impl.layers with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	Linear.doDiff(List<SDVariable> f1)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.layers.convolution

Methods in org.nd4j.linalg.api.ops.impl.layers.convolution that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	DepthToSpace.doDiff(List<SDVariable> i_v)
List<SDVariable>	BatchNormDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Pooling3DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Conv3DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Im2colBp.doDiff(List<SDVariable> f1)
List<SDVariable>	Pooling2DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	LocalResponseNormalization.doDiff(List<SDVariable> f1)
List<SDVariable>	DeConv2D.doDiff(List<SDVariable> f1)
List<SDVariable>	Conv2D.doDiff(List<SDVariable> f1)
List<SDVariable>	FullConv3DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	SpaceToDepth.doDiff(List<SDVariable> i_v)
List<SDVariable>	SConv2DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	LocalResponseNormalizationDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	AvgPooling2D.doDiff(List<SDVariable> f1)
List<SDVariable>	LegacyPooling2D.doDiff(List<SDVariable> f1) Deprecated.
List<SDVariable>	Pooling3D.doDiff(List<SDVariable> f1)
List<SDVariable>	DeConv2DTF.doDiff(List<SDVariable> f1)
List<SDVariable>	Conv3D.doDiff(List<SDVariable> f1)
List<SDVariable>	DepthwiseConv2D.doDiff(List<SDVariable> f1)
List<SDVariable>	Conv2DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Im2col.doDiff(List<SDVariable> grad)
List<SDVariable>	MaxPooling2D.doDiff(List<SDVariable> f1)
List<SDVariable>	DeConv2DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Col2Im.doDiff(List<SDVariable> f1)
List<SDVariable>	Pooling2D.doDiff(List<SDVariable> f1)
List<SDVariable>	BatchNorm.doDiff(List<SDVariable> f1)
List<SDVariable>	FullConv3D.doDiff(List<SDVariable> f1)
List<SDVariable>	SConv2D.doDiff(List<SDVariable> f1)
List<SDVariable>	Upsampling2dDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Upsampling2d.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.api.ops.impl.layers.convolution with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	DepthToSpace.doDiff(List<SDVariable> i_v)
List<SDVariable>	BatchNormDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Pooling3DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Conv3DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Im2colBp.doDiff(List<SDVariable> f1)
List<SDVariable>	Pooling2DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	LocalResponseNormalization.doDiff(List<SDVariable> f1)
List<SDVariable>	DeConv2D.doDiff(List<SDVariable> f1)
List<SDVariable>	Conv2D.doDiff(List<SDVariable> f1)
List<SDVariable>	FullConv3DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	SpaceToDepth.doDiff(List<SDVariable> i_v)
List<SDVariable>	SConv2DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	LocalResponseNormalizationDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	AvgPooling2D.doDiff(List<SDVariable> f1)
List<SDVariable>	LegacyPooling2D.doDiff(List<SDVariable> f1) Deprecated.
List<SDVariable>	Pooling3D.doDiff(List<SDVariable> f1)
List<SDVariable>	DeConv2DTF.doDiff(List<SDVariable> f1)
List<SDVariable>	Conv3D.doDiff(List<SDVariable> f1)
List<SDVariable>	DepthwiseConv2D.doDiff(List<SDVariable> f1)
List<SDVariable>	Conv2DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Im2col.doDiff(List<SDVariable> grad)
List<SDVariable>	MaxPooling2D.doDiff(List<SDVariable> f1)
List<SDVariable>	DeConv2DDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Col2Im.doDiff(List<SDVariable> f1)
List<SDVariable>	Pooling2D.doDiff(List<SDVariable> f1)
List<SDVariable>	BatchNorm.doDiff(List<SDVariable> f1)
List<SDVariable>	FullConv3D.doDiff(List<SDVariable> f1)
List<SDVariable>	SConv2D.doDiff(List<SDVariable> f1)
List<SDVariable>	Upsampling2dDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Upsampling2d.doDiff(List<SDVariable> f1)

Constructors in org.nd4j.linalg.api.ops.impl.layers.convolution with parameters of type SDVariable

Constructor and Description
AvgPooling2D(SameDiff sameDiff, SDVariable input, INDArray arrayInput, INDArray arrayOutput, Pooling2DConfig config)
BatchNorm(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputArrays, boolean inPlace, boolean applyGamma, boolean applyBeta, double epsilon)
BatchNormDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputArrays, boolean inPlace, boolean applyGamma, boolean applyBeta, double epsilon)
Col2Im(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputs, Conv2DConfig conv2DConfig)
Col2Im(SameDiff sd, SDVariable input, Conv2DConfig config)
Conv1D(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputs, Conv1DConfig config)
Conv2D(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputs, Conv2DConfig config)
Conv2DDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputs, Conv2DConfig config)
Conv3D(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputs, INDArray[] outputs, Conv3DConfig conv3DConfig)
Conv3DDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputs, INDArray[] outputs, Conv3DConfig conv3DConfig)
DeConv2D(SameDiff sameDiff, SDVariable[] inputs, INDArray[] inputArrays, INDArray[] outputs, DeConv2DConfig config)
DeConv2DDerivative(SameDiff sameDiff, SDVariable[] inputs, INDArray[] inputArrays, INDArray[] outputs, DeConv2DConfig config)
DeConv2DTF(SameDiff sameDiff, SDVariable[] inputs, INDArray[] inputArrays, INDArray[] outputs, DeConv2DConfig config)
DepthToSpace(SameDiff sameDiff, SDVariable[] args, int blockSize, String dataFormat)
DepthwiseConv2D(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputs, Conv2DConfig config)
FullConv3D(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputs, INDArray[] outputs, FullConv3DConfig config)
FullConv3DDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputs, INDArray[] outputs, FullConv3DConfig conv3DConfig)
Im2col(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputs, Conv2DConfig conv2DConfig)
Im2col(SameDiff sd, SDVariable input, Conv2DConfig config)
Im2colBp(SameDiff sd, SDVariable input, Conv2DConfig config)
Im2colBp(SameDiff sameDiff, SDVariable i2cInput, SDVariable gradAtOutput, Conv2DConfig conv2DConfig)
LocalResponseNormalization(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputs, INDArray[] outputs, boolean inPlace, LocalResponseNormalizationConfig config)
LocalResponseNormalizationDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputs, INDArray[] outputs, boolean inPlace, LocalResponseNormalizationConfig config)
MaxPooling2D(SameDiff sameDiff, SDVariable input, INDArray arrayInput, INDArray arrayOutput, Pooling2DConfig config)
Pooling2D(SameDiff sameDiff, SDVariable[] inputs, INDArray[] arrayInputs, INDArray[] arrayOutputs, Pooling2DConfig config)
Pooling2DDerivative(SameDiff sameDiff, SDVariable[] inputs, INDArray[] arrayInputs, INDArray[] arrayOutputs, Pooling2DConfig config)
Pooling3D(SameDiff sameDiff, SDVariable[] inputs, INDArray[] inputArrays, INDArray[] outputs, boolean inPlace, Pooling3DConfig pooling3DConfig, Pooling3D.Pooling3DType type)
Pooling3DDerivative(SameDiff sameDiff, SDVariable[] inputs, INDArray[] inputArrays, INDArray[] outputs, boolean inPlace, Pooling3DConfig pooling3DConfig, Pooling3D.Pooling3DType type)
SConv2D(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputs, Conv2DConfig conv2DConfig)
SConv2DDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputs, Conv2DConfig conv2DConfig)
SpaceToDepth(SameDiff sameDiff, SDVariable[] args, int blockSize, String dataFormat)
Upsampling2d(SameDiff sameDiff, SDVariable input, boolean nchw, int scaleH, int scaleW)
Upsampling2dDerivative(SameDiff sameDiff, SDVariable input, SDVariable gradient, boolean nchw, int scaleH, int scaleW)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.layers.recurrent.config

Methods in org.nd4j.linalg.api.ops.impl.layers.recurrent.config that return SDVariable

Modifier and Type	Method and Description
SDVariable[]	SRUConfiguration.args()
SDVariable[]	SRUCellConfiguration.args()
SDVariable[]	LSTMCellConfiguration.args()
SDVariable[]	GRUCellConfiguration.args()

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.loss

Constructors in org.nd4j.linalg.api.ops.impl.loss with parameters of type SDVariable

Constructor and Description
L2Loss(SameDiff sameDiff, SDVariable[] args)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.meta

Methods in org.nd4j.linalg.api.ops.impl.meta that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	PostulateMetaOp.doDiff(List<SDVariable> f1)
List<SDVariable>	InvertedPredicateMetaOp.doDiff(List<SDVariable> f1)
List<SDVariable>	PredicateMetaOp.doDiff(List<SDVariable> f1)
List<SDVariable>	ReduceMetaOp.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.api.ops.impl.meta with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	PostulateMetaOp.doDiff(List<SDVariable> f1)
List<SDVariable>	InvertedPredicateMetaOp.doDiff(List<SDVariable> f1)
List<SDVariable>	PredicateMetaOp.doDiff(List<SDVariable> f1)
List<SDVariable>	ReduceMetaOp.doDiff(List<SDVariable> f1)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.scalar

Methods in org.nd4j.linalg.api.ops.impl.scalar that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ScalarReverseSubtraction.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarSubtraction.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarMax.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarSet.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarReverseDivision.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarDivision.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarFMod.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarMin.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarRemainder.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarAdd.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarMultiplication.doDiff(List<SDVariable> i_v1)

Method parameters in org.nd4j.linalg.api.ops.impl.scalar with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ScalarReverseSubtraction.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarSubtraction.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarMax.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarSet.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarReverseDivision.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarDivision.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarFMod.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarMin.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarRemainder.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarAdd.doDiff(List<SDVariable> i_v1)
List<SDVariable>	ScalarMultiplication.doDiff(List<SDVariable> i_v1)

Constructors in org.nd4j.linalg.api.ops.impl.scalar with parameters of type SDVariable

Constructor and Description
ScalarAdd(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarAdd(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarAdd(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarDivision(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarDivision(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarDivision(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarDivision(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarFMod(SameDiff sd, SDVariable in, Number number)
ScalarMax(SameDiff sd, SDVariable in, Number number)
ScalarMin(SameDiff sd, SDVariable in, Number number)
ScalarMultiplication(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarMultiplication(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarMultiplication(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarMultiplication(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarRemainder(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarRemainder(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarRemainder(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarRemainder(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarReverseDivision(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarReverseDivision(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarReverseDivision(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarReverseDivision(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarReverseSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarReverseSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarReverseSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarReverseSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarSet(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarSet(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarSet(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarSet(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.scalar.comparison

Methods in org.nd4j.linalg.api.ops.impl.scalar.comparison that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ScalarGreaterThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarLessThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarEquals.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarGreaterThan.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarNotEquals.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarLessThan.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarSetValue.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.api.ops.impl.scalar.comparison with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ScalarGreaterThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarLessThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarEquals.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarGreaterThan.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarNotEquals.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarLessThan.doDiff(List<SDVariable> f1)
List<SDVariable>	ScalarSetValue.doDiff(List<SDVariable> f1)

Constructors in org.nd4j.linalg.api.ops.impl.scalar.comparison with parameters of type SDVariable

Constructor and Description
ScalarEquals(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarEquals(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarEquals(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarEquals(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarGreaterThan(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarGreaterThan(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarGreaterThan(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarGreaterThan(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarLessThan(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarNotEquals(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarNotEquals(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarNotEquals(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarNotEquals(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)
ScalarSetValue(SameDiff sameDiff, SDVariable i_v, Number scalar)
ScalarSetValue(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)
ScalarSetValue(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)
ScalarSetValue(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.scatter

Methods in org.nd4j.linalg.api.ops.impl.scatter that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ScatterAdd.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterMax.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterSub.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterUpdate.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterMul.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterMin.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterDiv.doDiff(List<SDVariable> gradOut)

Method parameters in org.nd4j.linalg.api.ops.impl.scatter with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ScatterAdd.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterMax.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterSub.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterUpdate.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterMul.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterMin.doDiff(List<SDVariable> gradOut)
List<SDVariable>	ScatterDiv.doDiff(List<SDVariable> gradOut)

Constructors in org.nd4j.linalg.api.ops.impl.scatter with parameters of type SDVariable

Constructor and Description
ScatterAdd(SameDiff sameDiff, SDVariable ref, SDVariable indices, SDVariable updates)
ScatterDiv(SameDiff sameDiff, SDVariable ref, SDVariable indices, SDVariable updates)
ScatterMax(SameDiff sameDiff, SDVariable ref, SDVariable indices, SDVariable updates)
ScatterMin(SameDiff sameDiff, SDVariable ref, SDVariable indices, SDVariable updates)
ScatterMul(SameDiff sameDiff, SDVariable ref, SDVariable indices, SDVariable updates)
ScatterSub(SameDiff sameDiff, SDVariable ref, SDVariable indices, SDVariable updates)
ScatterUpdate(SameDiff sameDiff, SDVariable ref, SDVariable indices, SDVariable updates)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.shape

Methods in org.nd4j.linalg.api.ops.impl.shape that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	Cross.doDiff(List<SDVariable> gradients)
List<SDVariable>	Size.doDiff(List<SDVariable> i_v)
List<SDVariable>	Transpose.doDiff(List<SDVariable> i_v)
List<SDVariable>	StridedSlice.doDiff(List<SDVariable> i_v)
List<SDVariable>	Diag.doDiff(List<SDVariable> i_v)
List<SDVariable>	MergeSum.doDiff(List<SDVariable> i_v)
List<SDVariable>	Permute.doDiff(List<SDVariable> i_v)
List<SDVariable>	Gather.doDiff(List<SDVariable> i_v)
List<SDVariable>	Broadcast.doDiff(List<SDVariable> i_v)
List<SDVariable>	ConfusionMatrix.doDiff(List<SDVariable> i_v)
List<SDVariable>	ExpandDims.doDiff(List<SDVariable> i_v)
List<SDVariable>	Slice.doDiff(List<SDVariable> grad)
List<SDVariable>	Unstack.doDiff(List<SDVariable> f1)
List<SDVariable>	Tile.doDiff(List<SDVariable> i_v)
List<SDVariable>	SequenceMask.doDiff(List<SDVariable> grad)
List<SDVariable>	BroadcastDynamicShape.doDiff(List<SDVariable> i_v)
List<SDVariable>	Reshape.doDiff(List<SDVariable> i_v)
List<SDVariable>	MergeAvg.doDiff(List<SDVariable> i_v)
List<SDVariable>	Concat.doDiff(List<SDVariable> i_v)
List<SDVariable>	SizeAt.doDiff(List<SDVariable> i_v)
List<SDVariable>	Eye.doDiff(List<SDVariable> outGrad)
List<SDVariable>	ZerosLike.doDiff(List<SDVariable> i_v)
List<SDVariable>	Squeeze.doDiff(List<SDVariable> i_v)
List<SDVariable>	RollAxis.doDiff(List<SDVariable> i_v)
List<SDVariable>	DiagPart.doDiff(List<SDVariable> i_v)
List<SDVariable>	Shape.doDiff(List<SDVariable> i_v)
List<SDVariable>	MeshGrid.doDiff(List<SDVariable> gradients)
List<SDVariable>	MergeMax.doDiff(List<SDVariable> i_v)
List<SDVariable>	Rank.doDiff(List<SDVariable> i_v)
List<SDVariable>	Stack.doDiff(List<SDVariable> f1)
List<SDVariable>	OneHot.doDiff(List<SDVariable> i_v)
List<SDVariable>	ApplyGradientDescent.doDiff(List<SDVariable> i_v)
List<SDVariable>	OnesLike.doDiff(List<SDVariable> i_v)
List<SDVariable>	Repeat.doDiff(List<SDVariable> i_v)

Method parameters in org.nd4j.linalg.api.ops.impl.shape with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	Cross.doDiff(List<SDVariable> gradients)
List<SDVariable>	Size.doDiff(List<SDVariable> i_v)
List<SDVariable>	Transpose.doDiff(List<SDVariable> i_v)
List<SDVariable>	StridedSlice.doDiff(List<SDVariable> i_v)
List<SDVariable>	Diag.doDiff(List<SDVariable> i_v)
List<SDVariable>	MergeSum.doDiff(List<SDVariable> i_v)
List<SDVariable>	Permute.doDiff(List<SDVariable> i_v)
List<SDVariable>	Gather.doDiff(List<SDVariable> i_v)
List<SDVariable>	Broadcast.doDiff(List<SDVariable> i_v)
List<SDVariable>	ConfusionMatrix.doDiff(List<SDVariable> i_v)
List<SDVariable>	ExpandDims.doDiff(List<SDVariable> i_v)
List<SDVariable>	Slice.doDiff(List<SDVariable> grad)
List<SDVariable>	Unstack.doDiff(List<SDVariable> f1)
List<SDVariable>	Tile.doDiff(List<SDVariable> i_v)
List<SDVariable>	SequenceMask.doDiff(List<SDVariable> grad)
List<SDVariable>	BroadcastDynamicShape.doDiff(List<SDVariable> i_v)
List<SDVariable>	Reshape.doDiff(List<SDVariable> i_v)
List<SDVariable>	MergeAvg.doDiff(List<SDVariable> i_v)
List<SDVariable>	Concat.doDiff(List<SDVariable> i_v)
List<SDVariable>	SizeAt.doDiff(List<SDVariable> i_v)
List<SDVariable>	Eye.doDiff(List<SDVariable> outGrad)
List<SDVariable>	ZerosLike.doDiff(List<SDVariable> i_v)
List<SDVariable>	Squeeze.doDiff(List<SDVariable> i_v)
List<SDVariable>	RollAxis.doDiff(List<SDVariable> i_v)
List<SDVariable>	DiagPart.doDiff(List<SDVariable> i_v)
List<SDVariable>	Shape.doDiff(List<SDVariable> i_v)
List<SDVariable>	MeshGrid.doDiff(List<SDVariable> gradients)
List<SDVariable>	MergeMax.doDiff(List<SDVariable> i_v)
List<SDVariable>	Rank.doDiff(List<SDVariable> i_v)
List<SDVariable>	Stack.doDiff(List<SDVariable> f1)
List<SDVariable>	OneHot.doDiff(List<SDVariable> i_v)
List<SDVariable>	ApplyGradientDescent.doDiff(List<SDVariable> i_v)
List<SDVariable>	OnesLike.doDiff(List<SDVariable> i_v)
List<SDVariable>	Repeat.doDiff(List<SDVariable> i_v)

Constructors in org.nd4j.linalg.api.ops.impl.shape with parameters of type SDVariable

Constructor and Description
Broadcast(SameDiff sameDiff, SDVariable iX, long[] shape)
BroadcastDynamicShape(SameDiff sameDiff, SDVariable in, SDVariable shape)
Concat(SameDiff sameDiff, int concatDimension, SDVariable... inputs)
ConfusionMatrix(SameDiff sameDiff, SDVariable labels, SDVariable pred)
ConfusionMatrix(SameDiff sameDiff, SDVariable labels, SDVariable pred, Integer numClasses)
ConfusionMatrix(SameDiff sameDiff, SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)
ConfusionMatrix(SameDiff sameDiff, SDVariable labels, SDVariable pred, SDVariable weights)
Cross(SameDiff sameDiff, SDVariable[] args)
Diag(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
DiagPart(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
ExpandDims(SameDiff sameDiff, SDVariable[] args)
ExpandDims(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
ExpandDims(SameDiff sameDiff, SDVariable[] args, int axis)
Eye(SameDiff sameDiff, SDVariable numRows)
Eye(SameDiff sameDiff, SDVariable numRows, SDVariable numCols)
Eye(SameDiff sameDiff, SDVariable numRows, SDVariable numCols, SDVariable batch_shape)
Gather(SameDiff sameDiff, SDVariable input, int[] indices, int axis, boolean inPlace)
Gather(SameDiff sameDiff, SDVariable input, SDVariable indices, int axis, boolean inPlace)
GatherNd(SameDiff sameDiff, SDVariable input, SDVariable indices, boolean inPlace)
MergeAvg(SameDiff sameDiff, SDVariable... inputs)
MergeMax(SameDiff sameDiff, SDVariable... inputs)
MergeSum(SameDiff sameDiff, SDVariable... inputs)
MeshGrid(SameDiff sd, boolean cartesian, SDVariable... inputs)
OneHot(SameDiff sameDiff, SDVariable indices, int depth)
OneHot(SameDiff sameDiff, SDVariable indices, int depth, int axis, double on, double off)
OnesLike(String name, SameDiff sameDiff, SDVariable input)
OnesLike(String name, SameDiff sameDiff, SDVariable input, boolean inPlace)
ParallelStack(SameDiff sameDiff, SDVariable[] values)
Permute(SameDiff sameDiff, SDVariable i_v, int... permuteDims)
Rank(SameDiff sameDiff, SDVariable input, boolean inPlace)
Repeat(SameDiff sameDiff, SDVariable[] args, boolean inPlace, int axis)
Repeat(SameDiff sameDiff, SDVariable[] args, int axis)
Reshape(SameDiff sameDiff, SDVariable i_v, long[] shape)
Reshape(SameDiff sameDiff, SDVariable i_v, SDVariable shape)
RollAxis(SameDiff sameDiff, SDVariable i_v, int axis)
RollAxis(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, int axis)
SequenceMask(SameDiff sameDiff, SDVariable input)
SequenceMask(SameDiff sameDiff, SDVariable input, int maxLen)
SequenceMask(SameDiff sameDiff, SDVariable input, SDVariable maxLen)
Shape(SameDiff sameDiff, SDVariable input, boolean inPlace)
Size(SameDiff sameDiff, SDVariable input)
SizeAt(SameDiff sameDiff, SDVariable input, int dimension)
Slice(SameDiff sameDiff, SDVariable input, int[] begin, int[] size)
Squeeze(SameDiff sameDiff, SDVariable arg, int[] squeezeDims)
Stack(SameDiff sameDiff, SDVariable[] values, int axis)
StridedSlice(SameDiff sameDiff, SDVariable in, int[] begin, int[] end, int[] strides)
StridedSlice(SameDiff sameDiff, SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
StridedSlice(SameDiff sameDiff, SDVariable in, long[] begin, long[] end, long[] strides)
StridedSlice(SameDiff sameDiff, SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
Tile(SameDiff sameDiff, SDVariable i_v, int[] axis)
Transpose(SameDiff sameDiff, SDVariable i_v)
Unstack(SameDiff sameDiff, SDVariable value, int axis)
Unstack(SameDiff sameDiff, SDVariable value, int axis, int num)
ZerosLike(String name, SameDiff sameDiff, SDVariable input)
ZerosLike(String name, SameDiff sameDiff, SDVariable input, boolean inPlace)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.shape.bp

Methods in org.nd4j.linalg.api.ops.impl.shape.bp that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	StridedSliceBp.doDiff(List<SDVariable> i_v)
List<SDVariable>	TileBp.doDiff(List<SDVariable> i_v)
List<SDVariable>	SliceBp.doDiff(List<SDVariable> i_v)

Method parameters in org.nd4j.linalg.api.ops.impl.shape.bp with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	StridedSliceBp.doDiff(List<SDVariable> i_v)
List<SDVariable>	TileBp.doDiff(List<SDVariable> i_v)
List<SDVariable>	SliceBp.doDiff(List<SDVariable> i_v)

Constructors in org.nd4j.linalg.api.ops.impl.shape.bp with parameters of type SDVariable

Constructor and Description
ConcatBp(SameDiff sameDiff, int concatDimension, SDVariable... inputsAndGrad)
SliceBp(SameDiff sameDiff, SDVariable input, SDVariable gradient, int[] begin, int[] size)
StridedSliceBp(SameDiff sameDiff, SDVariable in, SDVariable grad, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
TileBp(SameDiff sameDiff, SDVariable in, SDVariable grad, int[] repeat)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.shape.tensorops

Methods in org.nd4j.linalg.api.ops.impl.shape.tensorops that return SDVariable

Modifier and Type	Method and Description
SDVariable	TensorArrayV3.concat()
SDVariable	TensorArrayV3.gather(int... indices)
SDVariable	TensorArrayV3.gather(SDVariable indices)
SDVariable	TensorArrayV3.read(int index)
SDVariable	TensorArrayV3.read(SDVariable index)
SDVariable	TensorArrayV3.stack()

Methods in org.nd4j.linalg.api.ops.impl.shape.tensorops that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	BaseTensorOp.doDiff(List<SDVariable> f1)

Methods in org.nd4j.linalg.api.ops.impl.shape.tensorops with parameters of type SDVariable

Modifier and Type	Method and Description
SDVariable	TensorArrayV3.gather(SDVariable indices)
SDVariable	TensorArrayV3.read(SDVariable index)
void	TensorArrayV3.scatter(SDVariable value, int... indices)
void	TensorArrayV3.scatter(SDVariable value, SDVariable indices)
void	TensorArrayV3.unstack(SDVariable value)
void	TensorArrayV3.write(int index, SDVariable value)
void	TensorArrayV3.write(SDVariable index, SDVariable value)

Method parameters in org.nd4j.linalg.api.ops.impl.shape.tensorops with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	BaseTensorOp.doDiff(List<SDVariable> f1)

Constructors in org.nd4j.linalg.api.ops.impl.shape.tensorops with parameters of type SDVariable

Constructor and Description
BaseTensorOp(SameDiff sameDiff, SDVariable[] args)
BaseTensorOp(String name, SameDiff sameDiff, SDVariable[] args)
TensorArrayConcatV3(SameDiff sameDiff, SDVariable[] args)
TensorArrayConcatV3(String name, SameDiff sameDiff, SDVariable[] args)
TensorArrayGatherV3(SameDiff sameDiff, SDVariable[] args)
TensorArrayGatherV3(String name, SameDiff sameDiff, SDVariable[] args)
TensorArrayReadV3(SameDiff sameDiff, SDVariable[] args)
TensorArrayReadV3(String name, SameDiff sameDiff, SDVariable[] args)
TensorArrayScatterV3(SameDiff sameDiff, SDVariable[] args)
TensorArrayScatterV3(String name, SameDiff sameDiff, SDVariable[] args)
TensorArrayV3(TensorArrayV3 ta, SDVariable[] inputs)
TensorArrayWriteV3(SameDiff sameDiff, SDVariable[] args)
TensorArrayWriteV3(String name, SameDiff sameDiff, SDVariable[] args)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms

Methods in org.nd4j.linalg.api.ops.impl.transforms that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ASinh.doDiff(List<SDVariable> i_v)
List<SDVariable>	Round.doDiff(List<SDVariable> f1)
List<SDVariable>	PowDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	SpaceToBatch.doDiff(List<SDVariable> i_v)
List<SDVariable>	BinaryMinimalRelativeError.doDiff(List<SDVariable> i_v1)
List<SDVariable>	Log1p.doDiff(List<SDVariable> i_v)
List<SDVariable>	TanDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	MaxOut.doDiff(List<SDVariable> f1)
List<SDVariable>	ReplaceNans.doDiff(List<SDVariable> f1)
List<SDVariable>	SigmoidDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	OldAtan2Op.doDiff(List<SDVariable> f1)
List<SDVariable>	Ceil.doDiff(List<SDVariable> f1)
List<SDVariable>	BatchToSpace.doDiff(List<SDVariable> i_v)
List<SDVariable>	ACosh.doDiff(List<SDVariable> i_v)
List<SDVariable>	ATan2.doDiff(List<SDVariable> i_v)
List<SDVariable>	Trace.doDiff(List<SDVariable> gradAtOutput)
List<SDVariable>	RationalTanh.doDiff(List<SDVariable> f1)
List<SDVariable>	Expm1.doDiff(List<SDVariable> i_v)
List<SDVariable>	Reciprocal.doDiff(List<SDVariable> i_v1)
List<SDVariable>	Sqrt.doDiff(List<SDVariable> i_v)
List<SDVariable>	ReluLayer.doDiff(List<SDVariable> gradient)
List<SDVariable>	SoftMax.doDiff(List<SDVariable> i_v)
List<SDVariable>	SetRange.doDiff(List<SDVariable> f1)
List<SDVariable>	SwishDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Tanh.doDiff(List<SDVariable> i_v)
List<SDVariable>	ASin.doDiff(List<SDVariable> i_v)
List<SDVariable>	Cosh.doDiff(List<SDVariable> i_v)
List<SDVariable>	Or.doDiff(List<SDVariable> i_v)
List<SDVariable>	ReverseV2.doDiff(List<SDVariable> f1)
List<SDVariable>	MatchConditionTransform.doDiff(List<SDVariable> f1)
List<SDVariable>	TimesOneMinus.doDiff(List<SDVariable> f1)
List<SDVariable>	Pow.doDiff(List<SDVariable> i_v1)
List<SDVariable>	LogSigmoidDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	RSqrt.doDiff(List<SDVariable> i_v)
List<SDVariable>	Log.doDiff(List<SDVariable> i_v)
List<SDVariable>	Not.doDiff(List<SDVariable> f1)
List<SDVariable>	Abs.doDiff(List<SDVariable> i_v)
List<SDVariable>	Floor.doDiff(List<SDVariable> i_v)
List<SDVariable>	SoftSign.doDiff(List<SDVariable> i_v)
List<SDVariable>	Cube.doDiff(List<SDVariable> f1)
List<SDVariable>	Erf.doDiff(List<SDVariable> i_v)
List<SDVariable>	InvertPermutation.doDiff(List<SDVariable> grad)
List<SDVariable>	Stabilize.doDiff(List<SDVariable> f1)
List<SDVariable>	TanhDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	RectifedLinear.doDiff(List<SDVariable> i_v)
List<SDVariable>	Identity.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldIdentity.doDiff(List<SDVariable> i_v)
List<SDVariable>	ReverseSequence.doDiff(List<SDVariable> f1)
List<SDVariable>	Reverse.doDiff(List<SDVariable> f1)
List<SDVariable>	LogSoftMax.doDiff(List<SDVariable> i_v)
List<SDVariable>	Tan.doDiff(List<SDVariable> i_v)
List<SDVariable>	Swish.doDiff(List<SDVariable> i_v)
List<SDVariable>	Erfc.doDiff(List<SDVariable> i_v)
List<SDVariable>	LegacyDropOut.doDiff(List<SDVariable> f1)
List<SDVariable>	MatrixDiag.doDiff(List<SDVariable> i_v)
List<SDVariable>	Set.doDiff(List<SDVariable> i_v)
List<SDVariable>	LogSigmoid.doDiff(List<SDVariable> i_v)
List<SDVariable>	ELU.doDiff(List<SDVariable> i_v)
List<SDVariable>	IsNaN.doDiff(List<SDVariable> i_v)
List<SDVariable>	Rint.doDiff(List<SDVariable> i_v)
List<SDVariable>	OneMinus.doDiff(List<SDVariable> f1)
List<SDVariable>	Cos.doDiff(List<SDVariable> i_v)
List<SDVariable>	XwPlusB.doDiff(List<SDVariable> gradient)
List<SDVariable>	SoftPlus.doDiff(List<SDVariable> i_v)
List<SDVariable>	Negative.doDiff(List<SDVariable> i_v)
List<SDVariable>	IsFinite.doDiff(List<SDVariable> i_v)
List<SDVariable>	LeakyReLU.doDiff(List<SDVariable> i_v)
List<SDVariable>	Sign.doDiff(List<SDVariable> i_v)
List<SDVariable>	RelativeError.doDiff(List<SDVariable> i_v1)
List<SDVariable>	OldSoftMax.doDiff(List<SDVariable> i_v)
List<SDVariable>	Sinh.doDiff(List<SDVariable> i_v)
List<SDVariable>	IsInf.doDiff(List<SDVariable> i_v)
List<SDVariable>	Sin.doDiff(List<SDVariable> i_v)
List<SDVariable>	ACos.doDiff(List<SDVariable> i_v)
List<SDVariable>	IsMax.doDiff(List<SDVariable> f1)
List<SDVariable>	ATanh.doDiff(List<SDVariable> i_v)
List<SDVariable>	MatrixDiagPart.doDiff(List<SDVariable> i_v)
List<SDVariable>	Exp.doDiff(List<SDVariable> i_v)
List<SDVariable>	Square.doDiff(List<SDVariable> i_v)
List<SDVariable>	Histogram.doDiff(List<SDVariable> f1)
List<SDVariable>	MatrixInverse.doDiff(List<SDVariable> i_v)
List<SDVariable>	And.doDiff(List<SDVariable> f1)
List<SDVariable>	Step.doDiff(List<SDVariable> f1)
List<SDVariable>	Fill.doDiff(List<SDVariable> gradients)
List<SDVariable>	MatrixSetDiag.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldReverse.doDiff(List<SDVariable> f1)
List<SDVariable>	Assign.doDiff(List<SDVariable> f1)
List<SDVariable>	LegacyDropOutInverted.doDiff(List<SDVariable> f1)
List<SDVariable>	Sigmoid.doDiff(List<SDVariable> i_v)
List<SDVariable>	SELU.doDiff(List<SDVariable> i_v)
List<SDVariable>	BinaryRelativeError.doDiff(List<SDVariable> i_v1)
List<SDVariable>	DynamicStitch.doDiff(List<SDVariable> i_v)
List<SDVariable>	Constant.doDiff(List<SDVariable> i_v)
List<SDVariable>	MatrixDeterminant.doDiff(List<SDVariable> i_v)
List<SDVariable>	LogX.doDiff(List<SDVariable> f1)
List<SDVariable>	HardTanh.doDiff(List<SDVariable> i_v)
List<SDVariable>	Relu6.doDiff(List<SDVariable> i_v)
List<SDVariable>	Xor.doDiff(List<SDVariable> f1)
List<SDVariable>	HardSigmoid.doDiff(List<SDVariable> f1)
List<SDVariable>	ATan.doDiff(List<SDVariable> i_v)
List<SDVariable>	RectifiedTanh.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.api.ops.impl.transforms with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ASinh.doDiff(List<SDVariable> i_v)
List<SDVariable>	Round.doDiff(List<SDVariable> f1)
List<SDVariable>	PowDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	SpaceToBatch.doDiff(List<SDVariable> i_v)
List<SDVariable>	BinaryMinimalRelativeError.doDiff(List<SDVariable> i_v1)
List<SDVariable>	Log1p.doDiff(List<SDVariable> i_v)
List<SDVariable>	TanDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	MaxOut.doDiff(List<SDVariable> f1)
List<SDVariable>	ReplaceNans.doDiff(List<SDVariable> f1)
List<SDVariable>	SigmoidDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	OldAtan2Op.doDiff(List<SDVariable> f1)
List<SDVariable>	Ceil.doDiff(List<SDVariable> f1)
List<SDVariable>	BatchToSpace.doDiff(List<SDVariable> i_v)
List<SDVariable>	ACosh.doDiff(List<SDVariable> i_v)
List<SDVariable>	ATan2.doDiff(List<SDVariable> i_v)
List<SDVariable>	Trace.doDiff(List<SDVariable> gradAtOutput)
List<SDVariable>	RationalTanh.doDiff(List<SDVariable> f1)
List<SDVariable>	Expm1.doDiff(List<SDVariable> i_v)
List<SDVariable>	Reciprocal.doDiff(List<SDVariable> i_v1)
List<SDVariable>	Sqrt.doDiff(List<SDVariable> i_v)
List<SDVariable>	ReluLayer.doDiff(List<SDVariable> gradient)
List<SDVariable>	SoftMax.doDiff(List<SDVariable> i_v)
List<SDVariable>	SetRange.doDiff(List<SDVariable> f1)
List<SDVariable>	SwishDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	Tanh.doDiff(List<SDVariable> i_v)
List<SDVariable>	ASin.doDiff(List<SDVariable> i_v)
List<SDVariable>	Cosh.doDiff(List<SDVariable> i_v)
List<SDVariable>	Or.doDiff(List<SDVariable> i_v)
List<SDVariable>	ReverseV2.doDiff(List<SDVariable> f1)
List<SDVariable>	MatchConditionTransform.doDiff(List<SDVariable> f1)
List<SDVariable>	TimesOneMinus.doDiff(List<SDVariable> f1)
List<SDVariable>	Pow.doDiff(List<SDVariable> i_v1)
List<SDVariable>	LogSigmoidDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	RSqrt.doDiff(List<SDVariable> i_v)
List<SDVariable>	Log.doDiff(List<SDVariable> i_v)
List<SDVariable>	Not.doDiff(List<SDVariable> f1)
List<SDVariable>	Abs.doDiff(List<SDVariable> i_v)
List<SDVariable>	Floor.doDiff(List<SDVariable> i_v)
List<SDVariable>	SoftSign.doDiff(List<SDVariable> i_v)
List<SDVariable>	Cube.doDiff(List<SDVariable> f1)
List<SDVariable>	Erf.doDiff(List<SDVariable> i_v)
List<SDVariable>	InvertPermutation.doDiff(List<SDVariable> grad)
List<SDVariable>	Stabilize.doDiff(List<SDVariable> f1)
List<SDVariable>	TanhDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	RectifedLinear.doDiff(List<SDVariable> i_v)
List<SDVariable>	Identity.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldIdentity.doDiff(List<SDVariable> i_v)
List<SDVariable>	ReverseSequence.doDiff(List<SDVariable> f1)
List<SDVariable>	Reverse.doDiff(List<SDVariable> f1)
List<SDVariable>	LogSoftMax.doDiff(List<SDVariable> i_v)
List<SDVariable>	Tan.doDiff(List<SDVariable> i_v)
List<SDVariable>	Swish.doDiff(List<SDVariable> i_v)
List<SDVariable>	Erfc.doDiff(List<SDVariable> i_v)
List<SDVariable>	LegacyDropOut.doDiff(List<SDVariable> f1)
List<SDVariable>	MatrixDiag.doDiff(List<SDVariable> i_v)
List<SDVariable>	Set.doDiff(List<SDVariable> i_v)
List<SDVariable>	LogSigmoid.doDiff(List<SDVariable> i_v)
List<SDVariable>	ELU.doDiff(List<SDVariable> i_v)
List<SDVariable>	IsNaN.doDiff(List<SDVariable> i_v)
List<SDVariable>	Rint.doDiff(List<SDVariable> i_v)
List<SDVariable>	OneMinus.doDiff(List<SDVariable> f1)
List<SDVariable>	Cos.doDiff(List<SDVariable> i_v)
List<SDVariable>	XwPlusB.doDiff(List<SDVariable> gradient)
List<SDVariable>	SoftPlus.doDiff(List<SDVariable> i_v)
List<SDVariable>	Negative.doDiff(List<SDVariable> i_v)
List<SDVariable>	IsFinite.doDiff(List<SDVariable> i_v)
List<SDVariable>	LeakyReLU.doDiff(List<SDVariable> i_v)
List<SDVariable>	Sign.doDiff(List<SDVariable> i_v)
List<SDVariable>	RelativeError.doDiff(List<SDVariable> i_v1)
List<SDVariable>	OldSoftMax.doDiff(List<SDVariable> i_v)
List<SDVariable>	Sinh.doDiff(List<SDVariable> i_v)
List<SDVariable>	IsInf.doDiff(List<SDVariable> i_v)
List<SDVariable>	Sin.doDiff(List<SDVariable> i_v)
List<SDVariable>	ACos.doDiff(List<SDVariable> i_v)
List<SDVariable>	IsMax.doDiff(List<SDVariable> f1)
List<SDVariable>	ATanh.doDiff(List<SDVariable> i_v)
List<SDVariable>	MatrixDiagPart.doDiff(List<SDVariable> i_v)
List<SDVariable>	Exp.doDiff(List<SDVariable> i_v)
List<SDVariable>	Square.doDiff(List<SDVariable> i_v)
List<SDVariable>	Histogram.doDiff(List<SDVariable> f1)
List<SDVariable>	MatrixInverse.doDiff(List<SDVariable> i_v)
List<SDVariable>	And.doDiff(List<SDVariable> f1)
List<SDVariable>	Step.doDiff(List<SDVariable> f1)
List<SDVariable>	Fill.doDiff(List<SDVariable> gradients)
List<SDVariable>	MatrixSetDiag.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldReverse.doDiff(List<SDVariable> f1)
List<SDVariable>	Assign.doDiff(List<SDVariable> f1)
List<SDVariable>	LegacyDropOutInverted.doDiff(List<SDVariable> f1)
List<SDVariable>	Sigmoid.doDiff(List<SDVariable> i_v)
List<SDVariable>	SELU.doDiff(List<SDVariable> i_v)
List<SDVariable>	BinaryRelativeError.doDiff(List<SDVariable> i_v1)
List<SDVariable>	DynamicStitch.doDiff(List<SDVariable> i_v)
List<SDVariable>	Constant.doDiff(List<SDVariable> i_v)
List<SDVariable>	MatrixDeterminant.doDiff(List<SDVariable> i_v)
List<SDVariable>	LogX.doDiff(List<SDVariable> f1)
List<SDVariable>	HardTanh.doDiff(List<SDVariable> i_v)
List<SDVariable>	Relu6.doDiff(List<SDVariable> i_v)
List<SDVariable>	Xor.doDiff(List<SDVariable> f1)
List<SDVariable>	HardSigmoid.doDiff(List<SDVariable> f1)
List<SDVariable>	ATan.doDiff(List<SDVariable> i_v)
List<SDVariable>	RectifiedTanh.doDiff(List<SDVariable> f1)

Constructors in org.nd4j.linalg.api.ops.impl.transforms with parameters of type SDVariable

Constructor and Description
Abs(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Abs(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
Abs(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
ACos(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
ACos(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
ACos(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
ACosh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
ACosh(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
ACosh(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
And(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
And(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double comparable)
And(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
And(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, double comparable)
And(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
And(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double comparable)
And(SameDiff sameDiff, SDVariable ix, SDVariable iy)
ASin(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
ASin(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
ASin(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
ASinh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
ASinh(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
ASinh(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Assign(SameDiff sameDiff, SDVariable x, SDVariable y)
ATan(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
ATan(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
ATan(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
ATan2(SameDiff sameDiff, SDVariable y, SDVariable x)
ATanh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
ATanh(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
BaseDynamicTransformOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
BatchToSpace(SameDiff sameDiff, SDVariable[] args, int[] blocks, int[][] crops, boolean inPlace)
BinaryMinimalRelativeError(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
BinaryMinimalRelativeError(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
BinaryMinimalRelativeError(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
BinaryMinimalRelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
BinaryMinimalRelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
BinaryMinimalRelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
BinaryRelativeError(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
BinaryRelativeError(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
BinaryRelativeError(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
BinaryRelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
BinaryRelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
BinaryRelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
Ceil(SameDiff sameDiff, SDVariable i_v)
Ceil(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Ceil(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Constant(SameDiff sameDiff, SDVariable i_v, long[] shape)
Constant(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace)
Cos(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Cos(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Cos(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Cosh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Cosh(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Cosh(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Cube(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Cube(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
Cube(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Dilation2D(SameDiff sameDiff, SDVariable[] inputAndWeights, int[] strides, int[] rates, boolean isSameMode, boolean inPlace)
DynamicPartition(SameDiff sameDiff, SDVariable input, SDVariable partitions, int numPartitions)
DynamicStitch(SameDiff sameDiff, SDVariable[] indices, SDVariable[] inputs)
DynamicStitch(SameDiff sameDiff, SDVariable[] indices, SDVariable[] inputs)
ELU(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
ELU(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
ELU(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Erf(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Erf(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
Erf(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Erfc(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Erfc(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
Erfc(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Exp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Expm1(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Expm1(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Expm1(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Fill(SameDiff sameDiff, SDVariable shape, double value)
Floor(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Floor(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
Floor(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
HardSigmoid(SameDiff sameDiff, SDVariable in, boolean inPlace)
HardTanh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
HardTanh(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
HardTanh(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Histogram(SameDiff sameDiff, SDVariable i_v, boolean inPlace, int numBins)
Histogram(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, int numBins)
Histogram(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, int numBins)
Identity(SameDiff sd, SDVariable input)
InvertPermutation(SameDiff sameDiff, SDVariable input, boolean inPlace)
IsFinite(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
IsFinite(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
IsFinite(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
IsInf(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
IsInf(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
IsInf(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
IsMax(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
IsMax(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
IsMax(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
IsNaN(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
IsNaN(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
IsNaN(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
LeakyReLU(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double alpha)
LeakyReLU(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, double alpha)
LeakyReLU(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double alpha)
LegacyDropOut(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double p)
LegacyDropOut(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs, double p)
LegacyDropOut(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double p)
LegacyDropOutInverted(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double p)
LegacyDropOutInverted(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs, double p)
LegacyDropOutInverted(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double p)
Log(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Log(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Log(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Log1p(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Log1p(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Log1p(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
LogSigmoid(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
LogSigmoid(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
LogSigmoid(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
LogSigmoidDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
LogSigmoidDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
LogSoftMax(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
LogSoftMax(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
LogSoftMax(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
LogX(SameDiff sameDiff, SDVariable i_v, double base)
MatchConditionTransform(SameDiff sameDiff, SDVariable in, Condition condition)
MatrixDeterminant(SameDiff sameDiff, SDVariable in, boolean inPlace)
MatrixDiag(SameDiff sameDiff, SDVariable in, boolean inPlace)
MatrixDiagPart(SameDiff sameDiff, SDVariable in, boolean inPlace)
MatrixInverse(SameDiff sameDiff, SDVariable in, boolean inPlace)
MatrixSetDiag(SameDiff sameDiff, SDVariable in, SDVariable diag, boolean inPlace)
MaxOut(SameDiff sameDiff, SDVariable i_v, boolean inPlace, Number max)
MaxOut(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs, Number max)
MaxOut(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, Number max)
Negative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Negative(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
Negative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Not(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double comparable)
Not(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, double comparable)
Not(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double comparable)
OldAtan2Op(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldAtan2Op(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
OldAtan2Op(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldAtan2Op(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldAtan2Op(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldAtan2Op(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
OldIdentity(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldIdentity(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
OldIdentity(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldReverse(SameDiff sameDiff, SDVariable i_v, int... dimensions)
OldSoftMax(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldSoftMax(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
OldSoftMax(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldSoftMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldSoftMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OneMinus(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OneMinus(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
OneMinus(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Or(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double comparable)
Or(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, double comparable)
Or(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double comparable)
Or(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
Or(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
Pow(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double pow)
Pow(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs, double pow)
Pow(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double pow)
PowDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double pow)
RationalTanh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Reciprocal(SameDiff sameDiff, SDVariable in, boolean inPlace)
RectifedLinear(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double cutoff)
RectifedLinear(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, double cutoff)
RectifedLinear(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs, double cutoff)
RectifiedTanh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
RelativeError(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
RelativeError(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
RelativeError(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
RelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
RelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
RelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
Relu6(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double cutoff)
Relu6(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, double cutoff)
Relu6(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs, double cutoff)
ReluLayer(SameDiff sameDiff, SDVariable input, SDVariable weights, SDVariable bias)
ReplaceNans(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double set)
ReplaceNans(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, double set)
ReplaceNans(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double set)
Reverse(SameDiff sameDiff, SDVariable i_v, int... dimensions)
ReverseSequence(SameDiff sameDiff, SDVariable i_v, SDVariable seqLengths)
ReverseSequence(SameDiff sameDiff, SDVariable i_v, SDVariable seqLengths, int seqDim, int batchDim)
Rint(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Rint(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
Rint(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Round(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Round(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Round(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
RSqrt(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
RSqrt(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
RSqrt(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
SELU(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
SELU(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
SELU(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Set(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Set(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Set(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
SetRange(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double min, double max)
SetRange(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, double min, double max)
SetRange(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double min, double max)
Sigmoid(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Sigmoid(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Sigmoid(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
SigmoidDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
SigmoidDerivative(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
SigmoidDerivative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
SigmoidDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
SigmoidDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
Sign(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Sign(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Sign(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Sin(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Sin(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Sin(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Sinh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Sinh(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Sinh(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
SoftMax(SameDiff sameDiff, SDVariable[] args)
SoftMax(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
SoftMaxDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
SoftMaxDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
SoftPlus(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
SoftPlus(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
SoftPlus(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
SoftSign(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
SoftSign(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
SoftSign(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
SpaceToBatch(SameDiff sameDiff, SDVariable[] args, int[] blocks, int[][] padding, boolean inPlace)
Sqrt(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Sqrt(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Sqrt(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Square(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Square(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Square(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Stabilize(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double realMin, double cutOff, double k)
Stabilize(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, double realMin, double cutOff, double k)
Stabilize(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double realMin, double cutOff, double k)
Step(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double cutoff)
Step(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs, double cutoff)
Step(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double cutoff)
Swish(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Swish(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Swish(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
SwishDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
SwishDerivative(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
SwishDerivative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
SwishDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
SwishDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
Tan(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Tanh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Tanh(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Tanh(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
TanhDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
TanhDerivative(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
TanhDerivative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
TimesOneMinus(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
TimesOneMinus(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
TimesOneMinus(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Trace(SameDiff sd, SDVariable in)
Xor(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double comparable)
Xor(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs, double comparable)
Xor(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double comparable)
Xor(SameDiff sameDiff, SDVariable ix, SDVariable iy)
XwPlusB(SameDiff sameDiff, SDVariable input, SDVariable weights, SDVariable bias)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.arithmetic

Methods in org.nd4j.linalg.api.ops.impl.transforms.arithmetic that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	SquaredDifferenceOp.doDiff(List<SDVariable> i_v1)
List<SDVariable>	RemainderOp.doDiff(List<SDVariable> f1)
List<SDVariable>	AddOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	RSubOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldSubOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	Axpy.doDiff(List<SDVariable> f1)
List<SDVariable>	OldFloorDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	DivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	FloorDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	RealDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	SubOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldFModOp.doDiff(List<SDVariable> f1)
List<SDVariable>	OldRDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldAddOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	MulOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	FModOp.doDiff(List<SDVariable> f1)
List<SDVariable>	MergeAddOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldMulOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	TruncateDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	FloorModOp.doDiff(List<SDVariable> f1)
List<SDVariable>	CopyOp.doDiff(List<SDVariable> f1)
List<SDVariable>	RDivOp.doDiff(List<SDVariable> i_v)

Method parameters in org.nd4j.linalg.api.ops.impl.transforms.arithmetic with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	SquaredDifferenceOp.doDiff(List<SDVariable> i_v1)
List<SDVariable>	RemainderOp.doDiff(List<SDVariable> f1)
List<SDVariable>	AddOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	RSubOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldSubOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	Axpy.doDiff(List<SDVariable> f1)
List<SDVariable>	OldFloorDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	DivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	FloorDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	RealDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	SubOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldFModOp.doDiff(List<SDVariable> f1)
List<SDVariable>	OldRDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldAddOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	MulOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	FModOp.doDiff(List<SDVariable> f1)
List<SDVariable>	MergeAddOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	OldMulOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	TruncateDivOp.doDiff(List<SDVariable> i_v)
List<SDVariable>	FloorModOp.doDiff(List<SDVariable> f1)
List<SDVariable>	CopyOp.doDiff(List<SDVariable> f1)
List<SDVariable>	RDivOp.doDiff(List<SDVariable> i_v)

Constructors in org.nd4j.linalg.api.ops.impl.transforms.arithmetic with parameters of type SDVariable

Constructor and Description
AddOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
Axpy(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double p)
Axpy(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, double p)
Axpy(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double p)
Axpy(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, double p)
Axpy(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, double p)
Axpy(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs, double p)
CopyOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
CopyOp(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
CopyOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
CopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
CopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
CopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
DivOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
FloorDivOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
FloorDivOp(SameDiff sameDiff, SDVariable x, SDVariable y)
FloorModOp(SameDiff sameDiff, SDVariable x, SDVariable y)
FModOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
FModOp(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
FModOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
FModOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
FModOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
FModOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
MergeAddOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
MulOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
OldAddOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldAddOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldFloorDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldFloorDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldFModOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldFModOp(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
OldFModOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldFModOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldFModOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldFModOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
OldMulOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldMulOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldRDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldRDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
RDivOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
RealDivOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
RemainderOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
RemainderOp(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
RemainderOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
RemainderOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
RemainderOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
RemainderOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
RSubOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
RSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
RSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
SquaredDifferenceOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
SubOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
TruncateDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
TruncateDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.arithmetic.bp

Methods in org.nd4j.linalg.api.ops.impl.transforms.arithmetic.bp that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	SquaredDifferenceBpOp.doDiff(List<SDVariable> i_v1)
List<SDVariable>	BaseArithmeticBackpropOp.doDiff(List<SDVariable> i_v)

Method parameters in org.nd4j.linalg.api.ops.impl.transforms.arithmetic.bp with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	SquaredDifferenceBpOp.doDiff(List<SDVariable> i_v1)
List<SDVariable>	BaseArithmeticBackpropOp.doDiff(List<SDVariable> i_v)

Constructors in org.nd4j.linalg.api.ops.impl.transforms.arithmetic.bp with parameters of type SDVariable

Constructor and Description
AddBpOp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps)
BaseArithmeticBackpropOp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps)
DivBpOp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps)
FloorDivBpOp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps)
FloorModBpOp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps)
MulBpOp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps)
RDivBpOp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps)
RSubBpOp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps)
SquaredDifferenceBpOp(SameDiff sameDiff, SDVariable[] args)
SubBpOp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.clip

Methods in org.nd4j.linalg.api.ops.impl.transforms.clip that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ClipByValue.doDiff(List<SDVariable> grad)
List<SDVariable>	ClipByNorm.doDiff(List<SDVariable> grad)

Method parameters in org.nd4j.linalg.api.ops.impl.transforms.clip with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ClipByValue.doDiff(List<SDVariable> grad)
List<SDVariable>	ClipByNorm.doDiff(List<SDVariable> grad)

Constructors in org.nd4j.linalg.api.ops.impl.transforms.clip with parameters of type SDVariable

Constructor and Description
ClipByNorm(SameDiff sameDiff, SDVariable x, double clipValue, int... dimensions)
ClipByNormBp(SameDiff sameDiff, SDVariable x, SDVariable eps, double clipValue, int... dimensions)
ClipByValue(SameDiff sameDiff, SDVariable x, double clipValueMin, double clipValueMax)
ClipByValue(SameDiff sameDiff, SDVariable x, double clipValueMin, double clipValueMax, boolean inPlace)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.comparison

Methods in org.nd4j.linalg.api.ops.impl.transforms.comparison that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	IsStrictlyIncreasing.doDiff(List<SDVariable> f1)
List<SDVariable>	Min.doDiff(List<SDVariable> f1)
List<SDVariable>	NotEqualTo.doDiff(List<SDVariable> i_v)
List<SDVariable>	ListDiff.doDiff(List<SDVariable> f1)
List<SDVariable>	OldEqualTo.doDiff(List<SDVariable> f1)
List<SDVariable>	OldGreaterThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	LessThan.doDiff(List<SDVariable> f1)
List<SDVariable>	OldGreaterThan.doDiff(List<SDVariable> f1)
List<SDVariable>	Eps.doDiff(List<SDVariable> f1)
List<SDVariable>	OldMax.doDiff(List<SDVariable> f1)
List<SDVariable>	IsNumericTensor.doDiff(List<SDVariable> f1)
List<SDVariable>	IsNonDecreasing.doDiff(List<SDVariable> f1)
List<SDVariable>	EqualTo.doDiff(List<SDVariable> f1)
List<SDVariable>	Max.doDiff(List<SDVariable> f1)
List<SDVariable>	CompareAndSet.doDiff(List<SDVariable> gradient)
List<SDVariable>	OldLessThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	CompareAndReplace.doDiff(List<SDVariable> grad)
List<SDVariable>	GreaterThan.doDiff(List<SDVariable> f1)
List<SDVariable>	OldMin.doDiff(List<SDVariable> f1)
List<SDVariable>	LessThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	OldLessThan.doDiff(List<SDVariable> f1)
List<SDVariable>	OldNotEqualTo.doDiff(List<SDVariable> i_v)
List<SDVariable>	GreaterThanOrEqual.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.api.ops.impl.transforms.comparison with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	IsStrictlyIncreasing.doDiff(List<SDVariable> f1)
List<SDVariable>	Min.doDiff(List<SDVariable> f1)
List<SDVariable>	NotEqualTo.doDiff(List<SDVariable> i_v)
List<SDVariable>	ListDiff.doDiff(List<SDVariable> f1)
List<SDVariable>	OldEqualTo.doDiff(List<SDVariable> f1)
List<SDVariable>	OldGreaterThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	LessThan.doDiff(List<SDVariable> f1)
List<SDVariable>	OldGreaterThan.doDiff(List<SDVariable> f1)
List<SDVariable>	Eps.doDiff(List<SDVariable> f1)
List<SDVariable>	OldMax.doDiff(List<SDVariable> f1)
List<SDVariable>	IsNumericTensor.doDiff(List<SDVariable> f1)
List<SDVariable>	IsNonDecreasing.doDiff(List<SDVariable> f1)
List<SDVariable>	EqualTo.doDiff(List<SDVariable> f1)
List<SDVariable>	Max.doDiff(List<SDVariable> f1)
List<SDVariable>	CompareAndSet.doDiff(List<SDVariable> gradient)
List<SDVariable>	OldLessThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	CompareAndReplace.doDiff(List<SDVariable> grad)
List<SDVariable>	GreaterThan.doDiff(List<SDVariable> f1)
List<SDVariable>	OldMin.doDiff(List<SDVariable> f1)
List<SDVariable>	LessThanOrEqual.doDiff(List<SDVariable> f1)
List<SDVariable>	OldLessThan.doDiff(List<SDVariable> f1)
List<SDVariable>	OldNotEqualTo.doDiff(List<SDVariable> i_v)
List<SDVariable>	GreaterThanOrEqual.doDiff(List<SDVariable> f1)

Constructors in org.nd4j.linalg.api.ops.impl.transforms.comparison with parameters of type SDVariable

Constructor and Description
Choose(SameDiff sameDiff, SDVariable[] args, Condition condition)
Choose(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace)
CompareAndReplace(SameDiff sameDiff, SDVariable to, SDVariable from, Condition condition)
CompareAndSet(SameDiff sameDiff, SDVariable to, Number set, Condition condition)
Eps(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
Eps(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
Eps(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
Eps(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
Eps(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
Eps(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
EqualTo(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
GreaterThan(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
GreaterThanOrEqual(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
IsNonDecreasing(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
IsNumericTensor(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
IsStrictlyIncreasing(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
LessThan(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
LessThanOrEqual(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
Max(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
Max(SameDiff sameDiff, SDVariable first, SDVariable second)
Min(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
Min(SameDiff sameDiff, SDVariable first, SDVariable second)
NotEqualTo(SameDiff sameDiff, SDVariable[] args, boolean inPlace)
OldEqualTo(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldEqualTo(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
OldEqualTo(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldEqualTo(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldEqualTo(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldEqualTo(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
OldGreaterThan(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldGreaterThan(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
OldGreaterThan(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldGreaterThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldGreaterThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldGreaterThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
OldGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
OldGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
OldLessThan(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldLessThan(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
OldLessThan(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldLessThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldLessThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldLessThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
OldLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
OldLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldLessThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldLessThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldLessThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
OldMax(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldMax(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
OldMax(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
OldMin(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
OldMin(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
OldMin(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
OldMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
OldMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)
OldNotEqualTo(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
OldNotEqualTo(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.dtype

Methods in org.nd4j.linalg.api.ops.impl.transforms.dtype that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	Cast.doDiff(List<SDVariable> i_v)

Method parameters in org.nd4j.linalg.api.ops.impl.transforms.dtype with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	Cast.doDiff(List<SDVariable> i_v)

Constructors in org.nd4j.linalg.api.ops.impl.transforms.dtype with parameters of type SDVariable

Constructor and Description
Cast(SameDiff sameDiff, SDVariable arg, DataBuffer.Type dst)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.gradient

Methods in org.nd4j.linalg.api.ops.impl.transforms.gradient that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	SigmoidDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	SELUDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	RectifiedTanhDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	SoftmaxBp.doDiff(List<SDVariable> grad)
List<SDVariable>	LeakyReLUDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	CubeDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	TanhDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	HardTanhDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	Relu6Derivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	SoftSignDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	HardSigmoidDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	ELUDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	RationalTanhDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	GradientBackwardsMarker.doDiff(List<SDVariable> i_v)
List<SDVariable>	LogSoftMaxDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	SoftMaxDerivative.doDiff(List<SDVariable> i_v) Deprecated.

Method parameters in org.nd4j.linalg.api.ops.impl.transforms.gradient with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	SigmoidDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	SELUDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	RectifiedTanhDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	SoftmaxBp.doDiff(List<SDVariable> grad)
List<SDVariable>	LeakyReLUDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	CubeDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	TanhDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	HardTanhDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	Relu6Derivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	SoftSignDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	HardSigmoidDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	ELUDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	RationalTanhDerivative.doDiff(List<SDVariable> f1)
List<SDVariable>	GradientBackwardsMarker.doDiff(List<SDVariable> i_v)
List<SDVariable>	LogSoftMaxDerivative.doDiff(List<SDVariable> i_v)
List<SDVariable>	SoftMaxDerivative.doDiff(List<SDVariable> i_v) Deprecated.

Constructors in org.nd4j.linalg.api.ops.impl.transforms.gradient with parameters of type SDVariable

Constructor and Description
CubeDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
CubeDerivative(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
CubeDerivative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
ELUDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
ELUDerivative(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
ELUDerivative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
GradientBackwardsMarker(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
GradientBackwardsMarker(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
HardSigmoidDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
HardSigmoidDerivative(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)
HardSigmoidDerivative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
HardTanhDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
HardTanhDerivative(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
HardTanhDerivative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
LeakyReLUDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double alpha)
LeakyReLUDerivative(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs, double alpha)
LeakyReLUDerivative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double alpha)
LeakyReLUDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, double alpha)
LeakyReLUDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, double alpha)
LogSoftMaxDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
LogSoftMaxDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
RationalTanhDerivative(SameDiff sameDiff, SDVariable in, boolean inPlace)
RectifiedTanhDerivative(SameDiff sameDiff, SDVariable in, boolean inPlace)
Relu6Derivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, double cutoff)
SELUDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
SELUDerivative(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
SELUDerivative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
SigmoidDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
SigmoidDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)
SoftmaxBp(SameDiff sd, SDVariable input, SDVariable grad, Integer dimension)
SoftSignDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)
SoftSignDerivative(SameDiff sameDiff, SDVariable i_v, int[] shape, boolean inPlace, Object[] extraArgs)
SoftSignDerivative(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)
TanhDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)
TanhDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.segment

Constructors in org.nd4j.linalg.api.ops.impl.transforms.segment with parameters of type SDVariable

Constructor and Description
SegmentMax(SameDiff sameDiff, SDVariable data, SDVariable segmentIds)
SegmentMean(SameDiff sameDiff, SDVariable data, SDVariable segmentIds)
SegmentMin(SameDiff sameDiff, SDVariable data, SDVariable segmentIds)
SegmentProd(SameDiff sameDiff, SDVariable data, SDVariable segmentIds)
SegmentSum(SameDiff sameDiff, SDVariable data, SDVariable segmentIds)

Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.temp

Methods in org.nd4j.linalg.api.ops.impl.transforms.temp that return SDVariable

Modifier and Type	Method and Description
SDVariable[]	ExternalErrorsFunction.outputVariables(String baseName)

Methods in org.nd4j.linalg.api.ops.impl.transforms.temp that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ExternalErrorsFunction.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.api.ops.impl.transforms.temp with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	ExternalErrorsFunction.doDiff(List<SDVariable> f1)

Constructor parameters in org.nd4j.linalg.api.ops.impl.transforms.temp with type arguments of type SDVariable

Constructor and Description
ExternalErrorsFunction(SameDiff sd, List<SDVariable> inputs, Map<String,INDArray> gradients)

Uses of SDVariable in org.nd4j.linalg.api.ops.random

Constructors in org.nd4j.linalg.api.ops.random with parameters of type SDVariable

Constructor and Description
BaseRandomOp(SameDiff sameDiff, SDVariable i_v)

Uses of SDVariable in org.nd4j.linalg.api.ops.random.compat

Constructors in org.nd4j.linalg.api.ops.random.compat with parameters of type SDVariable

Constructor and Description
RandomStandardNormal(SameDiff sameDiff, SDVariable[] args)

Uses of SDVariable in org.nd4j.linalg.api.ops.random.custom

Methods in org.nd4j.linalg.api.ops.random.custom that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	RandomNormal.doDiff(List<SDVariable> grad)
List<SDVariable>	RandomBernoulli.doDiff(List<SDVariable> gradients)
List<SDVariable>	DistributionUniform.doDiff(List<SDVariable> gradients)
List<SDVariable>	RandomExponential.doDiff(List<SDVariable> gradients)

Method parameters in org.nd4j.linalg.api.ops.random.custom with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	RandomNormal.doDiff(List<SDVariable> grad)
List<SDVariable>	RandomBernoulli.doDiff(List<SDVariable> gradients)
List<SDVariable>	DistributionUniform.doDiff(List<SDVariable> gradients)
List<SDVariable>	RandomExponential.doDiff(List<SDVariable> gradients)

Constructors in org.nd4j.linalg.api.ops.random.custom with parameters of type SDVariable

Constructor and Description
DistributionUniform(SameDiff sd, SDVariable shape, double min, double max)
RandomBernoulli(SameDiff sd, SDVariable shape, double p)
RandomExponential(SameDiff sd, SDVariable shape, double lambda)
RandomNormal(SameDiff sameDiff, SDVariable shape, double mean, double stdev)

Uses of SDVariable in org.nd4j.linalg.api.ops.random.impl

Methods in org.nd4j.linalg.api.ops.random.impl that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	Linspace.doDiff(List<SDVariable> f1)
List<SDVariable>	DropOut.doDiff(List<SDVariable> f1)
List<SDVariable>	BernoulliDistribution.doDiff(List<SDVariable> f1)
List<SDVariable>	Range.doDiff(List<SDVariable> f1)
List<SDVariable>	BinomialDistributionEx.doDiff(List<SDVariable> f1)
List<SDVariable>	ProbablisticMerge.doDiff(List<SDVariable> f1)
List<SDVariable>	Choice.doDiff(List<SDVariable> f1)
List<SDVariable>	TruncatedNormalDistribution.doDiff(List<SDVariable> f1)
List<SDVariable>	AlphaDropOut.doDiff(List<SDVariable> f1)
List<SDVariable>	DropOutInverted.doDiff(List<SDVariable> f1)
List<SDVariable>	BinomialDistribution.doDiff(List<SDVariable> f1)
List<SDVariable>	LogNormalDistribution.doDiff(List<SDVariable> f1)
List<SDVariable>	GaussianDistribution.doDiff(List<SDVariable> f1)
List<SDVariable>	UniformDistribution.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.api.ops.random.impl with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	Linspace.doDiff(List<SDVariable> f1)
List<SDVariable>	DropOut.doDiff(List<SDVariable> f1)
List<SDVariable>	BernoulliDistribution.doDiff(List<SDVariable> f1)
List<SDVariable>	Range.doDiff(List<SDVariable> f1)
List<SDVariable>	BinomialDistributionEx.doDiff(List<SDVariable> f1)
List<SDVariable>	ProbablisticMerge.doDiff(List<SDVariable> f1)
List<SDVariable>	Choice.doDiff(List<SDVariable> f1)
List<SDVariable>	TruncatedNormalDistribution.doDiff(List<SDVariable> f1)
List<SDVariable>	AlphaDropOut.doDiff(List<SDVariable> f1)
List<SDVariable>	DropOutInverted.doDiff(List<SDVariable> f1)
List<SDVariable>	BinomialDistribution.doDiff(List<SDVariable> f1)
List<SDVariable>	LogNormalDistribution.doDiff(List<SDVariable> f1)
List<SDVariable>	GaussianDistribution.doDiff(List<SDVariable> f1)
List<SDVariable>	UniformDistribution.doDiff(List<SDVariable> f1)

Constructors in org.nd4j.linalg.api.ops.random.impl with parameters of type SDVariable

Constructor and Description
DropOut(SameDiff sameDiff, SDVariable input, double p)
DropOutInverted(SameDiff sameDiff, SDVariable input, double p)

Uses of SDVariable in org.nd4j.linalg.lossfunctions.impl

Methods in org.nd4j.linalg.lossfunctions.impl that return SDVariable

Modifier and Type	Method and Description
SDVariable[]	LossMAPE.outputVariables()
SDVariable[]	LossMSLE.outputVariables()
SDVariable[]	LossMultiLabel.outputVariables()
SDVariable[]	LossCosineProximity.outputVariables()
SDVariable[]	LossHinge.outputVariables()
SDVariable[]	LossSquaredHinge.outputVariables()
SDVariable[]	LossFMeasure.outputVariables()
SDVariable[]	LossKLD.outputVariables()
SDVariable[]	LossBinaryXENT.outputVariables()
SDVariable[]	LossMCXENT.outputVariables()
SDVariable[]	LossMixtureDensity.outputVariables()
SDVariable[]	LossL1.outputVariables()
SDVariable[]	LossPoisson.outputVariables()
SDVariable[]	LossL2.outputVariables()
SDVariable[]	LossMAPE.outputVariables(String baseName)
SDVariable[]	LossMSLE.outputVariables(String baseName)
SDVariable[]	LossMultiLabel.outputVariables(String baseName)
SDVariable[]	LossCosineProximity.outputVariables(String baseName)
SDVariable[]	LossHinge.outputVariables(String baseName)
SDVariable[]	LossSquaredHinge.outputVariables(String baseName)
SDVariable[]	LossFMeasure.outputVariables(String baseName)
SDVariable[]	LossKLD.outputVariables(String baseName)
SDVariable[]	LossBinaryXENT.outputVariables(String baseName)
SDVariable[]	LossMCXENT.outputVariables(String baseName)
SDVariable[]	LossMixtureDensity.outputVariables(String baseName)
SDVariable[]	LossL1.outputVariables(String baseName)
SDVariable[]	LossPoisson.outputVariables(String baseName)
SDVariable[]	LossL2.outputVariables(String baseName)

Methods in org.nd4j.linalg.lossfunctions.impl that return types with arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	LossMAPE.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMSLE.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMultiLabel.doDiff(List<SDVariable> f1)
List<SDVariable>	LossCosineProximity.doDiff(List<SDVariable> f1)
List<SDVariable>	LossHinge.doDiff(List<SDVariable> f1)
List<SDVariable>	LossSquaredHinge.doDiff(List<SDVariable> f1)
List<SDVariable>	LossFMeasure.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMSE.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMAE.doDiff(List<SDVariable> f1)
List<SDVariable>	LossKLD.doDiff(List<SDVariable> f1)
List<SDVariable>	LossBinaryXENT.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMCXENT.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMixtureDensity.doDiff(List<SDVariable> f1)
List<SDVariable>	LossL1.doDiff(List<SDVariable> f1)
List<SDVariable>	LossPoisson.doDiff(List<SDVariable> f1)
List<SDVariable>	LossL2.doDiff(List<SDVariable> f1)

Method parameters in org.nd4j.linalg.lossfunctions.impl with type arguments of type SDVariable

Modifier and Type	Method and Description
List<SDVariable>	LossMAPE.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMSLE.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMultiLabel.doDiff(List<SDVariable> f1)
List<SDVariable>	LossCosineProximity.doDiff(List<SDVariable> f1)
List<SDVariable>	LossHinge.doDiff(List<SDVariable> f1)
List<SDVariable>	LossSquaredHinge.doDiff(List<SDVariable> f1)
List<SDVariable>	LossFMeasure.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMSE.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMAE.doDiff(List<SDVariable> f1)
List<SDVariable>	LossKLD.doDiff(List<SDVariable> f1)
List<SDVariable>	LossBinaryXENT.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMCXENT.doDiff(List<SDVariable> f1)
List<SDVariable>	LossMixtureDensity.doDiff(List<SDVariable> f1)
List<SDVariable>	LossL1.doDiff(List<SDVariable> f1)
List<SDVariable>	LossPoisson.doDiff(List<SDVariable> f1)
List<SDVariable>	LossL2.doDiff(List<SDVariable> f1)