NnOps (libtensorflow 1.15.0 API)

java.lang.Object
- org.tensorflow.op.NnOps

```
public final class NnOps
extends Object
```
An API for building nn operations as Ops

See Also:

Ops}

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T extends Number> AvgPool<T>`	`avgPool(Operand<T> value, List<Long> ksize, List<Long> strides, String padding, AvgPool.Options... options)` Builds an `AvgPool` operation
`<T extends Number> AvgPool3d<T>`	`avgPool3d(Operand<T> input, List<Long> ksize, List<Long> strides, String padding, AvgPool3d.Options... options)` Builds an `AvgPool3d` operation
`<T extends Number> AvgPool3dGrad<T>`	`avgPool3dGrad(Operand<Integer> origInputShape, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, AvgPool3dGrad.Options... options)` Builds an `AvgPool3dGrad` operation
`<T> BatchNormWithGlobalNormalization<T>`	`batchNormWithGlobalNormalization(Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> beta, Operand<T> gamma, Float varianceEpsilon, Boolean scaleAfterNormalization)` Builds an `BatchNormWithGlobalNormalization` operation
`<T> BatchNormWithGlobalNormalizationGrad<T>`	`batchNormWithGlobalNormalizationGrad(Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> gamma, Operand<T> backprop, Float varianceEpsilon, Boolean scaleAfterNormalization)` Builds an `BatchNormWithGlobalNormalizationGrad` operation
`<T> BiasAdd<T>`	`biasAdd(Operand<T> value, Operand<T> bias, BiasAdd.Options... options)` Builds an `BiasAdd` operation
`<T> BiasAddGrad<T>`	`biasAddGrad(Operand<T> outBackprop, BiasAddGrad.Options... options)` Builds an `BiasAddGrad` operation
`ComputeAccidentalHits`	`computeAccidentalHits(Operand<Long> trueClasses, Operand<Long> sampledCandidates, Long numTrue, ComputeAccidentalHits.Options... options)` Builds an `ComputeAccidentalHits` operation
`<T extends Number> Conv2d<T>`	`conv2d(Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Conv2d.Options... options)` Builds an `Conv2d` operation
`<T extends Number> Conv2dBackpropFilter<T>`	`conv2dBackpropFilter(Operand<T> input, Operand<Integer> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Conv2dBackpropFilter.Options... options)` Builds an `Conv2dBackpropFilter` operation
`<T extends Number> Conv2dBackpropInput<T>`	`conv2dBackpropInput(Operand<Integer> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding, Conv2dBackpropInput.Options... options)` Builds an `Conv2dBackpropInput` operation
`<T extends Number> Conv3d<T>`	`conv3d(Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Conv3d.Options... options)` Builds an `Conv3d` operation
`<T extends Number> Conv3dBackpropFilter<T>`	`conv3dBackpropFilter(Operand<T> input, Operand<Integer> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Conv3dBackpropFilter.Options... options)` Builds an `Conv3dBackpropFilter` operation
`<U extends Number,T extends Number> Conv3dBackpropInput<U>`	`conv3dBackpropInput(Operand<T> inputSizes, Operand<U> filter, Operand<U> outBackprop, List<Long> strides, String padding, Conv3dBackpropInput.Options... options)` Builds an `Conv3dBackpropInput` operation
`<T extends Number> CtcBeamSearchDecoder<T>`	`ctcBeamSearchDecoder(Operand<T> inputs, Operand<Integer> sequenceLength, Long beamWidth, Long topPaths, CtcBeamSearchDecoder.Options... options)` Builds an `CtcBeamSearchDecoder` operation
`<T extends Number> CtcGreedyDecoder<T>`	`ctcGreedyDecoder(Operand<T> inputs, Operand<Integer> sequenceLength, CtcGreedyDecoder.Options... options)` Builds an `CtcGreedyDecoder` operation
`<T extends Number> CtcLoss<T>`	`ctcLoss(Operand<T> inputs, Operand<Long> labelsIndices, Operand<Integer> labelsValues, Operand<Integer> sequenceLength, CtcLoss.Options... options)` Builds an `CtcLoss` operation
`<T extends Number> CudnnRnnCanonicalToParams<T>`	`cudnnRnnCanonicalToParams(Operand<Integer> numLayers, Operand<Integer> numUnits, Operand<Integer> inputSize, Iterable<Operand<T>> weights, Iterable<Operand<T>> biases, CudnnRnnCanonicalToParams.Options... options)` Builds an `CudnnRnnCanonicalToParams` operation
`<U extends Number,T extends Number> CudnnRnnParamsSize<U>`	`cudnnRnnParamsSize(Operand<Integer> numLayers, Operand<Integer> numUnits, Operand<Integer> inputSize, Class<T> T, Class<U> S, CudnnRnnParamsSize.Options... options)` Builds an `CudnnRnnParamsSize` operation
`<T extends Number> CudnnRnnParamsToCanonical<T>`	`cudnnRnnParamsToCanonical(Operand<Integer> numLayers, Operand<Integer> numUnits, Operand<Integer> inputSize, Operand<T> params, Long numParams, CudnnRnnParamsToCanonical.Options... options)` Builds an `CudnnRnnParamsToCanonical` operation
`<T extends Number> DataFormatDimMap<T>`	`dataFormatDimMap(Operand<T> x, DataFormatDimMap.Options... options)` Builds an `DataFormatDimMap` operation
`<T extends Number> DataFormatVecPermute<T>`	`dataFormatVecPermute(Operand<T> x, DataFormatVecPermute.Options... options)` Builds an `DataFormatVecPermute` operation
`<T> DepthToSpace<T>`	`depthToSpace(Operand<T> input, Long blockSize, DepthToSpace.Options... options)` Builds an `DepthToSpace` operation
`<T extends Number> DepthwiseConv2dNative<T>`	`depthwiseConv2dNative(Operand<T> input, Operand<T> filter, List<Long> strides, String padding, DepthwiseConv2dNative.Options... options)` Builds an `DepthwiseConv2dNative` operation
`<T extends Number> DepthwiseConv2dNativeBackpropFilter<T>`	`depthwiseConv2dNativeBackpropFilter(Operand<T> input, Operand<Integer> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, DepthwiseConv2dNativeBackpropFilter.Options... options)` Builds an `DepthwiseConv2dNativeBackpropFilter` operation
`<T extends Number> DepthwiseConv2dNativeBackpropInput<T>`	`depthwiseConv2dNativeBackpropInput(Operand<Integer> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding, DepthwiseConv2dNativeBackpropInput.Options... options)` Builds an `DepthwiseConv2dNativeBackpropInput` operation
`<T extends Number> Dilation2d<T>`	`dilation2d(Operand<T> input, Operand<T> filter, List<Long> strides, List<Long> rates, String padding)` Builds an `Dilation2d` operation
`<T extends Number> Dilation2dBackpropFilter<T>`	`dilation2dBackpropFilter(Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates, String padding)` Builds an `Dilation2dBackpropFilter` operation
`<T extends Number> Dilation2dBackpropInput<T>`	`dilation2dBackpropInput(Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates, String padding)` Builds an `Dilation2dBackpropInput` operation
`<T extends Number> Elu<T>`	`elu(Operand<T> features)` Builds an `Elu` operation
`FixedUnigramCandidateSampler`	`fixedUnigramCandidateSampler(Operand<Long> trueClasses, Long numTrue, Long numSampled, Boolean unique, Long rangeMax, FixedUnigramCandidateSampler.Options... options)` Builds an `FixedUnigramCandidateSampler` operation
`<T extends Number> FractionalAvgPool<T>`	`fractionalAvgPool(Operand<T> value, List<Float> poolingRatio, FractionalAvgPool.Options... options)` Builds an `FractionalAvgPool` operation
`<T extends Number> FractionalMaxPool<T>`	`fractionalMaxPool(Operand<T> value, List<Float> poolingRatio, FractionalMaxPool.Options... options)` Builds an `FractionalMaxPool` operation
`<T extends Number,U extends Number> FusedBatchNorm<T,U>`	`fusedBatchNorm(Operand<T> x, Operand<U> scale, Operand<U> offset, Operand<U> mean, Operand<U> variance, FusedBatchNorm.Options... options)` Builds an `FusedBatchNorm` operation
`<T extends Number,U extends Number> FusedBatchNormGrad<T,U>`	`fusedBatchNormGrad(Operand<T> yBackprop, Operand<T> x, Operand<Float> scale, Operand<U> reserveSpace1, Operand<U> reserveSpace2, FusedBatchNormGrad.Options... options)` Builds an `FusedBatchNormGrad` operation
`<T extends Number> FusedPadConv2d<T>`	`fusedPadConv2d(Operand<T> input, Operand<Integer> paddings, Operand<T> filter, String mode, List<Long> strides, String padding)` Builds an `FusedPadConv2d` operation
`<T extends Number> FusedResizeAndPadConv2d<T>`	`fusedResizeAndPadConv2d(Operand<T> input, Operand<Integer> size, Operand<Integer> paddings, Operand<T> filter, String mode, List<Long> strides, String padding, FusedResizeAndPadConv2d.Options... options)` Builds an `FusedResizeAndPadConv2d` operation
`<T extends Number> InTopK`	`inTopK(Operand<Float> predictions, Operand<T> targets, Operand<T> k)` Builds an `InTopK` operation
`<T extends Number> L2Loss<T>`	`l2Loss(Operand<T> t)` Builds an `L2Loss` operation
`LearnedUnigramCandidateSampler`	`learnedUnigramCandidateSampler(Operand<Long> trueClasses, Long numTrue, Long numSampled, Boolean unique, Long rangeMax, LearnedUnigramCandidateSampler.Options... options)` Builds an `LearnedUnigramCandidateSampler` operation
`<T extends Number> LocalResponseNormalization<T>`	`localResponseNormalization(Operand<T> input, LocalResponseNormalization.Options... options)` Builds an `LocalResponseNormalization` operation
`<T extends Number> LogSoftmax<T>`	`logSoftmax(Operand<T> logits)` Builds an `LogSoftmax` operation
`<T> MaxPool<T>`	`maxPool(Operand<T> input, Operand<Integer> ksize, Operand<Integer> strides, String padding, MaxPool.Options... options)` Builds an `MaxPool` operation
`<T extends Number> MaxPool3d<T>`	`maxPool3d(Operand<T> input, List<Long> ksize, List<Long> strides, String padding, MaxPool3d.Options... options)` Builds an `MaxPool3d` operation
`<U extends Number,T extends Number> MaxPool3dGrad<U>`	`maxPool3dGrad(Operand<T> origInput, Operand<T> origOutput, Operand<U> grad, List<Long> ksize, List<Long> strides, String padding, MaxPool3dGrad.Options... options)` Builds an `MaxPool3dGrad` operation
`<T extends Number> MaxPool3dGradGrad<T>`	`maxPool3dGradGrad(Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, MaxPool3dGradGrad.Options... options)` Builds an `MaxPool3dGradGrad` operation
`<T extends Number> MaxPoolGrad<T>`	`maxPoolGrad(Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, Operand<Integer> ksize, Operand<Integer> strides, String padding, MaxPoolGrad.Options... options)` Builds an `MaxPoolGrad` operation
`<T extends Number> MaxPoolGradGrad<T>`	`maxPoolGradGrad(Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, Operand<Integer> ksize, Operand<Integer> strides, String padding, MaxPoolGradGrad.Options... options)` Builds an `MaxPoolGradGrad` operation
`<T extends Number,U extends Number> MaxPoolGradGradWithArgmax<T>`	`maxPoolGradGradWithArgmax(Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides, String padding, MaxPoolGradGradWithArgmax.Options... options)` Builds an `MaxPoolGradGradWithArgmax` operation
`<T extends Number,U extends Number> MaxPoolWithArgmax<T,U>`	`maxPoolWithArgmax(Operand<T> input, List<Long> ksize, List<Long> strides, Class<U> Targmax, String padding, MaxPoolWithArgmax.Options... options)` Builds an `MaxPoolWithArgmax` operation
`<T extends Number> MaxPoolWithArgmax<T,Long>`	`maxPoolWithArgmax(Operand<T> input, List<Long> ksize, List<Long> strides, String padding, MaxPoolWithArgmax.Options... options)` Builds an `MaxPoolWithArgmax` operation
`<T extends Number> NthElement<T>`	`nthElement(Operand<T> input, Operand<Integer> n, NthElement.Options... options)` Builds an `NthElement` operation
`<T> QuantizedAvgPool<T>`	`quantizedAvgPool(Operand<T> input, Operand<Float> minInput, Operand<Float> maxInput, List<Long> ksize, List<Long> strides, String padding)` Builds an `QuantizedAvgPool` operation
`<U,T> QuantizedBatchNormWithGlobalNormalization<U>`	`quantizedBatchNormWithGlobalNormalization(Operand<T> t, Operand<Float> tMin, Operand<Float> tMax, Operand<T> m, Operand<Float> mMin, Operand<Float> mMax, Operand<T> v, Operand<Float> vMin, Operand<Float> vMax, Operand<T> beta, Operand<Float> betaMin, Operand<Float> betaMax, Operand<T> gamma, Operand<Float> gammaMin, Operand<Float> gammaMax, Class<U> outType, Float varianceEpsilon, Boolean scaleAfterNormalization)` Builds an `QuantizedBatchNormWithGlobalNormalization` operation
`<V,T,U> QuantizedBiasAdd<V>`	`quantizedBiasAdd(Operand<T> input, Operand<U> bias, Operand<Float> minInput, Operand<Float> maxInput, Operand<Float> minBias, Operand<Float> maxBias, Class<V> outType)` Builds an `QuantizedBiasAdd` operation
`<V,T,U> QuantizedConv2d<V>`	`quantizedConv2d(Operand<T> input, Operand<U> filter, Operand<Float> minInput, Operand<Float> maxInput, Operand<Float> minFilter, Operand<Float> maxFilter, Class<V> outType, List<Long> strides, String padding, QuantizedConv2d.Options... options)` Builds an `QuantizedConv2d` operation
`<T> QuantizedInstanceNorm<T>`	`quantizedInstanceNorm(Operand<T> x, Operand<Float> xMin, Operand<Float> xMax, QuantizedInstanceNorm.Options... options)` Builds an `QuantizedInstanceNorm` operation
`<T> QuantizedMaxPool<T>`	`quantizedMaxPool(Operand<T> input, Operand<Float> minInput, Operand<Float> maxInput, List<Long> ksize, List<Long> strides, String padding)` Builds an `QuantizedMaxPool` operation
`<U,T> QuantizedRelu<U>`	`quantizedRelu(Operand<T> features, Operand<Float> minFeatures, Operand<Float> maxFeatures, Class<U> outType)` Builds an `QuantizedRelu` operation
`<U,T> QuantizedRelu6<U>`	`quantizedRelu6(Operand<T> features, Operand<Float> minFeatures, Operand<Float> maxFeatures, Class<U> outType)` Builds an `QuantizedRelu6` operation
`<U,T> QuantizedReluX<U>`	`quantizedReluX(Operand<T> features, Operand<Float> maxValue, Operand<Float> minFeatures, Operand<Float> maxFeatures, Class<U> outType)` Builds an `QuantizedReluX` operation
`<T> Relu<T>`	`relu(Operand<T> features)` Builds an `Relu` operation
`<T extends Number> Relu6<T>`	`relu6(Operand<T> features)` Builds an `Relu6` operation
`<T extends Number> Selu<T>`	`selu(Operand<T> features)` Builds an `Selu` operation
`<T extends Number> Softmax<T>`	`softmax(Operand<T> logits)` Builds an `Softmax` operation
`<T extends Number> SoftmaxCrossEntropyWithLogits<T>`	`softmaxCrossEntropyWithLogits(Operand<T> features, Operand<T> labels)` Builds an `SoftmaxCrossEntropyWithLogits` operation
`<T extends Number> Softsign<T>`	`softsign(Operand<T> features)` Builds an `Softsign` operation
`<T,U extends Number> SpaceToBatch<T>`	`spaceToBatch(Operand<T> input, Operand<U> paddings, Long blockSize)` Builds an `SpaceToBatch` operation
`<T> SpaceToDepth<T>`	`spaceToDepth(Operand<T> input, Long blockSize, SpaceToDepth.Options... options)` Builds an `SpaceToDepth` operation
`<T extends Number,U extends Number> SparseSoftmaxCrossEntropyWithLogits<T>`	`sparseSoftmaxCrossEntropyWithLogits(Operand<T> features, Operand<U> labels)` Builds an `SparseSoftmaxCrossEntropyWithLogits` operation
`<T extends Number> TopK<T>`	`topK(Operand<T> input, Operand<Integer> k, TopK.Options... options)` Builds an `TopK` operation

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

Method Detail

topK

public <T extends Number> TopK<T> topK(Operand<T> input,
                                       Operand<Integer> k,
                                       TopK.Options... options)

Builds an TopK operation

Parameters:: input - 1-D or higher with last dimension at least `k`.; k - 0-D. Number of top elements to look for along the last dimension (along each; options - carries optional attributes values
Returns:: a new instance of TopK
See Also:: TopK

depthwiseConv2dNative

public <T extends Number> DepthwiseConv2dNative<T> depthwiseConv2dNative(Operand<T> input,
                                                                         Operand<T> filter,
                                                                         List<Long> strides,
                                                                         String padding,
                                                                         DepthwiseConv2dNative.Options... options)

Builds an DepthwiseConv2dNative operation

Parameters:: input -; filter -; strides - 1-D of length 4. The stride of the sliding window for each dimension; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of DepthwiseConv2dNative
See Also:: DepthwiseConv2dNative

quantizedInstanceNorm

public <T> QuantizedInstanceNorm<T> quantizedInstanceNorm(Operand<T> x,
                                                          Operand<Float> xMin,
                                                          Operand<Float> xMax,
                                                          QuantizedInstanceNorm.Options... options)

Builds an QuantizedInstanceNorm operation

Parameters:: x - A 4D input Tensor.; xMin - The value represented by the lowest quantized input.; xMax - The value represented by the highest quantized input.; options - carries optional attributes values
Returns:: a new instance of QuantizedInstanceNorm
See Also:: QuantizedInstanceNorm

spaceToBatch

public <T,U extends Number> SpaceToBatch<T> spaceToBatch(Operand<T> input,
                                                         Operand<U> paddings,
                                                         Long blockSize)

Builds an SpaceToBatch operation

Parameters:: input - 4-D with shape `[batch, height, width, depth]`.; paddings - 2-D tensor of non-negative integers with shape `[2, 2]`. It specifies; blockSize -
Returns:: a new instance of SpaceToBatch
See Also:: SpaceToBatch

depthToSpace

public <T> DepthToSpace<T> depthToSpace(Operand<T> input,
                                        Long blockSize,
                                        DepthToSpace.Options... options)

Builds an DepthToSpace operation

Parameters:: input -; blockSize - The size of the spatial block, same as in Space2Depth.; options - carries optional attributes values
Returns:: a new instance of DepthToSpace
See Also:: DepthToSpace

softsign
```
public <T extends Number> Softsign<T> softsign(Operand<T> features)
```
Builds an Softsign operation

Parameters:

features -

Returns:

a new instance of Softsign

See Also:

Softsign

conv3d

public <T extends Number> Conv3d<T> conv3d(Operand<T> input,
                                           Operand<T> filter,
                                           List<Long> strides,
                                           String padding,
                                           Conv3d.Options... options)

Builds an Conv3d operation

Parameters:: input - Shape `[batch, in_depth, in_height, in_width, in_channels]`.; filter - Shape `[filter_depth, filter_height, filter_width, in_channels,; strides - 1-D tensor of length 5. The stride of the sliding window for each; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of Conv3d
See Also:: Conv3d

quantizedReluX

public <U,T> QuantizedReluX<U> quantizedReluX(Operand<T> features,
                                              Operand<Float> maxValue,
                                              Operand<Float> minFeatures,
                                              Operand<Float> maxFeatures,
                                              Class<U> outType)

Builds an QuantizedReluX operation

Parameters:: features -; maxValue -; minFeatures - The float value that the lowest quantized value represents.; maxFeatures - The float value that the highest quantized value represents.; outType -
Returns:: a new instance of QuantizedReluX
See Also:: QuantizedReluX

maxPoolWithArgmax

public <T extends Number> MaxPoolWithArgmax<T,Long> maxPoolWithArgmax(Operand<T> input,
                                                                      List<Long> ksize,
                                                                      List<Long> strides,
                                                                      String padding,
                                                                      MaxPoolWithArgmax.Options... options)

Builds an MaxPoolWithArgmax operation

Parameters:: input - 4-D with shape `[batch, height, width, channels]`. Input to pool over.; ksize - The size of the window for each dimension of the input tensor.; strides - The stride of the sliding window for each dimension of the; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of MaxPoolWithArgmax
See Also:: MaxPoolWithArgmax

conv2dBackpropInput

public <T extends Number> Conv2dBackpropInput<T> conv2dBackpropInput(Operand<Integer> inputSizes,
                                                                     Operand<T> filter,
                                                                     Operand<T> outBackprop,
                                                                     List<Long> strides,
                                                                     String padding,
                                                                     Conv2dBackpropInput.Options... options)

Builds an Conv2dBackpropInput operation

Parameters:: inputSizes - An integer vector representing the shape of `input`,; filter - 4-D with shape; outBackprop - 4-D with shape `[batch, out_height, out_width, out_channels]`.; strides - The stride of the sliding window for each dimension of the input; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of Conv2dBackpropInput
See Also:: Conv2dBackpropInput

computeAccidentalHits

public ComputeAccidentalHits computeAccidentalHits(Operand<Long> trueClasses,
                                                   Operand<Long> sampledCandidates,
                                                   Long numTrue,
                                                   ComputeAccidentalHits.Options... options)

Builds an ComputeAccidentalHits operation

Parameters:: trueClasses - The true_classes output of UnpackSparseLabels.; sampledCandidates - The sampled_candidates output of CandidateSampler.; numTrue - Number of true labels per context.; options - carries optional attributes values
Returns:: a new instance of ComputeAccidentalHits
See Also:: ComputeAccidentalHits

maxPool3dGrad

public <U extends Number,T extends Number> MaxPool3dGrad<U> maxPool3dGrad(Operand<T> origInput,
                                                                          Operand<T> origOutput,
                                                                          Operand<U> grad,
                                                                          List<Long> ksize,
                                                                          List<Long> strides,
                                                                          String padding,
                                                                          MaxPool3dGrad.Options... options)

Builds an MaxPool3dGrad operation

Parameters:: origInput - The original input tensor.; origOutput - The original output tensor.; grad - Output backprop of shape `[batch, depth, rows, cols, channels]`.; ksize - 1-D tensor of length 5. The size of the window for each dimension of; strides - 1-D tensor of length 5. The stride of the sliding window for each; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of MaxPool3dGrad
See Also:: MaxPool3dGrad

cudnnRnnCanonicalToParams

public <T extends Number> CudnnRnnCanonicalToParams<T> cudnnRnnCanonicalToParams(Operand<Integer> numLayers,
                                                                                 Operand<Integer> numUnits,
                                                                                 Operand<Integer> inputSize,
                                                                                 Iterable<Operand<T>> weights,
                                                                                 Iterable<Operand<T>> biases,
                                                                                 CudnnRnnCanonicalToParams.Options... options)

Builds an CudnnRnnCanonicalToParams operation

Parameters:: numLayers -; numUnits -; inputSize -; weights -; biases -; options - carries optional attributes values
Returns:: a new instance of CudnnRnnCanonicalToParams
See Also:: CudnnRnnCanonicalToParams

fixedUnigramCandidateSampler

public FixedUnigramCandidateSampler fixedUnigramCandidateSampler(Operand<Long> trueClasses,
                                                                 Long numTrue,
                                                                 Long numSampled,
                                                                 Boolean unique,
                                                                 Long rangeMax,
                                                                 FixedUnigramCandidateSampler.Options... options)

Builds an FixedUnigramCandidateSampler operation

Parameters:: trueClasses - A batch_size * num_true matrix, in which each row contains the; numTrue - Number of true labels per context.; numSampled - Number of candidates to randomly sample.; unique - If unique is true, we sample with rejection, so that all sampled; rangeMax - The sampler will sample integers from the interval [0, range_max).; options - carries optional attributes values
Returns:: a new instance of FixedUnigramCandidateSampler
See Also:: FixedUnigramCandidateSampler

avgPool3d

public <T extends Number> AvgPool3d<T> avgPool3d(Operand<T> input,
                                                 List<Long> ksize,
                                                 List<Long> strides,
                                                 String padding,
                                                 AvgPool3d.Options... options)

Builds an AvgPool3d operation

Parameters:: input - Shape `[batch, depth, rows, cols, channels]` tensor to pool over.; ksize - 1-D tensor of length 5. The size of the window for each dimension of; strides - 1-D tensor of length 5. The stride of the sliding window for each; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of AvgPool3d
See Also:: AvgPool3d

relu6
```
public <T extends Number> Relu6<T> relu6(Operand<T> features)
```
Builds an Relu6 operation

Parameters:

features -

Returns:

a new instance of Relu6

See Also:

Relu6

elu
```
public <T extends Number> Elu<T> elu(Operand<T> features)
```
Builds an Elu operation

Parameters:

features -

Returns:

a new instance of Elu

See Also:

Elu

ctcLoss

public <T extends Number> CtcLoss<T> ctcLoss(Operand<T> inputs,
                                             Operand<Long> labelsIndices,
                                             Operand<Integer> labelsValues,
                                             Operand<Integer> sequenceLength,
                                             CtcLoss.Options... options)

Builds an CtcLoss operation

Parameters:: inputs - 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.; labelsIndices - The indices of a `SparseTensor`.; labelsValues - The values (labels) associated with the given batch and time.; sequenceLength - A vector containing sequence lengths (batch).; options - carries optional attributes values
Returns:: a new instance of CtcLoss
See Also:: CtcLoss

conv3dBackpropFilter

public <T extends Number> Conv3dBackpropFilter<T> conv3dBackpropFilter(Operand<T> input,
                                                                       Operand<Integer> filterSizes,
                                                                       Operand<T> outBackprop,
                                                                       List<Long> strides,
                                                                       String padding,
                                                                       Conv3dBackpropFilter.Options... options)

Builds an Conv3dBackpropFilter operation

Parameters:: input - Shape `[batch, depth, rows, cols, in_channels]`.; filterSizes - An integer vector representing the tensor shape of `filter`,; outBackprop - Backprop signal of shape `[batch, out_depth, out_rows, out_cols,; strides - 1-D tensor of length 5. The stride of the sliding window for each; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of Conv3dBackpropFilter
See Also:: Conv3dBackpropFilter

cudnnRnnParamsToCanonical

public <T extends Number> CudnnRnnParamsToCanonical<T> cudnnRnnParamsToCanonical(Operand<Integer> numLayers,
                                                                                 Operand<Integer> numUnits,
                                                                                 Operand<Integer> inputSize,
                                                                                 Operand<T> params,
                                                                                 Long numParams,
                                                                                 CudnnRnnParamsToCanonical.Options... options)

Builds an CudnnRnnParamsToCanonical operation

Parameters:: numLayers -; numUnits -; inputSize -; params -; numParams -; options - carries optional attributes values
Returns:: a new instance of CudnnRnnParamsToCanonical
See Also:: CudnnRnnParamsToCanonical

fusedPadConv2d

public <T extends Number> FusedPadConv2d<T> fusedPadConv2d(Operand<T> input,
                                                           Operand<Integer> paddings,
                                                           Operand<T> filter,
                                                           String mode,
                                                           List<Long> strides,
                                                           String padding)

Builds an FusedPadConv2d operation

Parameters:: input - 4-D with shape `[batch, in_height, in_width, in_channels]`.; paddings - A two-column matrix specifying the padding sizes. The number of; filter - 4-D with shape; mode -; strides - 1-D of length 4. The stride of the sliding window for each dimension; padding - The type of padding algorithm to use.
Returns:: a new instance of FusedPadConv2d
See Also:: FusedPadConv2d

quantizedRelu6

public <U,T> QuantizedRelu6<U> quantizedRelu6(Operand<T> features,
                                              Operand<Float> minFeatures,
                                              Operand<Float> maxFeatures,
                                              Class<U> outType)

Builds an QuantizedRelu6 operation

Parameters:: features -; minFeatures - The float value that the lowest quantized value represents.; maxFeatures - The float value that the highest quantized value represents.; outType -
Returns:: a new instance of QuantizedRelu6
See Also:: QuantizedRelu6

conv2dBackpropFilter

public <T extends Number> Conv2dBackpropFilter<T> conv2dBackpropFilter(Operand<T> input,
                                                                       Operand<Integer> filterSizes,
                                                                       Operand<T> outBackprop,
                                                                       List<Long> strides,
                                                                       String padding,
                                                                       Conv2dBackpropFilter.Options... options)

Builds an Conv2dBackpropFilter operation

Parameters:: input - 4-D with shape `[batch, in_height, in_width, in_channels]`.; filterSizes - An integer vector representing the tensor shape of `filter`,; outBackprop - 4-D with shape `[batch, out_height, out_width, out_channels]`.; strides - The stride of the sliding window for each dimension of the input; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of Conv2dBackpropFilter
See Also:: Conv2dBackpropFilter

fusedResizeAndPadConv2d

public <T extends Number> FusedResizeAndPadConv2d<T> fusedResizeAndPadConv2d(Operand<T> input,
                                                                             Operand<Integer> size,
                                                                             Operand<Integer> paddings,
                                                                             Operand<T> filter,
                                                                             String mode,
                                                                             List<Long> strides,
                                                                             String padding,
                                                                             FusedResizeAndPadConv2d.Options... options)

Builds an FusedResizeAndPadConv2d operation

Parameters:: input - 4-D with shape `[batch, in_height, in_width, in_channels]`.; size - A 1-D int32 Tensor of 2 elements: `new_height, new_width`. The; paddings - A two-column matrix specifying the padding sizes. The number of; filter - 4-D with shape; mode -; strides - 1-D of length 4. The stride of the sliding window for each dimension; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of FusedResizeAndPadConv2d
See Also:: FusedResizeAndPadConv2d

ctcGreedyDecoder

public <T extends Number> CtcGreedyDecoder<T> ctcGreedyDecoder(Operand<T> inputs,
                                                               Operand<Integer> sequenceLength,
                                                               CtcGreedyDecoder.Options... options)

Builds an CtcGreedyDecoder operation

Parameters:: inputs - 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.; sequenceLength - A vector containing sequence lengths, size `(batch_size)`.; options - carries optional attributes values
Returns:: a new instance of CtcGreedyDecoder
See Also:: CtcGreedyDecoder

dataFormatDimMap

public <T extends Number> DataFormatDimMap<T> dataFormatDimMap(Operand<T> x,
                                                               DataFormatDimMap.Options... options)

Builds an DataFormatDimMap operation

Parameters:: x - A Tensor with each element as a dimension index in source data format.; options - carries optional attributes values
Returns:: a new instance of DataFormatDimMap
See Also:: DataFormatDimMap

sparseSoftmaxCrossEntropyWithLogits

public <T extends Number,U extends Number> SparseSoftmaxCrossEntropyWithLogits<T> sparseSoftmaxCrossEntropyWithLogits(Operand<T> features,
                                                                                                                      Operand<U> labels)

Builds an SparseSoftmaxCrossEntropyWithLogits operation

Parameters:: features - batch_size x num_classes matrix; labels - batch_size vector with values in [0, num_classes).
Returns:: a new instance of SparseSoftmaxCrossEntropyWithLogits
See Also:: SparseSoftmaxCrossEntropyWithLogits

fusedBatchNormGrad

public <T extends Number,U extends Number> FusedBatchNormGrad<T,U> fusedBatchNormGrad(Operand<T> yBackprop,
                                                                                      Operand<T> x,
                                                                                      Operand<Float> scale,
                                                                                      Operand<U> reserveSpace1,
                                                                                      Operand<U> reserveSpace2,
                                                                                      FusedBatchNormGrad.Options... options)

Builds an FusedBatchNormGrad operation

Parameters:: yBackprop - A 4D Tensor for the gradient with respect to y.; x - A 4D Tensor for input data.; scale - A 1D Tensor for scaling factor, to scale the normalized x.; reserveSpace1 - When is_training is True, a 1D Tensor for the computed batch; reserveSpace2 - When is_training is True, a 1D Tensor for the computed batch; options - carries optional attributes values
Returns:: a new instance of FusedBatchNormGrad
See Also:: FusedBatchNormGrad

maxPoolGradGrad

public <T extends Number> MaxPoolGradGrad<T> maxPoolGradGrad(Operand<T> origInput,
                                                             Operand<T> origOutput,
                                                             Operand<T> grad,
                                                             Operand<Integer> ksize,
                                                             Operand<Integer> strides,
                                                             String padding,
                                                             MaxPoolGradGrad.Options... options)

Builds an MaxPoolGradGrad operation

Parameters:: origInput - The original input tensor.; origOutput - The original output tensor.; grad - 4-D. Gradients of gradients w.r.t. the input of `max_pool`.; ksize - The size of the window for each dimension of the input tensor.; strides - The stride of the sliding window for each dimension of the; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of MaxPoolGradGrad
See Also:: MaxPoolGradGrad

learnedUnigramCandidateSampler

public LearnedUnigramCandidateSampler learnedUnigramCandidateSampler(Operand<Long> trueClasses,
                                                                     Long numTrue,
                                                                     Long numSampled,
                                                                     Boolean unique,
                                                                     Long rangeMax,
                                                                     LearnedUnigramCandidateSampler.Options... options)

Builds an LearnedUnigramCandidateSampler operation

Parameters:: trueClasses - A batch_size * num_true matrix, in which each row contains the; numTrue - Number of true labels per context.; numSampled - Number of candidates to randomly sample.; unique - If unique is true, we sample with rejection, so that all sampled; rangeMax - The sampler will sample integers from the interval [0, range_max).; options - carries optional attributes values
Returns:: a new instance of LearnedUnigramCandidateSampler
See Also:: LearnedUnigramCandidateSampler

relu
```
public <T> Relu<T> relu(Operand<T> features)
```
Builds an Relu operation

Parameters:

features -

Returns:

a new instance of Relu

See Also:

Relu

spaceToDepth

public <T> SpaceToDepth<T> spaceToDepth(Operand<T> input,
                                        Long blockSize,
                                        SpaceToDepth.Options... options)

Builds an SpaceToDepth operation

Parameters:: input -; blockSize - The size of the spatial block.; options - carries optional attributes values
Returns:: a new instance of SpaceToDepth
See Also:: SpaceToDepth

fusedBatchNorm

public <T extends Number,U extends Number> FusedBatchNorm<T,U> fusedBatchNorm(Operand<T> x,
                                                                              Operand<U> scale,
                                                                              Operand<U> offset,
                                                                              Operand<U> mean,
                                                                              Operand<U> variance,
                                                                              FusedBatchNorm.Options... options)

Builds an FusedBatchNorm operation

Parameters:: x - A 4D Tensor for input data.; scale - A 1D Tensor for scaling factor, to scale the normalized x.; offset - A 1D Tensor for offset, to shift to the normalized x.; mean - A 1D Tensor for population mean. Used for inference only;; variance - A 1D Tensor for population variance. Used for inference only;; options - carries optional attributes values
Returns:: a new instance of FusedBatchNorm
See Also:: FusedBatchNorm

maxPool

public <T> MaxPool<T> maxPool(Operand<T> input,
                              Operand<Integer> ksize,
                              Operand<Integer> strides,
                              String padding,
                              MaxPool.Options... options)

Builds an MaxPool operation

Parameters:: input - 4-D input to pool over.; ksize - The size of the window for each dimension of the input tensor.; strides - The stride of the sliding window for each dimension of the; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of MaxPool
See Also:: MaxPool

quantizedConv2d

public <V,T,U> QuantizedConv2d<V> quantizedConv2d(Operand<T> input,
                                                  Operand<U> filter,
                                                  Operand<Float> minInput,
                                                  Operand<Float> maxInput,
                                                  Operand<Float> minFilter,
                                                  Operand<Float> maxFilter,
                                                  Class<V> outType,
                                                  List<Long> strides,
                                                  String padding,
                                                  QuantizedConv2d.Options... options)

Builds an QuantizedConv2d operation

Parameters:: input -; filter - filter's input_depth dimension must match input's depth dimensions.; minInput - The float value that the lowest quantized input value represents.; maxInput - The float value that the highest quantized input value represents.; minFilter - The float value that the lowest quantized filter value represents.; maxFilter - The float value that the highest quantized filter value represents.; outType -; strides - The stride of the sliding window for each dimension of the input; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of QuantizedConv2d
See Also:: QuantizedConv2d

localResponseNormalization

public <T extends Number> LocalResponseNormalization<T> localResponseNormalization(Operand<T> input,
                                                                                   LocalResponseNormalization.Options... options)

Builds an LocalResponseNormalization operation

Parameters:: input - 4-D.; options - carries optional attributes values
Returns:: a new instance of LocalResponseNormalization
See Also:: LocalResponseNormalization

quantizedRelu

public <U,T> QuantizedRelu<U> quantizedRelu(Operand<T> features,
                                            Operand<Float> minFeatures,
                                            Operand<Float> maxFeatures,
                                            Class<U> outType)

Builds an QuantizedRelu operation

Parameters:: features -; minFeatures - The float value that the lowest quantized value represents.; maxFeatures - The float value that the highest quantized value represents.; outType -
Returns:: a new instance of QuantizedRelu
See Also:: QuantizedRelu

dilation2d

public <T extends Number> Dilation2d<T> dilation2d(Operand<T> input,
                                                   Operand<T> filter,
                                                   List<Long> strides,
                                                   List<Long> rates,
                                                   String padding)

Builds an Dilation2d operation

Parameters:: input - 4-D with shape `[batch, in_height, in_width, depth]`.; filter - 3-D with shape `[filter_height, filter_width, depth]`.; strides - The stride of the sliding window for each dimension of the input; rates - The input stride for atrous morphological dilation. Must be:; padding - The type of padding algorithm to use.
Returns:: a new instance of Dilation2d
See Also:: Dilation2d

maxPoolGrad

public <T extends Number> MaxPoolGrad<T> maxPoolGrad(Operand<T> origInput,
                                                     Operand<T> origOutput,
                                                     Operand<T> grad,
                                                     Operand<Integer> ksize,
                                                     Operand<Integer> strides,
                                                     String padding,
                                                     MaxPoolGrad.Options... options)

Builds an MaxPoolGrad operation

Parameters:: origInput - The original input tensor.; origOutput - The original output tensor.; grad - 4-D. Gradients w.r.t. the output of `max_pool`.; ksize - The size of the window for each dimension of the input tensor.; strides - The stride of the sliding window for each dimension of the; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of MaxPoolGrad
See Also:: MaxPoolGrad

conv3dBackpropInput

public <U extends Number,T extends Number> Conv3dBackpropInput<U> conv3dBackpropInput(Operand<T> inputSizes,
                                                                                      Operand<U> filter,
                                                                                      Operand<U> outBackprop,
                                                                                      List<Long> strides,
                                                                                      String padding,
                                                                                      Conv3dBackpropInput.Options... options)

Builds an Conv3dBackpropInput operation

Parameters:: inputSizes - An integer vector representing the tensor shape of `input`,; filter - Shape `[depth, rows, cols, in_channels, out_channels]`.; outBackprop - Backprop signal of shape `[batch, out_depth, out_rows, out_cols,; strides - 1-D tensor of length 5. The stride of the sliding window for each; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of Conv3dBackpropInput
See Also:: Conv3dBackpropInput

nthElement

public <T extends Number> NthElement<T> nthElement(Operand<T> input,
                                                   Operand<Integer> n,
                                                   NthElement.Options... options)

Builds an NthElement operation

Parameters:: input - 1-D or higher with last dimension at least `n+1`.; n - 0-D. Position of sorted vector to select along the last dimension (along; options - carries optional attributes values
Returns:: a new instance of NthElement
See Also:: NthElement

dataFormatVecPermute

public <T extends Number> DataFormatVecPermute<T> dataFormatVecPermute(Operand<T> x,
                                                                       DataFormatVecPermute.Options... options)

Builds an DataFormatVecPermute operation

Parameters:: x - Vector of size 4 or Tensor of shape (4, 2) in source data format.; options - carries optional attributes values
Returns:: a new instance of DataFormatVecPermute
See Also:: DataFormatVecPermute

quantizedMaxPool

public <T> QuantizedMaxPool<T> quantizedMaxPool(Operand<T> input,
                                                Operand<Float> minInput,
                                                Operand<Float> maxInput,
                                                List<Long> ksize,
                                                List<Long> strides,
                                                String padding)

Builds an QuantizedMaxPool operation

Parameters:: input - The 4D (batch x rows x cols x depth) Tensor to MaxReduce over.; minInput - The float value that the lowest quantized input value represents.; maxInput - The float value that the highest quantized input value represents.; ksize - The size of the window for each dimension of the input tensor.; strides - The stride of the sliding window for each dimension of the input; padding - The type of padding algorithm to use.
Returns:: a new instance of QuantizedMaxPool
See Also:: QuantizedMaxPool

softmax
```
public <T extends Number> Softmax<T> softmax(Operand<T> logits)
```
Builds an Softmax operation

Parameters:

logits - 2-D with shape `[batch_size, num_classes]`.

Returns:

a new instance of Softmax

See Also:

Softmax

biasAddGrad
```
public <T> BiasAddGrad<T> biasAddGrad(Operand<T> outBackprop,
                                      BiasAddGrad.Options... options)
```
Builds an BiasAddGrad operation

Parameters:

outBackprop - Any number of dimensions.

options - carries optional attributes values

Returns:

a new instance of BiasAddGrad

See Also:

BiasAddGrad

batchNormWithGlobalNormalizationGrad

public <T> BatchNormWithGlobalNormalizationGrad<T> batchNormWithGlobalNormalizationGrad(Operand<T> t,
                                                                                        Operand<T> m,
                                                                                        Operand<T> v,
                                                                                        Operand<T> gamma,
                                                                                        Operand<T> backprop,
                                                                                        Float varianceEpsilon,
                                                                                        Boolean scaleAfterNormalization)

Builds an BatchNormWithGlobalNormalizationGrad operation

Parameters:: t - A 4D input Tensor.; m - A 1D mean Tensor with size matching the last dimension of t.; v - A 1D variance Tensor with size matching the last dimension of t.; gamma - A 1D gamma Tensor with size matching the last dimension of t.; backprop - 4D backprop Tensor.; varianceEpsilon - A small float number to avoid dividing by 0.; scaleAfterNormalization - A bool indicating whether the resulted tensor
Returns:: a new instance of BatchNormWithGlobalNormalizationGrad
See Also:: BatchNormWithGlobalNormalizationGrad

dilation2dBackpropFilter

public <T extends Number> Dilation2dBackpropFilter<T> dilation2dBackpropFilter(Operand<T> input,
                                                                               Operand<T> filter,
                                                                               Operand<T> outBackprop,
                                                                               List<Long> strides,
                                                                               List<Long> rates,
                                                                               String padding)

Builds an Dilation2dBackpropFilter operation

Parameters:: input - 4-D with shape `[batch, in_height, in_width, depth]`.; filter - 3-D with shape `[filter_height, filter_width, depth]`.; outBackprop - 4-D with shape `[batch, out_height, out_width, depth]`.; strides - 1-D of length 4. The stride of the sliding window for each dimension of; rates - 1-D of length 4. The input stride for atrous morphological dilation.; padding - The type of padding algorithm to use.
Returns:: a new instance of Dilation2dBackpropFilter
See Also:: Dilation2dBackpropFilter

maxPoolWithArgmax

public <T extends Number,U extends Number> MaxPoolWithArgmax<T,U> maxPoolWithArgmax(Operand<T> input,
                                                                                    List<Long> ksize,
                                                                                    List<Long> strides,
                                                                                    Class<U> Targmax,
                                                                                    String padding,
                                                                                    MaxPoolWithArgmax.Options... options)

Builds an MaxPoolWithArgmax operation

Parameters:: input - 4-D with shape `[batch, height, width, channels]`. Input to pool over.; ksize - The size of the window for each dimension of the input tensor.; strides - The stride of the sliding window for each dimension of the; Targmax -; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of MaxPoolWithArgmax
See Also:: MaxPoolWithArgmax

avgPool3dGrad

public <T extends Number> AvgPool3dGrad<T> avgPool3dGrad(Operand<Integer> origInputShape,
                                                         Operand<T> grad,
                                                         List<Long> ksize,
                                                         List<Long> strides,
                                                         String padding,
                                                         AvgPool3dGrad.Options... options)

Builds an AvgPool3dGrad operation

Parameters:: origInputShape - The original input dimensions.; grad - Output backprop of shape `[batch, depth, rows, cols, channels]`.; ksize - 1-D tensor of length 5. The size of the window for each dimension of; strides - 1-D tensor of length 5. The stride of the sliding window for each; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of AvgPool3dGrad
See Also:: AvgPool3dGrad

inTopK

public <T extends Number> InTopK inTopK(Operand<Float> predictions,
                                        Operand<T> targets,
                                        Operand<T> k)

Builds an InTopK operation

Parameters:: predictions - A `batch_size` x `classes` tensor.; targets - A `batch_size` vector of class ids.; k - Number of top elements to look at for computing precision.
Returns:: a new instance of InTopK
See Also:: InTopK

cudnnRnnParamsSize

public <U extends Number,T extends Number> CudnnRnnParamsSize<U> cudnnRnnParamsSize(Operand<Integer> numLayers,
                                                                                    Operand<Integer> numUnits,
                                                                                    Operand<Integer> inputSize,
                                                                                    Class<T> T,
                                                                                    Class<U> S,
                                                                                    CudnnRnnParamsSize.Options... options)

Builds an CudnnRnnParamsSize operation

Parameters:: numLayers -; numUnits -; inputSize -; T -; S -; options - carries optional attributes values
Returns:: a new instance of CudnnRnnParamsSize
See Also:: CudnnRnnParamsSize

dilation2dBackpropInput

public <T extends Number> Dilation2dBackpropInput<T> dilation2dBackpropInput(Operand<T> input,
                                                                             Operand<T> filter,
                                                                             Operand<T> outBackprop,
                                                                             List<Long> strides,
                                                                             List<Long> rates,
                                                                             String padding)

Builds an Dilation2dBackpropInput operation

Parameters:: input - 4-D with shape `[batch, in_height, in_width, depth]`.; filter - 3-D with shape `[filter_height, filter_width, depth]`.; outBackprop - 4-D with shape `[batch, out_height, out_width, depth]`.; strides - 1-D of length 4. The stride of the sliding window for each dimension of; rates - 1-D of length 4. The input stride for atrous morphological dilation.; padding - The type of padding algorithm to use.
Returns:: a new instance of Dilation2dBackpropInput
See Also:: Dilation2dBackpropInput

quantizedAvgPool

public <T> QuantizedAvgPool<T> quantizedAvgPool(Operand<T> input,
                                                Operand<Float> minInput,
                                                Operand<Float> maxInput,
                                                List<Long> ksize,
                                                List<Long> strides,
                                                String padding)

Builds an QuantizedAvgPool operation

Parameters:: input - 4-D with shape `[batch, height, width, channels]`.; minInput - The float value that the lowest quantized input value represents.; maxInput - The float value that the highest quantized input value represents.; ksize - The size of the window for each dimension of the input tensor.; strides - The stride of the sliding window for each dimension of the input; padding - The type of padding algorithm to use.
Returns:: a new instance of QuantizedAvgPool
See Also:: QuantizedAvgPool

batchNormWithGlobalNormalization

public <T> BatchNormWithGlobalNormalization<T> batchNormWithGlobalNormalization(Operand<T> t,
                                                                                Operand<T> m,
                                                                                Operand<T> v,
                                                                                Operand<T> beta,
                                                                                Operand<T> gamma,
                                                                                Float varianceEpsilon,
                                                                                Boolean scaleAfterNormalization)

Builds an BatchNormWithGlobalNormalization operation

Parameters:: t - A 4D input Tensor.; m - A 1D mean Tensor with size matching the last dimension of t.; v - A 1D variance Tensor with size matching the last dimension of t.; beta - A 1D beta Tensor with size matching the last dimension of t.; gamma - A 1D gamma Tensor with size matching the last dimension of t.; varianceEpsilon - A small float number to avoid dividing by 0.; scaleAfterNormalization - A bool indicating whether the resulted tensor
Returns:: a new instance of BatchNormWithGlobalNormalization
See Also:: BatchNormWithGlobalNormalization

selu
```
public <T extends Number> Selu<T> selu(Operand<T> features)
```
Builds an Selu operation

Parameters:

features -

Returns:

a new instance of Selu

See Also:

Selu

logSoftmax
```
public <T extends Number> LogSoftmax<T> logSoftmax(Operand<T> logits)
```
Builds an LogSoftmax operation

Parameters:

logits - 2-D with shape `[batch_size, num_classes]`.

Returns:

a new instance of LogSoftmax

See Also:

LogSoftmax

ctcBeamSearchDecoder

public <T extends Number> CtcBeamSearchDecoder<T> ctcBeamSearchDecoder(Operand<T> inputs,
                                                                       Operand<Integer> sequenceLength,
                                                                       Long beamWidth,
                                                                       Long topPaths,
                                                                       CtcBeamSearchDecoder.Options... options)

Builds an CtcBeamSearchDecoder operation

Parameters:: inputs - 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.; sequenceLength - A vector containing sequence lengths, size `(batch)`.; beamWidth - A scalar >= 0 (beam search beam width).; topPaths - A scalar >= 0, <= beam_width (controls output size).; options - carries optional attributes values
Returns:: a new instance of CtcBeamSearchDecoder
See Also:: CtcBeamSearchDecoder

fractionalAvgPool

public <T extends Number> FractionalAvgPool<T> fractionalAvgPool(Operand<T> value,
                                                                 List<Float> poolingRatio,
                                                                 FractionalAvgPool.Options... options)

Builds an FractionalAvgPool operation

Parameters:: value - 4-D with shape `[batch, height, width, channels]`.; poolingRatio - Pooling ratio for each dimension of `value`, currently only; options - carries optional attributes values
Returns:: a new instance of FractionalAvgPool
See Also:: FractionalAvgPool

conv2d

public <T extends Number> Conv2d<T> conv2d(Operand<T> input,
                                           Operand<T> filter,
                                           List<Long> strides,
                                           String padding,
                                           Conv2d.Options... options)

Builds an Conv2d operation

Parameters:: input - A 4-D tensor. The dimension order is interpreted according to the value; filter - A 4-D tensor of shape; strides - 1-D tensor of length 4. The stride of the sliding window for each; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of Conv2d
See Also:: Conv2d

l2Loss
```
public <T extends Number> L2Loss<T> l2Loss(Operand<T> t)
```
Builds an L2Loss operation

Parameters:

t - Typically 2-D, but may have any dimensions.

Returns:

a new instance of L2Loss

See Also:

L2Loss

maxPool3d

public <T extends Number> MaxPool3d<T> maxPool3d(Operand<T> input,
                                                 List<Long> ksize,
                                                 List<Long> strides,
                                                 String padding,
                                                 MaxPool3d.Options... options)

Builds an MaxPool3d operation

Parameters:: input - Shape `[batch, depth, rows, cols, channels]` tensor to pool over.; ksize - 1-D tensor of length 5. The size of the window for each dimension of; strides - 1-D tensor of length 5. The stride of the sliding window for each; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of MaxPool3d
See Also:: MaxPool3d

quantizedBiasAdd

public <V,T,U> QuantizedBiasAdd<V> quantizedBiasAdd(Operand<T> input,
                                                    Operand<U> bias,
                                                    Operand<Float> minInput,
                                                    Operand<Float> maxInput,
                                                    Operand<Float> minBias,
                                                    Operand<Float> maxBias,
                                                    Class<V> outType)

Builds an QuantizedBiasAdd operation

Parameters:: input -; bias - A 1D bias Tensor with size matching the last dimension of 'input'.; minInput - The float value that the lowest quantized input value represents.; maxInput - The float value that the highest quantized input value represents.; minBias - The float value that the lowest quantized bias value represents.; maxBias - The float value that the highest quantized bias value represents.; outType -
Returns:: a new instance of QuantizedBiasAdd
See Also:: QuantizedBiasAdd

depthwiseConv2dNativeBackpropInput

public <T extends Number> DepthwiseConv2dNativeBackpropInput<T> depthwiseConv2dNativeBackpropInput(Operand<Integer> inputSizes,
                                                                                                   Operand<T> filter,
                                                                                                   Operand<T> outBackprop,
                                                                                                   List<Long> strides,
                                                                                                   String padding,
                                                                                                   DepthwiseConv2dNativeBackpropInput.Options... options)

Builds an DepthwiseConv2dNativeBackpropInput operation

Parameters:: inputSizes - An integer vector representing the shape of `input`, based; filter - 4-D with shape; outBackprop - 4-D with shape based on `data_format`.; strides - The stride of the sliding window for each dimension of the input; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of DepthwiseConv2dNativeBackpropInput
See Also:: DepthwiseConv2dNativeBackpropInput

softmaxCrossEntropyWithLogits

public <T extends Number> SoftmaxCrossEntropyWithLogits<T> softmaxCrossEntropyWithLogits(Operand<T> features,
                                                                                         Operand<T> labels)

Builds an SoftmaxCrossEntropyWithLogits operation

Parameters:: features - batch_size x num_classes matrix; labels - batch_size x num_classes matrix
Returns:: a new instance of SoftmaxCrossEntropyWithLogits
See Also:: SoftmaxCrossEntropyWithLogits

maxPool3dGradGrad

public <T extends Number> MaxPool3dGradGrad<T> maxPool3dGradGrad(Operand<T> origInput,
                                                                 Operand<T> origOutput,
                                                                 Operand<T> grad,
                                                                 List<Long> ksize,
                                                                 List<Long> strides,
                                                                 String padding,
                                                                 MaxPool3dGradGrad.Options... options)

Builds an MaxPool3dGradGrad operation

Parameters:: origInput - The original input tensor.; origOutput - The original output tensor.; grad - Output backprop of shape `[batch, depth, rows, cols, channels]`.; ksize - 1-D tensor of length 5. The size of the window for each dimension of; strides - 1-D tensor of length 5. The stride of the sliding window for each; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of MaxPool3dGradGrad
See Also:: MaxPool3dGradGrad

quantizedBatchNormWithGlobalNormalization

public <U,T> QuantizedBatchNormWithGlobalNormalization<U> quantizedBatchNormWithGlobalNormalization(Operand<T> t,
                                                                                                    Operand<Float> tMin,
                                                                                                    Operand<Float> tMax,
                                                                                                    Operand<T> m,
                                                                                                    Operand<Float> mMin,
                                                                                                    Operand<Float> mMax,
                                                                                                    Operand<T> v,
                                                                                                    Operand<Float> vMin,
                                                                                                    Operand<Float> vMax,
                                                                                                    Operand<T> beta,
                                                                                                    Operand<Float> betaMin,
                                                                                                    Operand<Float> betaMax,
                                                                                                    Operand<T> gamma,
                                                                                                    Operand<Float> gammaMin,
                                                                                                    Operand<Float> gammaMax,
                                                                                                    Class<U> outType,
                                                                                                    Float varianceEpsilon,
                                                                                                    Boolean scaleAfterNormalization)

Builds an QuantizedBatchNormWithGlobalNormalization operation

Parameters:: t - A 4D input Tensor.; tMin - The value represented by the lowest quantized input.; tMax - The value represented by the highest quantized input.; m - A 1D mean Tensor with size matching the last dimension of t.; mMin - The value represented by the lowest quantized mean.; mMax - The value represented by the highest quantized mean.; v - A 1D variance Tensor with size matching the last dimension of t.; vMin - The value represented by the lowest quantized variance.; vMax - The value represented by the highest quantized variance.; beta - A 1D beta Tensor with size matching the last dimension of t.; betaMin - The value represented by the lowest quantized offset.; betaMax - The value represented by the highest quantized offset.; gamma - A 1D gamma Tensor with size matching the last dimension of t.; gammaMin - The value represented by the lowest quantized gamma.; gammaMax - The value represented by the highest quantized gamma.; outType -; varianceEpsilon - A small float number to avoid dividing by 0.; scaleAfterNormalization - A bool indicating whether the resulted tensor
Returns:: a new instance of QuantizedBatchNormWithGlobalNormalization
See Also:: QuantizedBatchNormWithGlobalNormalization

maxPoolGradGradWithArgmax

public <T extends Number,U extends Number> MaxPoolGradGradWithArgmax<T> maxPoolGradGradWithArgmax(Operand<T> input,
                                                                                                  Operand<T> grad,
                                                                                                  Operand<U> argmax,
                                                                                                  List<Long> ksize,
                                                                                                  List<Long> strides,
                                                                                                  String padding,
                                                                                                  MaxPoolGradGradWithArgmax.Options... options)

Builds an MaxPoolGradGradWithArgmax operation

Parameters:: input - The original input.; grad - 4-D with shape `[batch, height, width, channels]`. Gradients w.r.t. the; argmax - The indices of the maximum values chosen for each output of `max_pool`.; ksize - The size of the window for each dimension of the input tensor.; strides - The stride of the sliding window for each dimension of the; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of MaxPoolGradGradWithArgmax
See Also:: MaxPoolGradGradWithArgmax

fractionalMaxPool

public <T extends Number> FractionalMaxPool<T> fractionalMaxPool(Operand<T> value,
                                                                 List<Float> poolingRatio,
                                                                 FractionalMaxPool.Options... options)

Builds an FractionalMaxPool operation

Parameters:: value - 4-D with shape `[batch, height, width, channels]`.; poolingRatio - Pooling ratio for each dimension of `value`, currently only; options - carries optional attributes values
Returns:: a new instance of FractionalMaxPool
See Also:: FractionalMaxPool

avgPool

public <T extends Number> AvgPool<T> avgPool(Operand<T> value,
                                             List<Long> ksize,
                                             List<Long> strides,
                                             String padding,
                                             AvgPool.Options... options)

Builds an AvgPool operation

Parameters:: value - 4-D with shape `[batch, height, width, channels]`.; ksize - The size of the sliding window for each dimension of `value`.; strides - The stride of the sliding window for each dimension of `value`.; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of AvgPool
See Also:: AvgPool

biasAdd

public <T> BiasAdd<T> biasAdd(Operand<T> value,
                              Operand<T> bias,
                              BiasAdd.Options... options)

Builds an BiasAdd operation

Parameters:: value - Any number of dimensions.; bias - 1-D with size the last dimension of `value`.; options - carries optional attributes values
Returns:: a new instance of BiasAdd
See Also:: BiasAdd

depthwiseConv2dNativeBackpropFilter

public <T extends Number> DepthwiseConv2dNativeBackpropFilter<T> depthwiseConv2dNativeBackpropFilter(Operand<T> input,
                                                                                                     Operand<Integer> filterSizes,
                                                                                                     Operand<T> outBackprop,
                                                                                                     List<Long> strides,
                                                                                                     String padding,
                                                                                                     DepthwiseConv2dNativeBackpropFilter.Options... options)

Builds an DepthwiseConv2dNativeBackpropFilter operation

Parameters:: input - 4-D with shape based on `data_format`. For example, if; filterSizes - An integer vector representing the tensor shape of `filter`,; outBackprop - 4-D with shape based on `data_format`.; strides - The stride of the sliding window for each dimension of the input; padding - The type of padding algorithm to use.; options - carries optional attributes values
Returns:: a new instance of DepthwiseConv2dNativeBackpropFilter
See Also:: DepthwiseConv2dNativeBackpropFilter

Class NnOps

Method Summary

Methods inherited from class java.lang.Object

Method Detail

topK

depthwiseConv2dNative

quantizedInstanceNorm

spaceToBatch

depthToSpace

softsign

conv3d

quantizedReluX

maxPoolWithArgmax

conv2dBackpropInput

computeAccidentalHits

maxPool3dGrad

cudnnRnnCanonicalToParams

fixedUnigramCandidateSampler

avgPool3d

relu6

elu

ctcLoss

conv3dBackpropFilter

cudnnRnnParamsToCanonical

fusedPadConv2d

quantizedRelu6

conv2dBackpropFilter

fusedResizeAndPadConv2d

ctcGreedyDecoder

dataFormatDimMap

sparseSoftmaxCrossEntropyWithLogits

fusedBatchNormGrad

maxPoolGradGrad

learnedUnigramCandidateSampler

relu

spaceToDepth

fusedBatchNorm

maxPool

quantizedConv2d

localResponseNormalization

quantizedRelu

dilation2d

maxPoolGrad

conv3dBackpropInput

nthElement

dataFormatVecPermute

quantizedMaxPool

softmax

biasAddGrad

batchNormWithGlobalNormalizationGrad

dilation2dBackpropFilter

maxPoolWithArgmax

avgPool3dGrad

inTopK

cudnnRnnParamsSize

dilation2dBackpropInput

quantizedAvgPool

batchNormWithGlobalNormalization

selu

logSoftmax

ctcBeamSearchDecoder

fractionalAvgPool

conv2d

l2Loss

maxPool3d

quantizedBiasAdd

depthwiseConv2dNativeBackpropInput

softmaxCrossEntropyWithLogits

maxPool3dGradGrad

quantizedBatchNormWithGlobalNormalization

maxPoolGradGradWithArgmax

fractionalMaxPool

avgPool

biasAdd

depthwiseConv2dNativeBackpropFilter