DifferentialFunctionFactory (nd4j-api 1.0.0-beta2 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
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)` 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`	`broadcast(SDVariable iX, int... shape)`
`SDVariable`	`broadcast(SDVariable iX, long... shape)`
`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)`
`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`	`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`	`cubeDerivative(SDVariable iX)`
`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`	`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`	`dropout(SDVariable input, double p)`
`SDVariable[]`	`dynamicPartition(SDVariable differentialFunction, SDVariable partitions, int numPartitions)`
`SDVariable`	`dynamicStitch(SDVariable[] indices, SDVariable[] differentialFunctions)`
`SDVariable`	`elu(SDVariable iX)`
`SDVariable`	`eluDerivative(SDVariable iX)`
`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`	`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`	`fill(SDVariable shape, 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)`
`long`	`getInputLength(SDVariable func)`
`long`	`getReductionLength(DifferentialFunction func)`
`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`	`hardTanh(SDVariable iX)`
`SDVariable`	`hardTanhDerivative(SDVariable iX)`
`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`	`leakyRelu(SDVariable iX, double alpha)`
`SDVariable`	`leakyReluDerivative(SDVariable iX, double cutoff)`
`SDVariable`	`linspace(double lower, double upper, long count)`
`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`	`logSigmoidDerivative(SDVariable iX, SDVariable wrt)`
`SDVariable`	`logSoftmax(SDVariable i_v)`
`SDVariable`	`logSoftmaxDerivative(SDVariable arg, SDVariable wrt)`
`SDVariable`	`logSumExp(SDVariable arg, int... dimension)`
`SDVariable`	`lossBinaryXENT(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossCosineSimilarity(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossHinge(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossKLD(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossL1(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossL2(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMAE(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMAPE(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMCXENT(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMSE(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossMSLE(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossNegativeLogLikelihood(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossPoisson(SDVariable iX, SDVariable i_y, int... dimensions)`
`SDVariable`	`lossSquaredHinge(SDVariable iX, SDVariable i_y, int... dimensions)`
`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`	`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)`
`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`	`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`	`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`	`one(int[] shape)`
`SDVariable`	`one(long[] shape)`
`SDVariable`	`onehot(SDVariable indices, int depth)`
`SDVariable`	`onehot(SDVariable indices, int depth, int axis, double on, double off)`
`SDVariable`	`onesLike(String name, SDVariable input)`
`SDVariable`	`or(SDVariable iX, SDVariable i_y)`
`SDVariable`	`parallel_stack(SDVariable[] values)`
`SDVariable`	`permute(SDVariable iX, int... dimensions)`
`SDVariable`	`pooling3d(SDVariable input, Pooling3DConfig pooling3DConfig)`
`SDVariable`	`pow(SDVariable iX, double i_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)`
`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`	`relu(SDVariable iX, double cutoff)`
`SDVariable`	`relu6(SDVariable iX, double cutoff)`
`SDVariable`	`relu6Derivative(SDVariable iX, SDVariable wrt, double cutoff)`
`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`	`rollAxis(SDVariable iX, int axis)`
`SDVariable`	`round(SDVariable ix)`
`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`	`segmentMean(SDVariable data, SDVariable segmentIds)`
`SDVariable`	`segmentMin(SDVariable data, SDVariable segmentIds)`
`SDVariable`	`segmentProd(SDVariable data, SDVariable segmentIds)`
`SDVariable`	`segmentSum(SDVariable data, SDVariable segmentIds)`
`SDVariable`	`selu(SDVariable arg)`
`SDVariable`	`seluDerivative(SDVariable arg)`
`SDVariable`	`sequenceMask(SDVariable lengths)`
`SDVariable`	`sequenceMask(SDVariable lengths, int maxLen)`
`SDVariable`	`sequenceMask(SDVariable lengths, SDVariable maxLen)`
`SDVariable`	`setDiag(SDVariable in, SDVariable diag)`
`SDVariable`	`shannonEntropy(SDVariable in, int... dimensions)`
`SDVariable`	`shape(SDVariable df)`
`SDVariable`	`sigmoid(SDVariable iX)`
`SDVariable`	`sigmoidCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)`
`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`	`sliceBp(SDVariable input, SDVariable gradient, int[] begin, int[] size)`
`SDVariable`	`softmax(SDVariable iX)`
`SDVariable`	`softmaxCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)`
`SDVariable`	`softmaxDerivative(SDVariable functionInput, SDVariable wrt, Integer dimension)`
`SDVariable`	`softplus(SDVariable iX)`
`SDVariable`	`softsign(SDVariable iX)`
`SDVariable`	`softsignDerivative(SDVariable iX)`
`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`	`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`	`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`	`tan(SDVariable iX)`
`SDVariable`	`tanh(SDVariable iX)`
`SDVariable`	`tanhDerivative(SDVariable iX, SDVariable wrt)`
`SDVariable`	`tanhRational(SDVariable in)`
`SDVariable`	`tanhRationalDerivative(SDVariable in)`
`SDVariable`	`tanhRectified(SDVariable in)`
`SDVariable`	`tanhRectifiedDerivative(SDVariable in)`
`SDVariable`	`tensorMmul(SDVariable x, SDVariable y, int[][] dimensions)`
`SDVariable`	`tile(SDVariable iX, int[] repeat)`
`SDVariable`	`tileBp(SDVariable in, SDVariable grad, int[] repeat)`
`String`	`toString()`
`SDVariable`	`trace(SDVariable in)`
`SDVariable`	`transpose(SDVariable iX)`
`SDVariable`	`truncatedDiv(SDVariable differentialFunction, SDVariable i_v)`
`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`	`var(String iName, SDVariable iX)`
`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`	`zero(int[] shape)`
`SDVariable`	`zero(long[] shape)`
`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)
```

var

public SDVariable var(String iName,
                      SDVariable iX)

externalErrors

public ExternalErrorsFunction externalErrors(SDVariable... inputs)

externalErrors

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

zero
```
public SDVariable zero(int[] shape)
```

zero
```
public SDVariable zero(long[] shape)
```

zerosLike

public SDVariable zerosLike(SDVariable input)

zerosLike

public SDVariable zerosLike(String name,
                            SDVariable input)

one
```
public SDVariable one(int[] shape)
```

one
```
public SDVariable one(long[] shape)
```

onesLike

public SDVariable onesLike(String name,
                           SDVariable input)

constant

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

linspace

public SDVariable linspace(double lower,
                           double upper,
                           long count)

range

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

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

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:

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:

pooling3d

public SDVariable pooling3d(SDVariable input,
                            Pooling3DConfig pooling3DConfig)

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:

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)

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)

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)

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)

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)

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.

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)

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)

tanhRationalDerivative

public SDVariable tanhRationalDerivative(SDVariable in)

tanhRectifiedDerivative

public SDVariable tanhRectifiedDerivative(SDVariable in)

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)

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)

sqrt

public SDVariable sqrt(SDVariable iX)

square

public SDVariable square(SDVariable iX)

cube

public SDVariable cube(SDVariable iX)

cubeDerivative

public SDVariable cubeDerivative(SDVariable iX)

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)

relu6

public SDVariable relu6(SDVariable iX,
                        double cutoff)

relu6Derivative

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

softmax

public SDVariable softmax(SDVariable iX)

hardTanh

public SDVariable hardTanh(SDVariable iX)

hardTanhDerivative

public SDVariable hardTanhDerivative(SDVariable iX)

hardSigmoid

public SDVariable hardSigmoid(SDVariable in)

sigmoid

public SDVariable sigmoid(SDVariable iX)

sigmoidDerivative

public SDVariable sigmoidDerivative(SDVariable iX,
                                    SDVariable wrt)

logSigmoid

public SDVariable logSigmoid(SDVariable iX)

logSigmoidDerivative

public SDVariable logSigmoidDerivative(SDVariable iX,
                                       SDVariable wrt)

powDerivative

public SDVariable powDerivative(SDVariable iX,
                                double pow)

swish

public SDVariable swish(SDVariable iX)

swishDerivative

public SDVariable swishDerivative(SDVariable iX)

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)

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)

broadcast

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

broadcast

public SDVariable broadcast(SDVariable iX,
                            long... shape)

onehot

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

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)

softsignDerivative

public SDVariable softsignDerivative(SDVariable iX)

softplus

public SDVariable softplus(SDVariable iX)

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

eluDerivative

public SDVariable eluDerivative(SDVariable iX)

leakyRelu

public SDVariable leakyRelu(SDVariable iX,
                            double alpha)

leakyReluDerivative

public SDVariable leakyReluDerivative(SDVariable iX,
                                      double cutoff)

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)

sequenceMask

public SDVariable sequenceMask(SDVariable lengths,
                               int maxLen)

sequenceMask

public SDVariable sequenceMask(SDVariable lengths)

rollAxis

public SDVariable rollAxis(SDVariable iX,
                           int axis)

concat

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

fill

public SDVariable fill(SDVariable shape,
                       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)

sigmoidCrossEntropyWithLogits

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

softmaxCrossEntropyWithLogits

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

lossBinaryXENT

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

lossCosineSimilarity

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

lossHinge

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

lossKLD

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

lossL1

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

lossL2

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

lossMAE

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

lossMAPE

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

lossMSE

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

lossMCXENT

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

lossMSLE

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

lossNegativeLogLikelihood

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

lossPoisson

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

lossSquaredHinge

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

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)

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)

softmaxDerivative

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

logSoftmax

public SDVariable logSoftmax(SDVariable i_v)

logSoftmaxDerivative

public SDVariable logSoftmaxDerivative(SDVariable arg,
                                       SDVariable wrt)

logSumExp

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

selu

public SDVariable selu(SDVariable arg)

seluDerivative

public SDVariable seluDerivative(SDVariable arg)

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)

dynamicStitch

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

segmentMax

public SDVariable segmentMax(SDVariable data,
                             SDVariable segmentIds)

segmentMin

public SDVariable segmentMin(SDVariable data,
                             SDVariable segmentIds)

segmentMean

public SDVariable segmentMean(SDVariable data,
                              SDVariable segmentIds)

segmentProd

public SDVariable segmentProd(SDVariable data,
                              SDVariable segmentIds)

segmentSum

public SDVariable segmentSum(SDVariable data,
                             SDVariable segmentIds)

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)

muli

public SDVariable muli(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)

sliceBp

public SDVariable sliceBp(SDVariable input,
                          SDVariable gradient,
                          int[] begin,
                          int[] 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)

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)

getInputLength

public long getInputLength(SDVariable func)

Parameters:: func -
Returns:

getReductionLength

public long getReductionLength(DifferentialFunction func)

validateDifferentialFunctionsameDiff

public void validateDifferentialFunctionsameDiff(SDVariable function)

validateDifferentialFunctionGraph

public void validateDifferentialFunctionGraph(SDVariable function)

doRepeat

public SDVariable doRepeat(SDVariable func,
                           SDVariable input)

Parameters:: func -; input -
Returns:

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

var

externalErrors

externalErrors

zero

zero

zerosLike

zerosLike

one

one

onesLike

constant

linspace

range

meshgrid

randomUniform

randomUniform

randomNormal

randomNormal

randomBernoulli

randomBernoulli

randomBinomial

randomLogNormal

randomNormalTruncated

randomExponential

localResponseNormalization

conv1d

conv2d

upsampling2d

upsampling2dBp

avgPooling2d

maxPooling2d

avgPooling3d

maxPooling3d

pooling3d

sconv2d

depthWiseConv2d

deconv2d

conv3d

batchNorm

im2Col

im2ColBp

col2Im

moments

normalizeMoments

tile

tileBp

dropout

sum

sumBp

prod

prodBp

mean

meanBp

std

stdBp

variance

varianceBp

squaredNorm

squaredNormBp

entropy

logEntropy

shannonEntropy

countNonZero

countZero

zeroFraction

scalarMax

scalarMin