DifferentialFunctionFactory (nd4j-api 1.0.0-beta 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`	`and(SDVariable ix, SDVariable iy)`
`SDVariable`	`argmax(SDVariable in, int... dimensions)`
`SDVariable`	`argmin(SDVariable in, int... dimensions)`
`SDVariable`	`asin(SDVariable iX)`
`SDVariable`	`asinh(SDVariable iX)`
`SDVariable`	`assign(SDVariable x, SDVariable y)`
`SDVariable`	`atan(SDVariable iX)`
`SDVariable`	`atan2(SDVariable y, SDVariable x)`
`SDVariable`	`atanh(SDVariable iX)`
`SDVariable`	`avgPooling2d(SDVariable[] inputs, Pooling2DConfig pooling2DConfig)` Average pooling 2d operation.
`SDVariable`	`avgPooling3d(SDVariable[] inputs, Pooling3DConfig pooling3DConfig)` Avg pooling 3d operation.
`SDVariable`	`batchNorm(SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon)` Batch norm operation.
`SDVariable`	`batchToSpace(SDVariable differentialFunction, int[] blocks, int[][] crops)`
`SDVariable`	`biasAdd(SDVariable input, SDVariable bias)`
`SDVariable`	`broadcast(SDVariable iX, int... shape)`
`SDVariable`	`ceil(SDVariable x)`
`SDVariable`	`clipByNorm(SDVariable x, double clipValue)`
`SDVariable`	`clipByValue(SDVariable x, double clipValueMin, double clipValueMax)`
`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`	`conv1d(SDVariable[] inputs, 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)`
`SDVariable`	`countZero(SDVariable input)`
`SDVariable`	`cross(SDVariable a, SDVariable b)`
`SDVariable`	`cube(SDVariable iX)`
`SDVariable`	`cubeDerivative(SDVariable iX)`
`SDVariable`	`cumprod(SDVariable in, boolean exclusive, boolean reverse, int... dimensions)`
`SDVariable`	`cumsum(SDVariable in, boolean exclusive, boolean reverse, int... dimensions)`
`SDVariable`	`deconv2d(SDVariable[] inputs, DeConv2DConfig deconv2DConfig)` Deconv2d operation.
`SDVariable`	`depthToSpace(SDVariable differentialFunction, int blocksSize, String dataFormat)`
`SDVariable`	`depthWiseConv2d(SDVariable[] inputs, Conv2DConfig depthConv2DConfig)` Depthwise 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`	`doGradChoose(SDVariable func, SDVariable input)`
`SDVariable`	`doRepeat(SDVariable func, SDVariable input)`
`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`	`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)`
`SDVariable`	`fill(SDVariable shape, double value)`
`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 axis, int[] broadcast)`
`SDVariable`	`gatherNd(SDVariable df, SDVariable indices)`
`int`	`getInputLength(SDVariable func)`
`int`	`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`	`hardTanh(SDVariable iX)`
`SDVariable`	`hardTanhDerivative(SDVariable iX)`
`SDVariable`	`invertPermutation(SDVariable input, boolean inPlace)`
`SDVariable`	`invoke(String name, Object[] args)`
`SDVariable`	`isFinite(SDVariable ix)`
`SDVariable`	`isInfinite(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`	`leakyRelu(SDVariable iX, double cutoff)`
`SDVariable`	`leakyReluDerivative(SDVariable iX, double cutoff)`
`SDVariable`	`localResponseNormalization(SDVariable inputs, LocalResponseNormalizationConfig lrnConfig)` Local response normalization operation.
`SDVariable`	`log(SDVariable iX)`
`SDVariable`	`log1p(SDVariable iX)`
`SDVariable`	`logSigmoid(SDVariable iX)`
`SDVariable`	`logSigmoidDerivative(SDVariable iX, SDVariable wrt)`
`SDVariable`	`logSoftmax(SDVariable i_v)`
`SDVariable`	`logSoftmaxDerivative(SDVariable arg, SDVariable wrt)`
`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`	`max(SDVariable i_x, int... dimensions)`
`SDVariable`	`max(SDVariable first, SDVariable second)`
`SDVariable`	`maxPooling2d(SDVariable[] inputs, Pooling2DConfig pooling2DConfig)` Max pooling 2d operation.
`SDVariable`	`maxPooling3d(SDVariable[] inputs, Pooling3DConfig pooling3DConfig)` Max pooling 3d operation.
`SDVariable`	`mean(SDVariable i_x, int... dimensions)`
`SDVariable`	`mergeadd(SDVariable[] differentialFunctions)`
`SDVariable`	`min(SDVariable i_x, int... dimensions)`
`SDVariable`	`min(SDVariable first, SDVariable second)`
`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`	`norm1(SDVariable i_x, int... dimensions)`
`SDVariable`	`norm2(SDVariable i_x, int... dimensions)`
`SDVariable[]`	`normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)`
`SDVariable`	`normmax(SDVariable i_x, int... dimensions)`
`SDVariable`	`one(int[] 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`	`pow(SDVariable iX, double i_y)`
`SDVariable`	`powDerivative(SDVariable iX, double pow)`
`SDVariable`	`prod(SDVariable i_x, int... dimensions)`
`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`	`reluLayer(SDVariable input, SDVariable weights, SDVariable bias)`
`SDVariable`	`repeat(SDVariable iX, int axis)`
`SDVariable`	`reshape(SDVariable iX, int[] 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`	`scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`sconv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig)` Separable Conv2d operation.
`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`	`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`	`slice(SDVariable input, 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)`
`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`	`squeeze(SDVariable iX, int... axis)`
`SDVariable`	`stack(SDVariable[] values, int axis)`
`SDVariable`	`std(SDVariable i_x, boolean biasCorrected, int... dimensions)`
`SDVariable`	`stridedSlice(SDVariable input, int[] begin, int[] end, int[] strides)`
`SDVariable`	`stridedSlice(SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)`
`SDVariable`	`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, 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`	`tensorMmul(SDVariable x, SDVariable y, int[][] dimensions)`
`SDVariable`	`tile(SDVariable iX, int[] repeat)`
`String`	`toString()`
`SDVariable`	`transpose(SDVariable iX)`
`SDVariable`	`truncatedDiv(SDVariable differentialFunction, SDVariable i_v)`
`SDVariable[]`	`unstack(SDVariable value, int axis)`
`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, 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`	`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)

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

zerosLike

public SDVariable zerosLike(SDVariable input)

zerosLike

public SDVariable zerosLike(String name,
                            SDVariable input)

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

onesLike

public SDVariable onesLike(String name,
                           SDVariable input)

localResponseNormalization

public SDVariable localResponseNormalization(SDVariable inputs,
                                             LocalResponseNormalizationConfig lrnConfig)

Local response normalization operation.

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

conv1d

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

Conv1d operation.

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

conv2d

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

Conv2d operation.

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

avgPooling2d

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

Average pooling 2d operation.

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

maxPooling2d

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

Max pooling 2d operation.

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

avgPooling3d

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

Avg pooling 3d operation.

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

maxPooling3d

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

Max pooling 3d operation.

Parameters:: inputs - 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)
```
Depthwise 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.

moments

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

normalizeMoments

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

tile

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

dropout

public SDVariable dropout(SDVariable input,
                          double p)

sum

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

prod

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

mean

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

std

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

variance

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

countNonZero

public SDVariable countNonZero(SDVariable input)

countZero

public SDVariable countZero(SDVariable input)

zeroFraction

public SDVariable zeroFraction(SDVariable input)

max

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

max

public SDVariable max(SDVariable first,
                      SDVariable second)

min

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

min

public SDVariable min(SDVariable first,
                      SDVariable second)

argmax

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

argmin

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

cumsum

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

cumprod

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

biasAdd

public SDVariable biasAdd(SDVariable input,
                          SDVariable bias)

norm1

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

norm2

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

normmax

public SDVariable normmax(SDVariable i_x,
                          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)

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)

tanhDerivative

public SDVariable tanhDerivative(SDVariable iX,
                                 SDVariable wrt)

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

log1p

public SDVariable log1p(SDVariable iX)

isFinite

public SDVariable isFinite(SDVariable ix)

isInfinite

public SDVariable isInfinite(SDVariable ix)

isNaN

public SDVariable isNaN(SDVariable ix)

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)

relu

public SDVariable relu(SDVariable iX,
                       double cutoff)

relu6

public SDVariable relu6(SDVariable iX,
                        double cutoff)

softmax

public SDVariable softmax(SDVariable iX)

hardTanh

public SDVariable hardTanh(SDVariable iX)

hardTanhDerivative

public SDVariable hardTanhDerivative(SDVariable iX)

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)

broadcast

public SDVariable broadcast(SDVariable iX,
                            int... 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)

assign

public SDVariable assign(SDVariable x,
                         SDVariable y)

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 cutoff)

leakyReluDerivative

public SDVariable leakyReluDerivative(SDVariable iX,
                                      double cutoff)

reshape

public SDVariable reshape(SDVariable iX,
                          int[] 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)

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)

tensorMmul

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

softmaxDerivative

public SDVariable softmaxDerivative(SDVariable functionInput,
                                    SDVariable wrt)

logSoftmax

public SDVariable logSoftmax(SDVariable i_v)

logSoftmaxDerivative

public SDVariable logSoftmaxDerivative(SDVariable arg,
                                       SDVariable wrt)

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)

diag

public SDVariable diag(SDVariable sdVariable)

diagPart

public SDVariable diagPart(SDVariable sdVariable)

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)

dilation2D

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

shape

public SDVariable shape(SDVariable df)

gather

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

gatherNd

public SDVariable gatherNd(SDVariable df,
                           SDVariable indices)

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)

stridedSlice

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

stridedSlice

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

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)

getInputLength

public int getInputLength(SDVariable func)

Parameters:: func -
Returns:

getReductionLength

public int getReductionLength(DifferentialFunction func)

validateDifferentialFunctionsameDiff

public void validateDifferentialFunctionsameDiff(SDVariable function)

validateDifferentialFunctionGraph

public void validateDifferentialFunctionGraph(SDVariable function)

doGradChoose

public SDVariable doGradChoose(SDVariable func,
                               SDVariable input)

Parameters:: func -; input -
Returns:

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

zero

zerosLike

zerosLike

one

onesLike

localResponseNormalization

conv1d

conv2d

avgPooling2d

maxPooling2d

avgPooling3d

maxPooling3d

sconv2d

depthWiseConv2d

deconv2d

conv3d

batchNorm

moments

normalizeMoments

tile

dropout

sum

prod

mean

std

variance

countNonZero

countZero

zeroFraction

max

max

min

min

argmax

argmin

cumsum

cumprod

biasAdd

norm1

norm2

normmax

reductionBroadcastableWithOrigShape

gradientBackwardsMarker

abs

neg

cos

sin

tan

permute

invertPermutation

transpose

acos

asin

atan

atan2

cosh

sinh

tanh

tanhDerivative

acosh

asinh

atanh

exp

expm1

rsqrt

log