DifferentialFunctionFactory (nd4j-api 1.0.0-beta5 API)

java.lang.Object
- org.nd4j.autodiff.functions.DifferentialFunctionFactory

public class DifferentialFunctionFactory
extends Object

Field Summary

Fields
Modifier and Type Field and Description

protected SameDiff sameDiff

Fields
Modifier and Type	Field and Description
`protected SameDiff`	`sameDiff`

Constructor Summary

Constructors
Constructor and Description

DifferentialFunctionFactory(SameDiff sameDiff)

Constructors
Constructor and Description
`DifferentialFunctionFactory(SameDiff sameDiff)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`SDVariable`	`abs(SDVariable iX)`
`SDVariable`	`acos(SDVariable iX)`
`SDVariable`	`acosh(SDVariable iX)`
`SDVariable`	`add(SDVariable differentialFunction, double i_v)`
`SDVariable`	`add(SDVariable differentialFunction, SDVariable i_v)`
`List<SDVariable>`	`addBp(SDVariable x, SDVariable y, SDVariable grad)`
`SDVariable`	`addi(SDVariable differentialFunction, double i_v)`
`SDVariable`	`addi(SDVariable differentialFunction, SDVariable i_v)`
`SDVariable`	`all(SDVariable input, int... dimensions)`
`SDVariable`	`amax(SDVariable in, int... dimensions)`
`SDVariable`	`amean(SDVariable in, int... dimensions)`
`SDVariable`	`amin(SDVariable in, int... dimensions)`
`SDVariable`	`and(SDVariable ix, SDVariable iy)`
`SDVariable`	`any(SDVariable input, int... dimensions)`
`SDVariable`	`argmax(SDVariable in, boolean keepDims, int... dimensions)`
`SDVariable`	`argmin(SDVariable in, boolean keepDims, int... dimensions)`
`SDVariable`	`asin(SDVariable iX)`
`SDVariable`	`asinh(SDVariable iX)`
`SDVariable`	`assign(SDVariable x, Number num)`
`SDVariable`	`assign(SDVariable x, SDVariable y)`
`SDVariable`	`asum(SDVariable in, int... dimensions)`
`SDVariable`	`atan(SDVariable iX)`
`SDVariable`	`atan2(SDVariable y, SDVariable x)`
`SDVariable`	`atanh(SDVariable iX)`
`SDVariable`	`avgPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig)` Average pooling 2d operation.
`SDVariable`	`avgPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig)` Avg pooling 3d operation.
`SDVariable[]`	`batchMmul(SDVariable[] matrices, boolean transposeA, boolean transposeB)`
`SDVariable[]`	`batchMmul(SDVariable[] matricesA, SDVariable[] matricesB)`
`SDVariable[]`	`batchMmul(SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB)`
`SDVariable`	`batchNorm(SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon, int... axis)` Batch norm operation.
`SDVariable`	`batchToSpace(SDVariable differentialFunction, int[] blocks, int[][] crops)`
`SDVariable`	`biasAdd(SDVariable input, SDVariable bias)`
`SDVariable[]`	`biasAddBp(SDVariable input, SDVariable bias, SDVariable grad)`
`SDVariable`	`bitwiseAnd(SDVariable x, SDVariable y)`
`SDVariable`	`bitwiseHammingDist(SDVariable x, SDVariable y)`
`SDVariable`	`bitwiseOr(SDVariable x, SDVariable y)`
`SDVariable`	`bitwiseXor(SDVariable x, SDVariable y)`
`SDVariable`	`cast(SDVariable toCast, DataType toType)`
`SDVariable`	`ceil(SDVariable x)`
`SDVariable`	`clipByNorm(SDVariable x, double clipValue)`
`SDVariable`	`clipByNorm(SDVariable x, double clipValue, int... dimensions)`
`SDVariable`	`clipByValue(SDVariable x, double clipValueMin, double clipValueMax)`
`SDVariable`	`col2Im(SDVariable input, Conv2DConfig config)`
`SDVariable`	`concat(int dimension, SDVariable... inputs)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, DataType dataType)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights)`
`SDVariable`	`constant(SDVariable input, long... shape)`
`SDVariable`	`conv1d(SDVariable input, SDVariable weights, Conv1DConfig conv1DConfig)` Conv1d operation.
`SDVariable`	`conv1d(SDVariable input, SDVariable weights, SDVariable bias, Conv1DConfig conv1DConfig)` Conv1d operation.
`SDVariable`	`conv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig)` Conv2d operation.
`SDVariable`	`conv3d(SDVariable[] inputs, Conv3DConfig conv3DConfig)` Conv3d operation.
`SDVariable`	`cos(SDVariable iX)`
`SDVariable`	`cosh(SDVariable iX)`
`SDVariable`	`cosineDistance(SDVariable ix, SDVariable iy, int... dimensions)`
`SDVariable`	`cosineSimilarity(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`countNonZero(SDVariable input, int... dimensions)`
`SDVariable`	`countZero(SDVariable input, int... dimensions)`
`SDVariable`	`cross(SDVariable a, SDVariable b)`
`SDVariable`	`cube(SDVariable iX)`
`SDVariable`	`cubeBp(SDVariable in, SDVariable epsilon)`
`SDVariable`	`cubeDerivative(SDVariable iX)` Deprecated. Use `cubeBp(SDVariable, SDVariable)`
`SDVariable`	`cumprod(SDVariable in, boolean exclusive, boolean reverse, int... axis)`
`SDVariable`	`cumprodBp(SDVariable in, SDVariable grad, boolean exclusive, boolean reverse, int... axis)`
`SDVariable`	`cumsum(SDVariable in, boolean exclusive, boolean reverse, int... axis)`
`SDVariable`	`cumsumBp(SDVariable in, SDVariable grad, boolean exclusive, boolean reverse, int... axis)`
`SDVariable`	`deconv2d(SDVariable[] inputs, DeConv2DConfig deconv2DConfig)` Deconv2d operation.
`SDVariable`	`deconv3d(SDVariable input, SDVariable weights, SDVariable bias, DeConv3DConfig config)`
`SDVariable[]`	`deconv3dDerivative(SDVariable input, SDVariable weights, SDVariable bias, SDVariable grad, DeConv3DConfig config)`
`SDVariable`	`depthToSpace(SDVariable differentialFunction, int blocksSize, String dataFormat)`
`SDVariable`	`depthWiseConv2d(SDVariable[] inputs, Conv2DConfig depthConv2DConfig)` Depth-wise Conv2d operation.
`SDVariable`	`diag(SDVariable sdVariable)`
`SDVariable`	`diagPart(SDVariable sdVariable)`
`SDVariable`	`dilation2D(SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)`
`SDVariable`	`div(SDVariable differentialFunction, double i_v)`
`SDVariable`	`div(SDVariable differentialFunction, SDVariable i_v)`
`List<SDVariable>`	`divBp(SDVariable x, SDVariable y, SDVariable grad)`
`SDVariable`	`divi(SDVariable differentialFunction, double i_v)`
`SDVariable`	`divi(SDVariable differentialFunction, SDVariable i_v)`
`SDVariable`	`doRepeat(SDVariable func, SDVariable input)`
`SDVariable`	`dot(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable[]`	`dotBp(SDVariable in1, SDVariable in2, SDVariable grad, boolean keepDims, int... dimensions)`
`SDVariable`	`dotProductAttention(SDVariable queries, SDVariable keys, SDVariable values, SDVariable mask, boolean scaled)`
`List<SDVariable>`	`dotProductAttention(SDVariable queries, SDVariable keys, SDVariable values, SDVariable mask, boolean scaled, boolean withWeights)`
`List<SDVariable>`	`dotProductAttentionBp(SDVariable queries, SDVariable keys, SDVariable values, SDVariable gradient, SDVariable mask, boolean scaled)`
`SDVariable`	`dropout(SDVariable input, double p)`
`SDVariable[]`	`dynamicPartition(SDVariable differentialFunction, SDVariable partitions, int numPartitions)`
`SDVariable[]`	`dynamicPartitionBp(SDVariable input, SDVariable partitions, SDVariable[] grads, int numPartitions)`
`SDVariable`	`dynamicStitch(SDVariable[] indices, SDVariable[] differentialFunctions)`
`SDVariable`	`elu(SDVariable iX)`
`SDVariable`	`eluBp(SDVariable in, SDVariable epsilon, double alpha)`
`SDVariable`	`enter(SDVariable x, String frameName)`
`SDVariable`	`enter(SDVariable x, String frameName, boolean isConstant)`
`SDVariable`	`entropy(SDVariable in, int... dimensions)`
`SDVariable`	`eq(SDVariable iX, double i_y)`
`SDVariable`	`eq(SDVariable iX, SDVariable i_y)`
`SDVariable`	`eqi(SDVariable iX, double i_y)`
`SDVariable`	`erf(SDVariable differentialFunction)`
`SDVariable`	`erfc(SDVariable differentialFunction)`
`SDVariable`	`euclideanDistance(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`exit(SDVariable x)`
`SDVariable`	`exp(SDVariable iX)`
`SDVariable`	`expandDims(SDVariable iX, int axis)`
`SDVariable`	`expm1(SDVariable iX)`
`ExternalErrorsFunction`	`externalErrors(Map<String,INDArray> externalGradients, SDVariable... inputs)`
`ExternalErrorsFunction`	`externalErrors(SDVariable... inputs)`
`SDVariable`	`extractImagePatches(SDVariable input, int kH, int kW, int sH, int sW, int rH, int rW, boolean sameMode)`
`SDVariable`	`fill(SDVariable shape, DataType dataType, double value)`
`SDVariable`	`firstIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)`
`SDVariable`	`floor(SDVariable iX)`
`SDVariable`	`floorDiv(SDVariable x, SDVariable y)`
`List<SDVariable>`	`floorDivBp(SDVariable x, SDVariable y, SDVariable grad)`
`SDVariable`	`floorMod(SDVariable x, SDVariable y)`
`List<SDVariable>`	`floorModBp(SDVariable x, SDVariable y, SDVariable grad)`
`SDVariable`	`gather(SDVariable df, int[] indices, int axis)`
`SDVariable`	`gather(SDVariable df, SDVariable indices, int axis)`
`SDVariable`	`gatherNd(SDVariable df, SDVariable indices)`
`SDVariable`	`gelu(SDVariable iX, boolean precise)`
`SDVariable`	`geluDerivative(SDVariable iX, boolean precise)`
`SDVariable`	`gradientBackwardsMarker(SDVariable iX)`
`SDVariable`	`gt(SDVariable functionInput, double functionInput1)`
`SDVariable`	`gt(SDVariable functionInput, SDVariable functionInput1)`
`SDVariable`	`gte(SDVariable functionInput, double functionInput1)`
`SDVariable`	`gte(SDVariable functionInput, SDVariable functionInput1)`
`SDVariable`	`gtei(SDVariable functionInput, double functionInput1)`
`SDVariable`	`gtei(SDVariable functionInput, SDVariable functionInput1)`
`SDVariable`	`gti(SDVariable functionInput, double functionInput1)`
`SDVariable`	`gti(SDVariable functionInput, SDVariable functionInput1)`
`SDVariable`	`hammingDistance(SDVariable ix, SDVariable iy, int... dimensions)`
`SDVariable`	`hardSigmoid(SDVariable in)`
`SDVariable`	`hardSigmoidBp(SDVariable in, SDVariable epsilon)`
`SDVariable`	`hardTanh(SDVariable iX)`
`SDVariable`	`hardTanhBp(SDVariable in, SDVariable epsilon)`
`SDVariable`	`hardTanhDerivative(SDVariable iX)` Deprecated. Use `hardTanhBp(SDVariable, SDVariable)`
`SDVariable`	`iamax(SDVariable in, boolean keepDims, int... dimensions)`
`SDVariable`	`iamin(SDVariable in, boolean keepDims, int... dimensions)`
`SDVariable`	`identity(SDVariable input)`
`SDVariable`	`im2Col(SDVariable input, Conv2DConfig config)`
`SDVariable`	`im2ColBp(SDVariable im2colInput, SDVariable gradientAtOutput, Conv2DConfig config)`
`SDVariable`	`invertPermutation(SDVariable input, boolean inPlace)`
`SDVariable`	`invoke(String name, Object[] args)`
`SDVariable`	`isFinite(SDVariable ix)`
`SDVariable`	`isInfinite(SDVariable ix)`
`SDVariable`	`isMax(SDVariable ix)`
`SDVariable`	`isNaN(SDVariable ix)`
`SDVariable`	`isNonDecreasing(SDVariable iX)`
`SDVariable`	`isNumericTensor(SDVariable iX)`
`SDVariable`	`isStrictlyIncreasing(SDVariable iX)`
`SDVariable`	`jaccardDistance(SDVariable ix, SDVariable iy, int... dimensions)`
`SDVariable`	`lastIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)`
`SDVariable`	`layerNorm(SDVariable input, SDVariable gain, boolean channelsFirst, int... dimensions)`
`SDVariable`	`layerNorm(SDVariable input, SDVariable gain, SDVariable bias, boolean channelsFirst, int... dimensions)`
`SDVariable[]`	`layerNormBp(SDVariable input, SDVariable gain, SDVariable gradient, boolean channelsFirst, int... dimensions)`
`SDVariable[]`	`layerNormBp(SDVariable input, SDVariable gain, SDVariable bias, SDVariable gradient, boolean channelsFirst, int... dimensions)`
`SDVariable`	`leakyRelu(SDVariable iX, double alpha)`
`SDVariable`	`leakyReluBp(SDVariable in, SDVariable epsilon, double cutoff)`
`SDVariable`	`leakyReluDerivative(SDVariable iX, double cutoff)` Deprecated. Use `leakyReluBp(SDVariable, SDVariable, double)`
`SDVariable`	`linspace(SDVariable lower, SDVariable upper, SDVariable count, DataType dt)`
`SDVariable[]`	`listdiff(SDVariable x, SDVariable y)`
`SDVariable`	`localResponseNormalization(SDVariable input, LocalResponseNormalizationConfig lrnConfig)` Local response normalization operation.
`SDVariable`	`log(SDVariable iX)`
`SDVariable`	`log(SDVariable in, double base)`
`SDVariable`	`log1p(SDVariable iX)`
`SDVariable`	`logEntropy(SDVariable in, int... dimensions)`
`SDVariable`	`logSigmoid(SDVariable iX)`
`SDVariable`	`logSoftmax(SDVariable i_v)`
`SDVariable`	`logSoftmax(SDVariable i_v, int dimension)`
`SDVariable`	`logSoftmaxDerivative(SDVariable arg, SDVariable wrt)`
`SDVariable`	`logSoftmaxDerivative(SDVariable arg, SDVariable wrt, int dimension)`
`SDVariable`	`logSumExp(SDVariable arg, boolean keepDims, int... dimension)`
`SDVariable`	`lossAbsoluteDifference(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable[]`	`lossAbsoluteDifferenceBP(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable`	`lossCosineDistance(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, int dimension)`
`SDVariable[]`	`lossCosineDistanceBp(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, int dimension)`
`SDVariable`	`lossHinge(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable[]`	`lossHingeBp(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable`	`lossHuber(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double delta)`
`SDVariable[]`	`lossHuberBp(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double delta)`
`SDVariable`	`lossL2(SDVariable var)`
`SDVariable`	`lossLog(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double epsilon)`
`SDVariable[]`	`lossLogBp(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double epsilon)`
`SDVariable`	`lossLogPoisson(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable[]`	`lossLogPoissonBp(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable`	`lossLogPoissonFull(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable[]`	`lossLogPoissonFullBp(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable`	`lossMeanPairwiseSquaredError(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable[]`	`lossMeanPairwiseSquaredErrorBp(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable`	`lossMeanSquaredError(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable[]`	`lossMeanSquaredErrorBp(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)`
`SDVariable`	`lossSigmoidCrossEntropy(SDVariable labels, SDVariable logits, SDVariable weights, LossReduce lossReduce, double labelSmoothing)`
`SDVariable[]`	`lossSigmoidCrossEntropyBp(SDVariable labels, SDVariable logits, SDVariable weights, LossReduce lossReduce, double labelSmoothing)`
`SDVariable`	`lossSoftmaxCrossEntropy(SDVariable labels, SDVariable logits, SDVariable weights, LossReduce lossReduce, double labelSmoothing)`
`SDVariable[]`	`lossSoftmaxCrossEntropyBp(SDVariable labels, SDVariable logits, SDVariable weights, LossReduce lossReduce, double labelSmoothing)`
`SDVariable`	`lossSoftmaxCrossEntropyWithLogits(SDVariable labels, SDVariable logits, SDVariable weights, int classDim)`
`SDVariable[]`	`lossSoftmaxCrossEntropyWithLogitsBp(SDVariable labels, SDVariable logits, SDVariable weights, int classDim)`
`SDVariable`	`lossSparseSoftmaxCrossEntropy(SDVariable logits, SDVariable labels)`
`SDVariable[]`	`lossSparseSoftmaxCrossEntropyBp(SDVariable logits, SDVariable labels)`
`SDVariable`	`lt(SDVariable functionInput, double functionInput1)`
`SDVariable`	`lt(SDVariable functionInput, SDVariable functionInput1)`
`SDVariable`	`lte(SDVariable functionInput, double functionInput1)`
`SDVariable`	`lte(SDVariable functionInput, SDVariable functionInput1)`
`SDVariable`	`ltei(SDVariable functionInput, double functionInput1)`
`SDVariable`	`lti(SDVariable functionInput, double functionInput1)`
`SDVariable`	`lti(SDVariable functionInput, SDVariable functionInput1)`
`SDVariable`	`ltOrEqi(SDVariable functionInput, SDVariable functionInput1)`
`SDVariable`	`manhattanDistance(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`matchCondition(SDVariable in, Condition condition)` Returns a boolean mask of equal shape to the input, where the condition is satisfied
`SDVariable`	`matchConditionCount(SDVariable in, Condition condition, boolean keepDims, int... dimensions)` Returns a count of the number of elements that satisfy the condition
`SDVariable`	`matrixDeterminant(SDVariable in)`
`SDVariable`	`matrixInverse(SDVariable in)`
`SDVariable`	`max(SDVariable i_x, boolean keepDims, int... dimensions)`
`SDVariable`	`max(SDVariable first, SDVariable second)`
`SDVariable`	`maxBp(SDVariable i_x, SDVariable grad, boolean keepDims, int... dimensions)`
`SDVariable`	`maxPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig)` Max pooling 2d operation.
`SDVariable`	`maxPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig)` Max pooling 3d operation.
`SDVariable`	`mean(SDVariable in, boolean keepDims, int... dimensions)`
`SDVariable`	`meanBp(SDVariable in, SDVariable grad, boolean keepDims, int... dimensions)`
`SDVariable`	`merge(SDVariable... inputs)`
`SDVariable`	`mergeAdd(SDVariable... differentialFunctions)`
`SDVariable`	`mergeAvg(SDVariable... differentialFunctions)`
`SDVariable`	`mergeMax(SDVariable... differentialFunctions)`
`SDVariable[]`	`meshgrid(boolean cartesian, SDVariable... inputs)`
`SDVariable`	`min(SDVariable i_x, boolean keepDims, int... dimensions)`
`SDVariable`	`min(SDVariable first, SDVariable second)`
`SDVariable`	`minBp(SDVariable i_x, SDVariable grad, boolean keepDims, int... dimensions)`
`SDVariable`	`mmul(SDVariable x, SDVariable y)`
`SDVariable`	`mmul(SDVariable x, SDVariable y, MMulTranspose mMulTranspose)`
`List<SDVariable>`	`mmulBp(SDVariable x, SDVariable y, SDVariable eps, MMulTranspose mt)`
`SDVariable`	`mod(SDVariable differentialFunction, SDVariable i_v)`
`List<SDVariable>`	`modBp(SDVariable x, SDVariable y, SDVariable grad)`
`SDVariable[]`	`moments(SDVariable input, int... axes)`
`SDVariable`	`mul(SDVariable differentialFunction, double i_v)`
`SDVariable`	`mul(SDVariable differentialFunction, SDVariable i_v)`
`List<SDVariable>`	`mulBp(SDVariable x, SDVariable y, SDVariable grad)`
`SDVariable`	`muli(SDVariable differentialFunction, double i_v)`
`SDVariable`	`muli(SDVariable differentialFunction, SDVariable i_v)`
`SDVariable`	`multiHeadDotProductAttention(SDVariable queries, SDVariable keys, SDVariable values, SDVariable Wq, SDVariable Wk, SDVariable Wv, SDVariable Wo, SDVariable mask, boolean scaled)`
`List<SDVariable>`	`multiHeadDotProductAttention(SDVariable queries, SDVariable keys, SDVariable values, SDVariable Wq, SDVariable Wk, SDVariable Wv, SDVariable Wo, SDVariable mask, boolean scaled, boolean withWeights)`
`List<SDVariable>`	`multiHeadDotProductAttentionBp(SDVariable queries, SDVariable keys, SDVariable values, SDVariable Wq, SDVariable Wk, SDVariable Wv, SDVariable Wo, SDVariable gradient, SDVariable mask, boolean scaled)`
`SDVariable`	`neg(SDVariable iX)`
`SDVariable`	`neq(SDVariable iX, double i_y)`
`SDVariable`	`neq(SDVariable iX, SDVariable i_y)`
`SDVariable`	`neqi(SDVariable iX, double i_y)`
`SDVariable`	`neqi(SDVariable iX, SDVariable i_y)`
`SDVariable`	`nextIteration(SDVariable x)`
`SDVariable`	`noop(SDVariable input)`
`SDVariable`	`norm1(SDVariable i_x, boolean keepDims, int... dimensions)`
`SDVariable`	`norm1Bp(SDVariable preReduceIn, SDVariable grad, boolean keepDims, int... dimensions)`
`SDVariable`	`norm2(SDVariable i_x, boolean keepDims, int... dimensions)`
`SDVariable`	`norm2Bp(SDVariable preReduceIn, SDVariable grad, boolean keepDims, int... dimensions)`
`SDVariable[]`	`normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)`
`SDVariable`	`normmax(SDVariable i_x, boolean keepDims, int... dimensions)`
`SDVariable`	`normmaxBp(SDVariable preReduceIn, SDVariable grad, boolean keepDims, int... dimensions)`
`SDVariable`	`onehot(SDVariable indices, int depth)`
`SDVariable`	`onehot(SDVariable indices, int depth, int axis, double on, double off, DataType dataType)`
`SDVariable`	`onesLike(String name, SDVariable input, DataType dataType)`
`SDVariable`	`or(SDVariable iX, SDVariable i_y)`
`SDVariable`	`pad(SDVariable input, SDVariable padding, Pad.Mode mode, double padValue)`
`SDVariable`	`parallel_stack(SDVariable[] values)`
`SDVariable`	`permute(SDVariable iX, int... dimensions)`
`SDVariable`	`permute(SDVariable in, SDVariable dimensions)`
`SDVariable`	`pow(SDVariable iX, double i_y)`
`SDVariable`	`pow(SDVariable x, SDVariable y)`
`SDVariable`	`powDerivative(SDVariable iX, double pow)`
`SDVariable`	`prod(SDVariable i_x, boolean keepDims, int... dimensions)`
`SDVariable`	`prodBp(SDVariable preReduceInput, SDVariable grad, boolean keepDims, int... dimensions)`
`SDVariable`	`randomBernoulli(double p, long... shape)`
`SDVariable`	`randomBernoulli(double p, SDVariable shape)`
`SDVariable`	`randomBinomial(int nTrials, double p, long... shape)`
`SDVariable`	`randomExponential(double lambda, SDVariable shape)` Exponential distribution: P(x) = lambda * exp(-lambda * x)
`SDVariable`	`randomLogNormal(double mean, double stdev, long... shape)`
`SDVariable`	`randomNormal(double mean, double std, long... shape)`
`SDVariable`	`randomNormal(double mean, double std, SDVariable shape)`
`SDVariable`	`randomNormalTruncated(double mean, double stdev, long... shape)`
`SDVariable`	`randomUniform(double min, double max, long... shape)`
`SDVariable`	`randomUniform(double min, double max, SDVariable shape)`
`SDVariable`	`range(double from, double to, double step, DataType dataType)`
`SDVariable`	`range(SDVariable from, SDVariable to, SDVariable step, DataType dataType)`
`SDVariable`	`rank(SDVariable df)`
`SDVariable`	`rdiv(SDVariable differentialFunction, double i_v)`
`SDVariable`	`rdiv(SDVariable differentialFunction, SDVariable i_v)`
`List<SDVariable>`	`rdivBp(SDVariable x, SDVariable y, SDVariable grad)`
`SDVariable`	`rdivi(SDVariable differentialFunction, double i_v)`
`SDVariable`	`rdivi(SDVariable differentialFunction, SDVariable i_v)`
`SDVariable`	`reciprocal(SDVariable a)`
`SDVariable`	`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`	`reductionBroadcastableWithOrigShape(SDVariable origInput, SDVariable axis, SDVariable toExpand)`
`SDVariable`	`reductionShape(SDVariable shape, SDVariable axis, boolean keepDim)`
`SDVariable`	`relu(SDVariable iX, double cutoff)`
`SDVariable`	`relu6(SDVariable iX, double cutoff)`
`SDVariable`	`relu6Derivative(SDVariable iX, SDVariable wrt, double cutoff)`
`SDVariable`	`reluDerivative(SDVariable input, SDVariable grad)`
`SDVariable`	`reluLayer(SDVariable input, SDVariable weights, SDVariable bias)`
`SDVariable`	`repeat(SDVariable iX, int axis)`
`SDVariable`	`replaceWhere(SDVariable to, Number set, Condition condition)`
`SDVariable`	`replaceWhere(SDVariable to, SDVariable from, Condition condition)`
`SDVariable`	`reshape(SDVariable iX, int[] shape)`
`SDVariable`	`reshape(SDVariable iX, long[] shape)`
`SDVariable`	`reshape(SDVariable iX, SDVariable shape)`
`SDVariable`	`reverse(SDVariable x, int... dimensions)`
`SDVariable`	`reverseSequence(SDVariable x, SDVariable seq_lengths)`
`SDVariable`	`reverseSequence(SDVariable x, SDVariable seq_lengths, int seq_dim, int batch_dim)`
`SDVariable`	`rotl(SDVariable ix, SDVariable shift)`
`SDVariable`	`rotr(SDVariable ix, SDVariable shift)`
`SDVariable`	`round(SDVariable ix)`
`SDVariable`	`rshift(SDVariable ix, SDVariable shift)`
`SDVariable`	`rsqrt(SDVariable iX)`
`SDVariable`	`rsub(SDVariable differentialFunction, double i_v)`
`SDVariable`	`rsub(SDVariable differentialFunction, SDVariable i_v)`
`List<SDVariable>`	`rsubBp(SDVariable x, SDVariable y, SDVariable grad)`
`SDVariable`	`rsubi(SDVariable differentialFunction, double i_v)`
`SDVariable`	`rsubi(SDVariable differentialFunction, SDVariable i_v)`
`SameDiff`	`sameDiff()`
`SDVariable`	`scalarFloorMod(SDVariable in, Number num)`
`SDVariable`	`scalarMax(SDVariable in, Number num)`
`SDVariable`	`scalarMin(SDVariable in, Number num)`
`SDVariable`	`scalarSet(SDVariable in, Number num)`
`SDVariable`	`scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterMax(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterMin(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterUpdate(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`sconv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig)` Separable Conv2d operation.
`SDVariable`	`segmentMax(SDVariable data, SDVariable segmentIds)`
`SDVariable[]`	`segmentMaxBp(SDVariable data, SDVariable segmentIds, SDVariable gradient)`
`SDVariable`	`segmentMean(SDVariable data, SDVariable segmentIds)`
`SDVariable[]`	`segmentMeanBp(SDVariable data, SDVariable segmentIds, SDVariable gradient)`
`SDVariable`	`segmentMin(SDVariable data, SDVariable segmentIds)`
`SDVariable[]`	`segmentMinBp(SDVariable data, SDVariable segmentIds, SDVariable gradient)`
`SDVariable`	`segmentProd(SDVariable data, SDVariable segmentIds)`
`SDVariable[]`	`segmentProdBp(SDVariable data, SDVariable segmentIds, SDVariable gradient)`
`SDVariable`	`segmentSum(SDVariable data, SDVariable segmentIds)`
`SDVariable[]`	`segmentSumBp(SDVariable data, SDVariable segmentIds, SDVariable gradient)`
`SDVariable`	`selu(SDVariable arg)`
`SDVariable`	`seluBp(SDVariable in, SDVariable epsilon)`
`SDVariable`	`seluDerivative(SDVariable arg)` Deprecated. Use `seluBp(SDVariable, SDVariable)`
`SDVariable`	`sequenceMask(SDVariable lengths, DataType dataType)`
`SDVariable`	`sequenceMask(SDVariable lengths, int maxLen, DataType dataType)`
`SDVariable`	`sequenceMask(SDVariable lengths, SDVariable maxLen, DataType dataType)`
`SDVariable`	`setDiag(SDVariable in, SDVariable diag)`
`SDVariable`	`shannonEntropy(SDVariable in, int... dimensions)`
`SDVariable`	`shape(SDVariable df)`
`SDVariable`	`shift(SDVariable ix, SDVariable shift)`
`SDVariable`	`sigmoid(SDVariable iX)`
`SDVariable`	`sigmoidDerivative(SDVariable iX, SDVariable wrt)`
`SDVariable`	`sign(SDVariable iX)`
`SDVariable`	`sin(SDVariable iX)`
`SDVariable`	`sinh(SDVariable iX)`
`SDVariable`	`size(SDVariable in)`
`SDVariable`	`sizeAt(SDVariable in, int dimension)`
`SDVariable`	`slice(SDVariable input, int[] begin, int[] size)`
`SDVariable`	`slice(SDVariable input, SDVariable begin, SDVariable size)`
`SDVariable`	`sliceBp(SDVariable input, SDVariable gradient, int[] begin, int[] size)`
`SDVariable`	`sliceBp(SDVariable input, SDVariable gradient, SDVariable begin, SDVariable size)`
`SDVariable`	`softmax(SDVariable iX)`
`SDVariable`	`softmax(SDVariable iX, int dimension)`
`SDVariable`	`softmaxDerivative(SDVariable functionInput, SDVariable wrt, Integer dimension)`
`SDVariable`	`softplus(SDVariable iX)`
`SDVariable`	`softsign(SDVariable iX)`
`SDVariable`	`softsignBp(SDVariable in, SDVariable epsilon)`
`SDVariable`	`softsignDerivative(SDVariable iX)` Deprecated. Use `softsignBp(SDVariable, SDVariable)`
`SDVariable`	`spaceToBatch(SDVariable differentialFunction, int[] blocks, int[][] padding)`
`SDVariable`	`spaceToDepth(SDVariable differentialFunction, int blocksSize, String dataFormat)`
`SDVariable`	`sqrt(SDVariable iX)`
`SDVariable`	`square(SDVariable iX)`
`SDVariable`	`squaredDifference(SDVariable differentialFunction, SDVariable i_v)`
`SDVariable`	`squaredNorm(SDVariable input, boolean keepDims, int... dimensions)`
`SDVariable`	`squaredNormBp(SDVariable preReduceInput, SDVariable gradient, boolean keepDims, int... dimensions)`
`SDVariable`	`squeeze(SDVariable iX, int... axis)`
`SDVariable`	`stack(SDVariable[] values, int axis)`
`SDVariable`	`standardize(SDVariable i_x, int... dimensions)`
`SDVariable`	`standardizeBp(SDVariable stdInput, SDVariable gradient, int... dimensions)`
`SDVariable`	`std(SDVariable i_x, boolean biasCorrected, boolean keepDims, int... dimensions)`
`SDVariable`	`stdBp(SDVariable stdInput, SDVariable gradient, boolean biasCorrected, boolean keepDims, int... dimensions)`
`SDVariable`	`step(SDVariable in, double cutoff)`
`SDVariable`	`stridedSlice(SDVariable input, int[] begin, int[] end, int[] strides)`
`SDVariable`	`stridedSlice(SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)`
`SDVariable`	`stridedSlice(SDVariable input, long[] begin, long[] end, long[] strides)`
`SDVariable`	`stridedSlice(SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)`
`SDVariable`	`stridedSliceBp(SDVariable in, SDVariable grad, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)`
`SDVariable`	`stridedSliceBp(SDVariable in, SDVariable grad, SDVariable begin, SDVariable end, SDVariable strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)`
`SDVariable`	`sub(SDVariable differentialFunction, double i_v)`
`SDVariable`	`sub(SDVariable differentialFunction, SDVariable i_v)`
`List<SDVariable>`	`subBp(SDVariable x, SDVariable y, SDVariable grad)`
`SDVariable`	`subi(SDVariable differentialFunction, double i_v)`
`SDVariable`	`subi(SDVariable differentialFunction, SDVariable i_v)`
`SDVariable`	`sum(SDVariable i_x, boolean keepDims, int... dimensions)`
`SDVariable`	`sumBp(SDVariable i_x, SDVariable grad, boolean keepDims, int... dimensions)`
`SDVariable`	`swish(SDVariable iX)`
`SDVariable`	`swishDerivative(SDVariable iX)`
`SDVariable[]`	`switchOp(SDVariable input, SDVariable predicate)`
`SDVariable`	`tan(SDVariable iX)`
`SDVariable`	`tanh(SDVariable iX)`
`SDVariable`	`tanhDerivative(SDVariable iX, SDVariable wrt)`
`SDVariable`	`tanhRational(SDVariable in)`
`SDVariable`	`tanhRationalBp(SDVariable in, SDVariable epsilon)`
`SDVariable`	`tanhRationalDerivative(SDVariable in)` Deprecated.
`SDVariable`	`tanhRectified(SDVariable in)`
`SDVariable`	`tanhRectifiedBp(SDVariable in, SDVariable epsilon)`
`SDVariable`	`tanhRectifiedDerivative(SDVariable in)` Deprecated.
`SDVariable`	`tensorMmul(SDVariable x, SDVariable y, int[][] dimensions)`
`SDVariable`	`thresholdRelu(SDVariable in, SDVariable epsilon, double cutoff)`
`SDVariable`	`thresholdReluBp(SDVariable in, SDVariable epsilon, double cutoff)`
`SDVariable`	`tile(SDVariable iX, int[] repeat)`
`SDVariable`	`tile(SDVariable iX, SDVariable repeat)`
`SDVariable`	`tileBp(SDVariable in, SDVariable grad, int[] repeat)`
`SDVariable`	`tileBp(SDVariable in, SDVariable repeat, SDVariable grad)`
`String`	`toString()`
`SDVariable`	`trace(SDVariable in)`
`SDVariable`	`transpose(SDVariable iX)`
`SDVariable`	`truncatedDiv(SDVariable differentialFunction, SDVariable i_v)`
`SDVariable`	`unsortedSegmentMax(SDVariable data, SDVariable segmentIds, int numSegments)`
`SDVariable[]`	`unsortedSegmentMaxBp(SDVariable data, SDVariable segmentIds, SDVariable gradient, int numSegments)`
`SDVariable`	`unsortedSegmentMean(SDVariable data, SDVariable segmentIds, int numSegments)`
`SDVariable[]`	`unsortedSegmentMeanBp(SDVariable data, SDVariable segmentIds, SDVariable gradient, int numSegments)`
`SDVariable`	`unsortedSegmentMin(SDVariable data, SDVariable segmentIds, int numSegments)`
`SDVariable[]`	`unsortedSegmentMinBp(SDVariable data, SDVariable segmentIds, SDVariable gradient, int numSegments)`
`SDVariable`	`unsortedSegmentProd(SDVariable data, SDVariable segmentIds, int numSegments)`
`SDVariable[]`	`unsortedSegmentProdBp(SDVariable data, SDVariable segmentIds, SDVariable gradient, int numSegments)`
`SDVariable`	`unsortedSegmentSqrtN(SDVariable data, SDVariable segmentIds, int numSegments)`
`SDVariable[]`	`unsortedSegmentSqrtNBp(SDVariable data, SDVariable segmentIds, SDVariable gradient, int numSegments)`
`SDVariable`	`unsortedSegmentSum(SDVariable data, SDVariable segmentIds, int numSegments)`
`SDVariable[]`	`unsortedSegmentSumBp(SDVariable data, SDVariable segmentIds, SDVariable gradient, int numSegments)`
`SDVariable[]`	`unstack(SDVariable value, int axis)`
`SDVariable[]`	`unstack(SDVariable value, int axis, int num)`
`SDVariable`	`upsampling2d(SDVariable input, boolean nchw, int scaleH, int scaleW)`
`SDVariable`	`upsampling2dBp(SDVariable input, SDVariable gradient, boolean nchw, int scaleH, int scaleW)`
`Constant`	`val(SDVariable iX)`
`void`	`validateDifferentialFunctionGraph(SDVariable function)`
`void`	`validateDifferentialFunctionsameDiff(SDVariable function)`
`SDVariable`	`variance(SDVariable i_x, boolean biasCorrected, boolean keepDims, int... dimensions)`
`SDVariable`	`varianceBp(SDVariable stdInput, SDVariable gradient, boolean biasCorrected, boolean keepDims, int... dimensions)`
`SDVariable`	`weightedCrossEntropyWithLogits(SDVariable targets, SDVariable inputs, SDVariable weights)`
`SDVariable`	`xor(SDVariable ix, SDVariable iy)`
`SDVariable`	`xwPlusB(SDVariable input, SDVariable weights, SDVariable bias)`
`SDVariable`	`zeroFraction(SDVariable input)`
`SDVariable`	`zerosLike(SDVariable input)`
`SDVariable`	`zerosLike(String name, SDVariable input)`

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

Field Detail
- sameDiff
```
protected SameDiff sameDiff
```

Constructor Detail
- DifferentialFunctionFactory
```
public DifferentialFunctionFactory(SameDiff sameDiff)
```
  Parameters:
  
  sameDiff -

Method Detail

sameDiff
```
public SameDiff sameDiff()
```

invoke

public SDVariable invoke(String name,
                         Object[] args)

val
```
public Constant val(SDVariable iX)
```

externalErrors

public ExternalErrorsFunction externalErrors(SDVariable... inputs)

externalErrors

public ExternalErrorsFunction externalErrors(Map<String,INDArray> externalGradients,
                                             SDVariable... inputs)

zerosLike

public SDVariable zerosLike(SDVariable input)

zerosLike

public SDVariable zerosLike(String name,
                            SDVariable input)

onesLike

public SDVariable onesLike(String name,
                           SDVariable input,
                           DataType dataType)

constant

public SDVariable constant(SDVariable input,
                           long... shape)

linspace

public SDVariable linspace(SDVariable lower,
                           SDVariable upper,
                           SDVariable count,
                           DataType dt)

range

public SDVariable range(double from,
                        double to,
                        double step,
                        DataType dataType)

range

public SDVariable range(SDVariable from,
                        SDVariable to,
                        SDVariable step,
                        DataType dataType)

listdiff

public SDVariable[] listdiff(SDVariable x,
                             SDVariable y)

cast

public SDVariable cast(SDVariable toCast,
                       DataType toType)

meshgrid

public SDVariable[] meshgrid(boolean cartesian,
                             SDVariable... inputs)

randomUniform

public SDVariable randomUniform(double min,
                                double max,
                                SDVariable shape)

randomUniform

public SDVariable randomUniform(double min,
                                double max,
                                long... shape)

randomNormal

public SDVariable randomNormal(double mean,
                               double std,
                               SDVariable shape)

randomNormal

public SDVariable randomNormal(double mean,
                               double std,
                               long... shape)

randomBernoulli

public SDVariable randomBernoulli(double p,
                                  SDVariable shape)

randomBernoulli

public SDVariable randomBernoulli(double p,
                                  long... shape)

randomBinomial

public SDVariable randomBinomial(int nTrials,
                                 double p,
                                 long... shape)

randomLogNormal

public SDVariable randomLogNormal(double mean,
                                  double stdev,
                                  long... shape)

randomNormalTruncated

public SDVariable randomNormalTruncated(double mean,
                                        double stdev,
                                        long... shape)

randomExponential

public SDVariable randomExponential(double lambda,
                                    SDVariable shape)

Exponential distribution: P(x) = lambda * exp(-lambda * x)

Parameters:: lambda - Must be > 0; shape - Shape of the output

pad

public SDVariable pad(SDVariable input,
                      SDVariable padding,
                      Pad.Mode mode,
                      double padValue)

localResponseNormalization

public SDVariable localResponseNormalization(SDVariable input,
                                             LocalResponseNormalizationConfig lrnConfig)

Local response normalization operation.

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

conv1d

public SDVariable conv1d(SDVariable input,
                         SDVariable weights,
                         Conv1DConfig conv1DConfig)

Conv1d operation.

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

conv1d

public SDVariable conv1d(SDVariable input,
                         SDVariable weights,
                         SDVariable bias,
                         Conv1DConfig conv1DConfig)

Conv1d operation.

Parameters:: input - the inputs to conv1d; weights - conv1d weights; bias - conv1d bias; conv1DConfig - the configuration
Returns:

conv2d

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

Conv2d operation.

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

upsampling2d

public SDVariable upsampling2d(SDVariable input,
                               boolean nchw,
                               int scaleH,
                               int scaleW)

upsampling2dBp

public SDVariable upsampling2dBp(SDVariable input,
                                 SDVariable gradient,
                                 boolean nchw,
                                 int scaleH,
                                 int scaleW)

avgPooling2d

public SDVariable avgPooling2d(SDVariable input,
                               Pooling2DConfig pooling2DConfig)

Average pooling 2d operation.

Parameters:: input - the inputs to pooling; pooling2DConfig - the configuration
Returns:

maxPooling2d

public SDVariable maxPooling2d(SDVariable input,
                               Pooling2DConfig pooling2DConfig)

Max pooling 2d operation.

Parameters:: input - the inputs to pooling; pooling2DConfig - the configuration
Returns:

avgPooling3d

public SDVariable avgPooling3d(SDVariable input,
                               Pooling3DConfig pooling3DConfig)

Avg pooling 3d operation.

Parameters:: input - the inputs to pooling; pooling3DConfig - the configuration
Returns:

maxPooling3d

public SDVariable maxPooling3d(SDVariable input,
                               Pooling3DConfig pooling3DConfig)

Max pooling 3d operation.

Parameters:: input - the inputs to pooling; pooling3DConfig - the configuration
Returns:

sconv2d

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

Separable Conv2d operation.

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

depthWiseConv2d
```
public SDVariable depthWiseConv2d(SDVariable[] inputs,
                                  Conv2DConfig depthConv2DConfig)
```
Depth-wise Conv2d operation. This is just separable convolution with only the depth-wise weights specified.

Parameters:

inputs - the inputs to conv2d

depthConv2DConfig - the configuration

Returns:

deconv2d

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

Deconv2d operation.

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

deconv3d

public SDVariable deconv3d(SDVariable input,
                           SDVariable weights,
                           SDVariable bias,
                           DeConv3DConfig config)

deconv3dDerivative

public SDVariable[] deconv3dDerivative(SDVariable input,
                                       SDVariable weights,
                                       SDVariable bias,
                                       SDVariable grad,
                                       DeConv3DConfig config)

conv3d

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

Conv3d operation.

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

batchNorm

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

Batch norm operation.

im2Col

public SDVariable im2Col(SDVariable input,
                         Conv2DConfig config)

im2ColBp

public SDVariable im2ColBp(SDVariable im2colInput,
                           SDVariable gradientAtOutput,
                           Conv2DConfig config)

col2Im

public SDVariable col2Im(SDVariable input,
                         Conv2DConfig config)

extractImagePatches

public SDVariable extractImagePatches(SDVariable input,
                                      int kH,
                                      int kW,
                                      int sH,
                                      int sW,
                                      int rH,
                                      int rW,
                                      boolean sameMode)

moments

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

normalizeMoments

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

tile

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

tileBp

public SDVariable tileBp(@NonNull
                         SDVariable in,
                         @NonNull
                         SDVariable grad,
                         @NonNull
                         int[] repeat)

tile

public SDVariable tile(@NonNull
                       SDVariable iX,
                       @NonNull
                       SDVariable repeat)

tileBp

public SDVariable tileBp(@NonNull
                         SDVariable in,
                         @NonNull
                         SDVariable repeat,
                         @NonNull
                         SDVariable grad)

dropout

public SDVariable dropout(SDVariable input,
                          double p)

sum

public SDVariable sum(SDVariable i_x,
                      boolean keepDims,
                      int... dimensions)

sumBp

public SDVariable sumBp(SDVariable i_x,
                        SDVariable grad,
                        boolean keepDims,
                        int... dimensions)

prod

public SDVariable prod(SDVariable i_x,
                       boolean keepDims,
                       int... dimensions)

prodBp

public SDVariable prodBp(SDVariable preReduceInput,
                         SDVariable grad,
                         boolean keepDims,
                         int... dimensions)

mean

public SDVariable mean(SDVariable in,
                       boolean keepDims,
                       int... dimensions)

meanBp

public SDVariable meanBp(SDVariable in,
                         SDVariable grad,
                         boolean keepDims,
                         int... dimensions)

std

public SDVariable std(SDVariable i_x,
                      boolean biasCorrected,
                      boolean keepDims,
                      int... dimensions)

stdBp

public SDVariable stdBp(SDVariable stdInput,
                        SDVariable gradient,
                        boolean biasCorrected,
                        boolean keepDims,
                        int... dimensions)

variance

public SDVariable variance(SDVariable i_x,
                           boolean biasCorrected,
                           boolean keepDims,
                           int... dimensions)

varianceBp

public SDVariable varianceBp(SDVariable stdInput,
                             SDVariable gradient,
                             boolean biasCorrected,
                             boolean keepDims,
                             int... dimensions)

standardize

public SDVariable standardize(SDVariable i_x,
                              int... dimensions)

standardizeBp

public SDVariable standardizeBp(SDVariable stdInput,
                                SDVariable gradient,
                                int... dimensions)

layerNorm

public SDVariable layerNorm(SDVariable input,
                            SDVariable gain,
                            SDVariable bias,
                            boolean channelsFirst,
                            int... dimensions)

layerNormBp

public SDVariable[] layerNormBp(SDVariable input,
                                SDVariable gain,
                                SDVariable bias,
                                SDVariable gradient,
                                boolean channelsFirst,
                                int... dimensions)

layerNorm

public SDVariable layerNorm(SDVariable input,
                            SDVariable gain,
                            boolean channelsFirst,
                            int... dimensions)

layerNormBp

public SDVariable[] layerNormBp(SDVariable input,
                                SDVariable gain,
                                SDVariable gradient,
                                boolean channelsFirst,
                                int... dimensions)

squaredNorm

public SDVariable squaredNorm(SDVariable input,
                              boolean keepDims,
                              int... dimensions)

squaredNormBp

public SDVariable squaredNormBp(SDVariable preReduceInput,
                                SDVariable gradient,
                                boolean keepDims,
                                int... dimensions)

entropy

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

logEntropy

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

shannonEntropy

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

countNonZero

public SDVariable countNonZero(SDVariable input,
                               int... dimensions)

countZero

public SDVariable countZero(SDVariable input,
                            int... dimensions)

zeroFraction

public SDVariable zeroFraction(SDVariable input)

scalarMax

public SDVariable scalarMax(SDVariable in,
                            Number num)

scalarMin

public SDVariable scalarMin(SDVariable in,
                            Number num)

scalarSet

public SDVariable scalarSet(SDVariable in,
                            Number num)

scalarFloorMod

public SDVariable scalarFloorMod(SDVariable in,
                                 Number num)

max

public SDVariable max(SDVariable i_x,
                      boolean keepDims,
                      int... dimensions)

max

public SDVariable max(SDVariable first,
                      SDVariable second)

maxBp

public SDVariable maxBp(SDVariable i_x,
                        SDVariable grad,
                        boolean keepDims,
                        int... dimensions)

min

public SDVariable min(SDVariable i_x,
                      boolean keepDims,
                      int... dimensions)

minBp

public SDVariable minBp(SDVariable i_x,
                        SDVariable grad,
                        boolean keepDims,
                        int... dimensions)

min

public SDVariable min(SDVariable first,
                      SDVariable second)

amax

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

amin

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

amean

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

asum

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

argmax

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

argmin

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

iamax

public SDVariable iamax(SDVariable in,
                        boolean keepDims,
                        int... dimensions)

iamin

public SDVariable iamin(SDVariable in,
                        boolean keepDims,
                        int... dimensions)

firstIndex

public SDVariable firstIndex(SDVariable in,
                             Condition condition,
                             boolean keepDims,
                             int... dimensions)

lastIndex

public SDVariable lastIndex(SDVariable in,
                            Condition condition,
                            boolean keepDims,
                            int... dimensions)

matchConditionCount

public SDVariable matchConditionCount(SDVariable in,
                                      Condition condition,
                                      boolean keepDims,
                                      int... dimensions)

Returns a count of the number of elements that satisfy the condition

Parameters:: in - Input; condition - Condition
Returns:: Number of elements that the condition is satisfied for

matchCondition
```
public SDVariable matchCondition(SDVariable in,
                                 Condition condition)
```
Returns a boolean mask of equal shape to the input, where the condition is satisfied

Parameters:

in - Input

condition - Condition

Returns:

Boolean mask

cumsum

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

cumsumBp

public SDVariable cumsumBp(SDVariable in,
                           SDVariable grad,
                           boolean exclusive,
                           boolean reverse,
                           int... axis)

cumprod

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

cumprodBp

public SDVariable cumprodBp(SDVariable in,
                            SDVariable grad,
                            boolean exclusive,
                            boolean reverse,
                            int... axis)

biasAdd

public SDVariable biasAdd(SDVariable input,
                          SDVariable bias)

biasAddBp

public SDVariable[] biasAddBp(SDVariable input,
                              SDVariable bias,
                              SDVariable grad)

norm1

public SDVariable norm1(SDVariable i_x,
                        boolean keepDims,
                        int... dimensions)

norm1Bp

public SDVariable norm1Bp(SDVariable preReduceIn,
                          SDVariable grad,
                          boolean keepDims,
                          int... dimensions)

norm2

public SDVariable norm2(SDVariable i_x,
                        boolean keepDims,
                        int... dimensions)

norm2Bp

public SDVariable norm2Bp(SDVariable preReduceIn,
                          SDVariable grad,
                          boolean keepDims,
                          int... dimensions)

normmax

public SDVariable normmax(SDVariable i_x,
                          boolean keepDims,
                          int... dimensions)

normmaxBp

public SDVariable normmaxBp(SDVariable preReduceIn,
                            SDVariable grad,
                            boolean keepDims,
                            int... dimensions)

reductionShape

public SDVariable reductionShape(SDVariable shape,
                                 SDVariable axis,
                                 boolean keepDim)

reductionBroadcastableWithOrigShape
```
public SDVariable 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.
Example: if doing [a,b,c].sum(1), result is [a,c]. To 'undo' this in a way that can be auto-broadcast, we want to expand as required - i.e., [a,c] -> [a,1,c] which can be auto-broadcast with the original [a,b,c]. This is typically only used with reduction operations backprop.

Parameters:

origRank - Rank of the original array, before the reduction was executed

reduceDims - Dimensions that the original array was reduced from

toExpand - Array to add 1s to the shape to (such that it can be

Returns:

Reshaped array.

reductionBroadcastableWithOrigShape

public SDVariable reductionBroadcastableWithOrigShape(SDVariable origInput,
                                                      SDVariable axis,
                                                      SDVariable toExpand)

gradientBackwardsMarker

public SDVariable gradientBackwardsMarker(SDVariable iX)

abs
```
public SDVariable abs(SDVariable iX)
```

neg
```
public SDVariable neg(SDVariable iX)
```

cos
```
public SDVariable cos(SDVariable iX)
```

sin
```
public SDVariable sin(SDVariable iX)
```

tan
```
public SDVariable tan(SDVariable iX)
```

permute

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

permute

public SDVariable permute(SDVariable in,
                          SDVariable dimensions)

noop

public SDVariable noop(SDVariable input)

identity

public SDVariable identity(SDVariable input)

all

public SDVariable all(SDVariable input,
                      int... dimensions)

any

public SDVariable any(SDVariable input,
                      int... dimensions)

invertPermutation

public SDVariable invertPermutation(SDVariable input,
                                    boolean inPlace)

transpose

public SDVariable transpose(SDVariable iX)

acos

public SDVariable acos(SDVariable iX)

asin

public SDVariable asin(SDVariable iX)

atan

public SDVariable atan(SDVariable iX)

atan2

public SDVariable atan2(SDVariable y,
                        SDVariable x)

cosh

public SDVariable cosh(SDVariable iX)

sinh

public SDVariable sinh(SDVariable iX)

tanh

public SDVariable tanh(SDVariable iX)

tanhRational

public SDVariable tanhRational(SDVariable in)

tanhRectified

public SDVariable tanhRectified(SDVariable in)

tanhDerivative

public SDVariable tanhDerivative(SDVariable iX,
                                 SDVariable wrt)

tanhRationalBp

public SDVariable tanhRationalBp(SDVariable in,
                                 SDVariable epsilon)

tanhRectifiedBp

public SDVariable tanhRectifiedBp(SDVariable in,
                                  SDVariable epsilon)

tanhRationalDerivative

@Deprecated
public SDVariable tanhRationalDerivative(SDVariable in)

Deprecated.

Use tanhRationalBp(SDVariable, SDVariable)

tanhRectifiedDerivative

@Deprecated
public SDVariable tanhRectifiedDerivative(SDVariable in)

Deprecated.

Use tanhRectifiedBp(SDVariable, SDVariable)

step

public SDVariable step(SDVariable in,
                       double cutoff)

acosh

public SDVariable acosh(SDVariable iX)

asinh

public SDVariable asinh(SDVariable iX)

atanh

public SDVariable atanh(SDVariable iX)

exp
```
public SDVariable exp(SDVariable iX)
```

expm1

public SDVariable expm1(SDVariable iX)

rsqrt

public SDVariable rsqrt(SDVariable iX)

log
```
public SDVariable log(SDVariable iX)
```

log

public SDVariable log(SDVariable in,
                      double base)

log1p

public SDVariable log1p(SDVariable iX)

isFinite

public SDVariable isFinite(SDVariable ix)

isInfinite

public SDVariable isInfinite(SDVariable ix)

isNaN

public SDVariable isNaN(SDVariable ix)

isMax

public SDVariable isMax(SDVariable ix)

replaceWhere

public SDVariable replaceWhere(SDVariable to,
                               SDVariable from,
                               Condition condition)

replaceWhere

public SDVariable replaceWhere(SDVariable to,
                               Number set,
                               Condition condition)

round

public SDVariable round(SDVariable ix)

or

public SDVariable or(SDVariable iX,
                     SDVariable i_y)

and

public SDVariable and(SDVariable ix,
                      SDVariable iy)

xor

public SDVariable xor(SDVariable ix,
                      SDVariable iy)

shift

public SDVariable shift(SDVariable ix,
                        SDVariable shift)

rshift

public SDVariable rshift(SDVariable ix,
                         SDVariable shift)

rotl

public SDVariable rotl(SDVariable ix,
                       SDVariable shift)

rotr

public SDVariable rotr(SDVariable ix,
                       SDVariable shift)

bitwiseHammingDist

public SDVariable bitwiseHammingDist(SDVariable x,
                                     SDVariable y)

bitwiseAnd

public SDVariable bitwiseAnd(SDVariable x,
                             SDVariable y)

bitwiseOr

public SDVariable bitwiseOr(SDVariable x,
                            SDVariable y)

bitwiseXor

public SDVariable bitwiseXor(SDVariable x,
                             SDVariable y)

eq

public SDVariable eq(SDVariable iX,
                     SDVariable i_y)

neq

public SDVariable neq(SDVariable iX,
                      double i_y)

neqi

public SDVariable neqi(SDVariable iX,
                       double i_y)

neqi

public SDVariable neqi(SDVariable iX,
                       SDVariable i_y)

neq

public SDVariable neq(SDVariable iX,
                      SDVariable i_y)

pow

public SDVariable pow(SDVariable iX,
                      double i_y)

pow

public SDVariable pow(SDVariable x,
                      SDVariable y)

sqrt

public SDVariable sqrt(SDVariable iX)

square

public SDVariable square(SDVariable iX)

cube

public SDVariable cube(SDVariable iX)

cubeBp

public SDVariable cubeBp(SDVariable in,
                         SDVariable epsilon)

cubeDerivative

@Deprecated
public SDVariable cubeDerivative(SDVariable iX)

Deprecated. Use cubeBp(SDVariable, SDVariable)

floor

public SDVariable floor(SDVariable iX)

floorDiv

public SDVariable floorDiv(SDVariable x,
                           SDVariable y)

floorDivBp

public List<SDVariable> floorDivBp(SDVariable x,
                                   SDVariable y,
                                   SDVariable grad)

floorMod

public SDVariable floorMod(SDVariable x,
                           SDVariable y)

floorModBp

public List<SDVariable> floorModBp(SDVariable x,
                                   SDVariable y,
                                   SDVariable grad)

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

clipByValue

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

clipByNorm

public SDVariable clipByNorm(SDVariable x,
                             double clipValue)

clipByNorm

public SDVariable clipByNorm(SDVariable x,
                             double clipValue,
                             int... dimensions)

relu

public SDVariable relu(SDVariable iX,
                       double cutoff)

reluDerivative

public SDVariable reluDerivative(SDVariable input,
                                 SDVariable grad)

thresholdRelu

public SDVariable thresholdRelu(SDVariable in,
                                SDVariable epsilon,
                                double cutoff)

thresholdReluBp

public SDVariable thresholdReluBp(SDVariable in,
                                  SDVariable epsilon,
                                  double cutoff)

relu6

public SDVariable relu6(SDVariable iX,
                        double cutoff)

relu6Derivative

public SDVariable relu6Derivative(SDVariable iX,
                                  SDVariable wrt,
                                  double cutoff)

softmax

public SDVariable softmax(SDVariable iX)

softmax

public SDVariable softmax(SDVariable iX,
                          int dimension)

hardTanh

public SDVariable hardTanh(SDVariable iX)

hardTanhBp

public SDVariable hardTanhBp(SDVariable in,
                             SDVariable epsilon)

hardTanhDerivative

@Deprecated
public SDVariable hardTanhDerivative(SDVariable iX)

Deprecated. Use hardTanhBp(SDVariable, SDVariable)

hardSigmoid

public SDVariable hardSigmoid(SDVariable in)

hardSigmoidBp

public SDVariable hardSigmoidBp(SDVariable in,
                                SDVariable epsilon)

sigmoid

public SDVariable sigmoid(SDVariable iX)

sigmoidDerivative

public SDVariable sigmoidDerivative(SDVariable iX,
                                    SDVariable wrt)

logSigmoid

public SDVariable logSigmoid(SDVariable iX)

powDerivative

public SDVariable powDerivative(SDVariable iX,
                                double pow)

swish

public SDVariable swish(SDVariable iX)

swishDerivative

public SDVariable swishDerivative(SDVariable iX)

gelu

public SDVariable gelu(SDVariable iX,
                       boolean precise)

geluDerivative

public SDVariable geluDerivative(SDVariable iX,
                                 boolean precise)

sign

public SDVariable sign(SDVariable iX)

expandDims

public SDVariable expandDims(SDVariable iX,
                             int axis)

squeeze

public SDVariable squeeze(SDVariable iX,
                          int... axis)

confusionMatrix

public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable pred,
                                  DataType dataType)

confusionMatrix

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

confusionMatrix

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

confusionMatrix

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

matrixDeterminant

public SDVariable matrixDeterminant(SDVariable in)

matrixInverse

public SDVariable matrixInverse(SDVariable in)

onehot

public SDVariable onehot(SDVariable indices,
                         int depth,
                         int axis,
                         double on,
                         double off,
                         DataType dataType)

onehot

public SDVariable onehot(SDVariable indices,
                         int depth)

reciprocal

public SDVariable reciprocal(SDVariable a)

repeat

public SDVariable repeat(SDVariable iX,
                         int axis)

stack

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

parallel_stack

public SDVariable parallel_stack(SDVariable[] values)

unstack

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

unstack

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

assign

public SDVariable assign(SDVariable x,
                         SDVariable y)

assign

public SDVariable assign(SDVariable x,
                         Number num)

softsign

public SDVariable softsign(SDVariable iX)

softsignBp

public SDVariable softsignBp(SDVariable in,
                             SDVariable epsilon)

softsignDerivative

@Deprecated
public SDVariable softsignDerivative(SDVariable iX)

Deprecated. Use softsignBp(SDVariable, SDVariable)

softplus

public SDVariable softplus(SDVariable iX)

elu
```
public SDVariable elu(SDVariable iX)
```

eluBp

public SDVariable eluBp(SDVariable in,
                        SDVariable epsilon,
                        double alpha)

leakyRelu

public SDVariable leakyRelu(SDVariable iX,
                            double alpha)

leakyReluBp

public SDVariable leakyReluBp(SDVariable in,
                              SDVariable epsilon,
                              double cutoff)

leakyReluDerivative

@Deprecated
public SDVariable leakyReluDerivative(SDVariable iX,
                                                   double cutoff)

Deprecated. Use leakyReluBp(SDVariable, SDVariable, double)

reshape

public SDVariable reshape(SDVariable iX,
                          int[] shape)

reshape

public SDVariable reshape(SDVariable iX,
                          long[] shape)

reshape

public SDVariable reshape(SDVariable iX,
                          SDVariable shape)

reverse

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

reverseSequence

public SDVariable reverseSequence(SDVariable x,
                                  SDVariable seq_lengths,
                                  int seq_dim,
                                  int batch_dim)

reverseSequence

public SDVariable reverseSequence(SDVariable x,
                                  SDVariable seq_lengths)

sequenceMask

public SDVariable sequenceMask(SDVariable lengths,
                               SDVariable maxLen,
                               DataType dataType)

sequenceMask

public SDVariable sequenceMask(SDVariable lengths,
                               int maxLen,
                               DataType dataType)

sequenceMask

public SDVariable sequenceMask(SDVariable lengths,
                               DataType dataType)

concat

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

fill

public SDVariable fill(SDVariable shape,
                       DataType dataType,
                       double value)

dot

public SDVariable dot(SDVariable x,
                      SDVariable y,
                      int... dimensions)

dotBp

public SDVariable[] dotBp(SDVariable in1,
                          SDVariable in2,
                          SDVariable grad,
                          boolean keepDims,
                          int... dimensions)

cosineSimilarity

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

cosineDistance

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

euclideanDistance

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

manhattanDistance

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

hammingDistance

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

jaccardDistance

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

weightedCrossEntropyWithLogits

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

lossL2

public SDVariable lossL2(SDVariable var)

lossAbsoluteDifference

public SDVariable lossAbsoluteDifference(SDVariable label,
                                         SDVariable predictions,
                                         SDVariable weights,
                                         LossReduce lossReduce)

lossAbsoluteDifferenceBP

public SDVariable[] lossAbsoluteDifferenceBP(SDVariable label,
                                             SDVariable predictions,
                                             SDVariable weights,
                                             LossReduce lossReduce)

lossCosineDistance

public SDVariable lossCosineDistance(SDVariable label,
                                     SDVariable predictions,
                                     SDVariable weights,
                                     LossReduce lossReduce,
                                     int dimension)

lossCosineDistanceBp

public SDVariable[] lossCosineDistanceBp(SDVariable label,
                                         SDVariable predictions,
                                         SDVariable weights,
                                         LossReduce lossReduce,
                                         int dimension)

lossHinge

public SDVariable lossHinge(SDVariable label,
                            SDVariable predictions,
                            SDVariable weights,
                            LossReduce lossReduce)

lossHingeBp

public SDVariable[] lossHingeBp(SDVariable label,
                                SDVariable predictions,
                                SDVariable weights,
                                LossReduce lossReduce)

lossHuber

public SDVariable lossHuber(SDVariable label,
                            SDVariable predictions,
                            SDVariable weights,
                            LossReduce lossReduce,
                            double delta)

lossHuberBp

public SDVariable[] lossHuberBp(SDVariable label,
                                SDVariable predictions,
                                SDVariable weights,
                                LossReduce lossReduce,
                                double delta)

lossLog

public SDVariable lossLog(SDVariable label,
                          SDVariable predictions,
                          SDVariable weights,
                          LossReduce lossReduce,
                          double epsilon)

lossLogBp

public SDVariable[] lossLogBp(SDVariable label,
                              SDVariable predictions,
                              SDVariable weights,
                              LossReduce lossReduce,
                              double epsilon)

lossLogPoisson

public SDVariable lossLogPoisson(SDVariable label,
                                 SDVariable predictions,
                                 SDVariable weights,
                                 LossReduce lossReduce)

lossLogPoissonBp

public SDVariable[] lossLogPoissonBp(SDVariable label,
                                     SDVariable predictions,
                                     SDVariable weights,
                                     LossReduce lossReduce)

lossLogPoissonFull

public SDVariable lossLogPoissonFull(SDVariable label,
                                     SDVariable predictions,
                                     SDVariable weights,
                                     LossReduce lossReduce)

lossLogPoissonFullBp

public SDVariable[] lossLogPoissonFullBp(SDVariable label,
                                         SDVariable predictions,
                                         SDVariable weights,
                                         LossReduce lossReduce)

lossMeanPairwiseSquaredError

public SDVariable lossMeanPairwiseSquaredError(SDVariable label,
                                               SDVariable predictions,
                                               SDVariable weights,
                                               LossReduce lossReduce)

lossMeanPairwiseSquaredErrorBp

public SDVariable[] lossMeanPairwiseSquaredErrorBp(SDVariable label,
                                                   SDVariable predictions,
                                                   SDVariable weights,
                                                   LossReduce lossReduce)

lossMeanSquaredError

public SDVariable lossMeanSquaredError(SDVariable label,
                                       SDVariable predictions,
                                       SDVariable weights,
                                       LossReduce lossReduce)

lossMeanSquaredErrorBp

public SDVariable[] lossMeanSquaredErrorBp(SDVariable label,
                                           SDVariable predictions,
                                           SDVariable weights,
                                           LossReduce lossReduce)

lossSigmoidCrossEntropy

public SDVariable lossSigmoidCrossEntropy(SDVariable labels,
                                          SDVariable logits,
                                          SDVariable weights,
                                          LossReduce lossReduce,
                                          double labelSmoothing)

lossSigmoidCrossEntropyBp

public SDVariable[] lossSigmoidCrossEntropyBp(SDVariable labels,
                                              SDVariable logits,
                                              SDVariable weights,
                                              LossReduce lossReduce,
                                              double labelSmoothing)

lossSoftmaxCrossEntropy

public SDVariable lossSoftmaxCrossEntropy(SDVariable labels,
                                          SDVariable logits,
                                          SDVariable weights,
                                          LossReduce lossReduce,
                                          double labelSmoothing)

lossSoftmaxCrossEntropyBp

public SDVariable[] lossSoftmaxCrossEntropyBp(SDVariable labels,
                                              SDVariable logits,
                                              SDVariable weights,
                                              LossReduce lossReduce,
                                              double labelSmoothing)

lossSoftmaxCrossEntropyWithLogits

public SDVariable lossSoftmaxCrossEntropyWithLogits(SDVariable labels,
                                                    SDVariable logits,
                                                    SDVariable weights,
                                                    int classDim)

lossSoftmaxCrossEntropyWithLogitsBp

public SDVariable[] lossSoftmaxCrossEntropyWithLogitsBp(SDVariable labels,
                                                        SDVariable logits,
                                                        SDVariable weights,
                                                        int classDim)

lossSparseSoftmaxCrossEntropy

public SDVariable lossSparseSoftmaxCrossEntropy(SDVariable logits,
                                                SDVariable labels)

lossSparseSoftmaxCrossEntropyBp

public SDVariable[] lossSparseSoftmaxCrossEntropyBp(SDVariable logits,
                                                    SDVariable labels)

xwPlusB

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

reluLayer

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

mmul

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

mmul

public SDVariable mmul(SDVariable x,
                       SDVariable y)

mmulBp

public List<SDVariable> mmulBp(SDVariable x,
                               SDVariable y,
                               SDVariable eps,
                               MMulTranspose mt)

batchMmul

public SDVariable[] batchMmul(SDVariable[] matricesA,
                              SDVariable[] matricesB)

batchMmul

public SDVariable[] batchMmul(SDVariable[] matricesA,
                              SDVariable[] matricesB,
                              boolean transposeA,
                              boolean transposeB)

batchMmul

public SDVariable[] batchMmul(SDVariable[] matrices,
                              boolean transposeA,
                              boolean transposeB)

tensorMmul

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

dotProductAttention

public SDVariable dotProductAttention(SDVariable queries,
                                      SDVariable keys,
                                      SDVariable values,
                                      SDVariable mask,
                                      boolean scaled)

dotProductAttention

public List<SDVariable> dotProductAttention(SDVariable queries,
                                            SDVariable keys,
                                            SDVariable values,
                                            SDVariable mask,
                                            boolean scaled,
                                            boolean withWeights)

dotProductAttentionBp

public List<SDVariable> dotProductAttentionBp(SDVariable queries,
                                              SDVariable keys,
                                              SDVariable values,
                                              SDVariable gradient,
                                              SDVariable mask,
                                              boolean scaled)

multiHeadDotProductAttention

public SDVariable multiHeadDotProductAttention(SDVariable queries,
                                               SDVariable keys,
                                               SDVariable values,
                                               SDVariable Wq,
                                               SDVariable Wk,
                                               SDVariable Wv,
                                               SDVariable Wo,
                                               SDVariable mask,
                                               boolean scaled)

multiHeadDotProductAttention

public List<SDVariable> multiHeadDotProductAttention(SDVariable queries,
                                                     SDVariable keys,
                                                     SDVariable values,
                                                     SDVariable Wq,
                                                     SDVariable Wk,
                                                     SDVariable Wv,
                                                     SDVariable Wo,
                                                     SDVariable mask,
                                                     boolean scaled,
                                                     boolean withWeights)

multiHeadDotProductAttentionBp

public List<SDVariable> multiHeadDotProductAttentionBp(SDVariable queries,
                                                       SDVariable keys,
                                                       SDVariable values,
                                                       SDVariable Wq,
                                                       SDVariable Wk,
                                                       SDVariable Wv,
                                                       SDVariable Wo,
                                                       SDVariable gradient,
                                                       SDVariable mask,
                                                       boolean scaled)

softmaxDerivative

public SDVariable softmaxDerivative(SDVariable functionInput,
                                    SDVariable wrt,
                                    Integer dimension)

logSoftmax

public SDVariable logSoftmax(SDVariable i_v)

logSoftmax

public SDVariable logSoftmax(SDVariable i_v,
                             int dimension)

logSoftmaxDerivative

public SDVariable logSoftmaxDerivative(SDVariable arg,
                                       SDVariable wrt)

logSoftmaxDerivative

public SDVariable logSoftmaxDerivative(SDVariable arg,
                                       SDVariable wrt,
                                       int dimension)

logSumExp

public SDVariable logSumExp(SDVariable arg,
                            boolean keepDims,
                            int... dimension)

selu

public SDVariable selu(SDVariable arg)

seluBp

public SDVariable seluBp(SDVariable in,
                         SDVariable epsilon)

seluDerivative

@Deprecated
public SDVariable seluDerivative(SDVariable arg)

Deprecated. Use seluBp(SDVariable, SDVariable)

rsub

public SDVariable rsub(SDVariable differentialFunction,
                       SDVariable i_v)

rsubBp

public List<SDVariable> rsubBp(SDVariable x,
                               SDVariable y,
                               SDVariable grad)

rdiv

public SDVariable rdiv(SDVariable differentialFunction,
                       SDVariable i_v)

rdivBp

public List<SDVariable> rdivBp(SDVariable x,
                               SDVariable y,
                               SDVariable grad)

rdivi

public SDVariable rdivi(SDVariable differentialFunction,
                        SDVariable i_v)

rsubi

public SDVariable rsubi(SDVariable differentialFunction,
                        SDVariable i_v)

add

public SDVariable add(SDVariable differentialFunction,
                      SDVariable i_v)

mergeAdd

public SDVariable mergeAdd(SDVariable... differentialFunctions)

mergeMax

public SDVariable mergeMax(SDVariable... differentialFunctions)

mergeAvg

public SDVariable mergeAvg(SDVariable... differentialFunctions)

diag

public SDVariable diag(SDVariable sdVariable)

diagPart

public SDVariable diagPart(SDVariable sdVariable)

setDiag

public SDVariable setDiag(SDVariable in,
                          SDVariable diag)

batchToSpace

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

spaceToBatch

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

depthToSpace

public SDVariable depthToSpace(SDVariable differentialFunction,
                               int blocksSize,
                               String dataFormat)

spaceToDepth

public SDVariable spaceToDepth(SDVariable differentialFunction,
                               int blocksSize,
                               String dataFormat)

dynamicPartition

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

dynamicPartitionBp

public SDVariable[] dynamicPartitionBp(SDVariable input,
                                       SDVariable partitions,
                                       SDVariable[] grads,
                                       int numPartitions)

dynamicStitch

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

segmentMax

public SDVariable segmentMax(SDVariable data,
                             SDVariable segmentIds)

segmentMaxBp

public SDVariable[] segmentMaxBp(SDVariable data,
                                 SDVariable segmentIds,
                                 SDVariable gradient)

segmentMin

public SDVariable segmentMin(SDVariable data,
                             SDVariable segmentIds)

segmentMinBp

public SDVariable[] segmentMinBp(SDVariable data,
                                 SDVariable segmentIds,
                                 SDVariable gradient)

segmentMean

public SDVariable segmentMean(SDVariable data,
                              SDVariable segmentIds)

segmentMeanBp

public SDVariable[] segmentMeanBp(SDVariable data,
                                  SDVariable segmentIds,
                                  SDVariable gradient)

segmentProd

public SDVariable segmentProd(SDVariable data,
                              SDVariable segmentIds)

segmentProdBp

public SDVariable[] segmentProdBp(SDVariable data,
                                  SDVariable segmentIds,
                                  SDVariable gradient)

segmentSum

public SDVariable segmentSum(SDVariable data,
                             SDVariable segmentIds)

segmentSumBp

public SDVariable[] segmentSumBp(SDVariable data,
                                 SDVariable segmentIds,
                                 SDVariable gradient)

unsortedSegmentMax

public SDVariable unsortedSegmentMax(SDVariable data,
                                     SDVariable segmentIds,
                                     int numSegments)

unsortedSegmentMaxBp

public SDVariable[] unsortedSegmentMaxBp(SDVariable data,
                                         SDVariable segmentIds,
                                         SDVariable gradient,
                                         int numSegments)

unsortedSegmentMin

public SDVariable unsortedSegmentMin(SDVariable data,
                                     SDVariable segmentIds,
                                     int numSegments)

unsortedSegmentMinBp

public SDVariable[] unsortedSegmentMinBp(SDVariable data,
                                         SDVariable segmentIds,
                                         SDVariable gradient,
                                         int numSegments)

unsortedSegmentMean

public SDVariable unsortedSegmentMean(SDVariable data,
                                      SDVariable segmentIds,
                                      int numSegments)

unsortedSegmentMeanBp

public SDVariable[] unsortedSegmentMeanBp(SDVariable data,
                                          SDVariable segmentIds,
                                          SDVariable gradient,
                                          int numSegments)

unsortedSegmentProd

public SDVariable unsortedSegmentProd(SDVariable data,
                                      SDVariable segmentIds,
                                      int numSegments)

unsortedSegmentProdBp

public SDVariable[] unsortedSegmentProdBp(SDVariable data,
                                          SDVariable segmentIds,
                                          SDVariable gradient,
                                          int numSegments)

unsortedSegmentSum

public SDVariable unsortedSegmentSum(SDVariable data,
                                     SDVariable segmentIds,
                                     int numSegments)

unsortedSegmentSumBp

public SDVariable[] unsortedSegmentSumBp(SDVariable data,
                                         SDVariable segmentIds,
                                         SDVariable gradient,
                                         int numSegments)

unsortedSegmentSqrtN

public SDVariable unsortedSegmentSqrtN(SDVariable data,
                                       SDVariable segmentIds,
                                       int numSegments)

unsortedSegmentSqrtNBp

public SDVariable[] unsortedSegmentSqrtNBp(SDVariable data,
                                           SDVariable segmentIds,
                                           SDVariable gradient,
                                           int numSegments)

dilation2D

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

shape

public SDVariable shape(SDVariable df)

size

public SDVariable size(SDVariable in)

sizeAt

public SDVariable sizeAt(SDVariable in,
                         int dimension)

rank

public SDVariable rank(SDVariable df)

gather

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

gather

public SDVariable gather(SDVariable df,
                         SDVariable indices,
                         int axis)

gatherNd

public SDVariable gatherNd(SDVariable df,
                           SDVariable indices)

trace

public SDVariable trace(SDVariable in)

cross

public SDVariable cross(SDVariable a,
                        SDVariable b)

erf

public SDVariable erf(SDVariable differentialFunction)

erfc

public SDVariable erfc(SDVariable differentialFunction)

addi

public SDVariable addi(SDVariable differentialFunction,
                       SDVariable i_v)

addBp

public List<SDVariable> addBp(SDVariable x,
                              SDVariable y,
                              SDVariable grad)

sub

public SDVariable sub(SDVariable differentialFunction,
                      SDVariable i_v)

squaredDifference

public SDVariable squaredDifference(SDVariable differentialFunction,
                                    SDVariable i_v)

subBp

public List<SDVariable> subBp(SDVariable x,
                              SDVariable y,
                              SDVariable grad)

subi

public SDVariable subi(SDVariable differentialFunction,
                       SDVariable i_v)

mul

public SDVariable mul(SDVariable differentialFunction,
                      SDVariable i_v)

mulBp

public List<SDVariable> mulBp(SDVariable x,
                              SDVariable y,
                              SDVariable grad)

modBp

public List<SDVariable> modBp(SDVariable x,
                              SDVariable y,
                              SDVariable grad)

muli

public SDVariable muli(SDVariable differentialFunction,
                       SDVariable i_v)

mod

public SDVariable mod(SDVariable differentialFunction,
                      SDVariable i_v)

div

public SDVariable div(SDVariable differentialFunction,
                      SDVariable i_v)

truncatedDiv

public SDVariable truncatedDiv(SDVariable differentialFunction,
                               SDVariable i_v)

divBp

public List<SDVariable> divBp(SDVariable x,
                              SDVariable y,
                              SDVariable grad)

divi

public SDVariable divi(SDVariable differentialFunction,
                       SDVariable i_v)

rsub

public SDVariable rsub(SDVariable differentialFunction,
                       double i_v)

rdiv

public SDVariable rdiv(SDVariable differentialFunction,
                       double i_v)

rdivi

public SDVariable rdivi(SDVariable differentialFunction,
                        double i_v)

rsubi

public SDVariable rsubi(SDVariable differentialFunction,
                        double i_v)

add

public SDVariable add(SDVariable differentialFunction,
                      double i_v)

addi

public SDVariable addi(SDVariable differentialFunction,
                       double i_v)

sub

public SDVariable sub(SDVariable differentialFunction,
                      double i_v)

subi

public SDVariable subi(SDVariable differentialFunction,
                       double i_v)

mul

public SDVariable mul(SDVariable differentialFunction,
                      double i_v)

muli

public SDVariable muli(SDVariable differentialFunction,
                       double i_v)

div

public SDVariable div(SDVariable differentialFunction,
                      double i_v)

divi

public SDVariable divi(SDVariable differentialFunction,
                       double i_v)

gt

public SDVariable gt(SDVariable functionInput,
                     SDVariable functionInput1)

lt

public SDVariable lt(SDVariable functionInput,
                     SDVariable functionInput1)

gti

public SDVariable gti(SDVariable functionInput,
                      SDVariable functionInput1)

lti

public SDVariable lti(SDVariable functionInput,
                      SDVariable functionInput1)

gte

public SDVariable gte(SDVariable functionInput,
                      SDVariable functionInput1)

lte

public SDVariable lte(SDVariable functionInput,
                      SDVariable functionInput1)

gtei

public SDVariable gtei(SDVariable functionInput,
                       SDVariable functionInput1)

ltOrEqi

public SDVariable ltOrEqi(SDVariable functionInput,
                          SDVariable functionInput1)

gt

public SDVariable gt(SDVariable functionInput,
                     double functionInput1)

lt

public SDVariable lt(SDVariable functionInput,
                     double functionInput1)

gti

public SDVariable gti(SDVariable functionInput,
                      double functionInput1)

lti

public SDVariable lti(SDVariable functionInput,
                      double functionInput1)

gte

public SDVariable gte(SDVariable functionInput,
                      double functionInput1)

lte

public SDVariable lte(SDVariable functionInput,
                      double functionInput1)

gtei

public SDVariable gtei(SDVariable functionInput,
                       double functionInput1)

ltei

public SDVariable ltei(SDVariable functionInput,
                       double functionInput1)

eq

public SDVariable eq(SDVariable iX,
                     double i_y)

eqi

public SDVariable eqi(SDVariable iX,
                      double i_y)

isNonDecreasing

public SDVariable isNonDecreasing(SDVariable iX)

isStrictlyIncreasing

public SDVariable isStrictlyIncreasing(SDVariable iX)

isNumericTensor

public SDVariable isNumericTensor(SDVariable iX)

slice

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

slice

public SDVariable slice(SDVariable input,
                        SDVariable begin,
                        SDVariable size)

sliceBp

public SDVariable sliceBp(SDVariable input,
                          SDVariable gradient,
                          int[] begin,
                          int[] size)

sliceBp

public SDVariable sliceBp(SDVariable input,
                          SDVariable gradient,
                          SDVariable begin,
                          SDVariable size)

stridedSlice

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

stridedSlice

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

stridedSlice

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

stridedSlice

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

stridedSliceBp

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

stridedSliceBp

public SDVariable stridedSliceBp(SDVariable in,
                                 SDVariable grad,
                                 SDVariable begin,
                                 SDVariable end,
                                 SDVariable strides,
                                 int beginMask,
                                 int endMask,
                                 int ellipsisMask,
                                 int newAxisMask,
                                 int shrinkAxisMask)

scatterAdd

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

scatterSub

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

scatterMul

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

scatterDiv

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

scatterMax

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

scatterMin

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

scatterUpdate

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

merge

public SDVariable merge(SDVariable... inputs)

switchOp

public SDVariable[] switchOp(SDVariable input,
                             SDVariable predicate)

validateDifferentialFunctionsameDiff

public void validateDifferentialFunctionsameDiff(SDVariable function)

validateDifferentialFunctionGraph

public void validateDifferentialFunctionGraph(SDVariable function)

doRepeat

public SDVariable doRepeat(SDVariable func,
                           SDVariable input)

Parameters:: func -; input -
Returns:

enter

public SDVariable enter(SDVariable x,
                        String frameName)

enter

public SDVariable enter(SDVariable x,
                        String frameName,
                        boolean isConstant)

exit
```
public SDVariable exit(SDVariable x)
```

nextIteration

public SDVariable nextIteration(SDVariable x)

toString
```
public String toString()
```
Overrides:

toString in class Object

Class DifferentialFunctionFactory

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

sameDiff

Constructor Detail

DifferentialFunctionFactory

Method Detail

sameDiff

invoke

val

externalErrors

externalErrors

zerosLike

zerosLike

onesLike

constant

linspace

range

range

listdiff

cast

meshgrid

randomUniform

randomUniform

randomNormal

randomNormal

randomBernoulli

randomBernoulli

randomBinomial

randomLogNormal

randomNormalTruncated

randomExponential

pad

localResponseNormalization

conv1d

conv1d

conv2d

upsampling2d

upsampling2dBp

avgPooling2d

maxPooling2d

avgPooling3d

maxPooling3d

sconv2d

depthWiseConv2d

deconv2d

deconv3d

deconv3dDerivative

conv3d

batchNorm

im2Col

im2ColBp

col2Im

extractImagePatches

moments

normalizeMoments

tile

tileBp

tile

tileBp

dropout

sum

sumBp

prod

prodBp

mean

meanBp

std

stdBp

variance

varianceBp

standardize

standardizeBp

layerNorm

layerNormBp

layerNorm

layerNormBp