TrainOps (libtensorflow 1.15.0 API)

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

```
public final class TrainOps
extends Object
```
An API for building train operations as Ops

See Also:

Ops}

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T> AccumulatorApplyGradient`	`accumulatorApplyGradient(Operand<String> handle, Operand<Long> localStep, Operand<T> gradient)` Builds an `AccumulatorApplyGradient` operation
`AccumulatorNumAccumulated`	`accumulatorNumAccumulated(Operand<String> handle)` Builds an `AccumulatorNumAccumulated` operation
`AccumulatorSetGlobalStep`	`accumulatorSetGlobalStep(Operand<String> handle, Operand<Long> newGlobalStep)` Builds an `AccumulatorSetGlobalStep` operation
`<T> AccumulatorTakeGradient<T>`	`accumulatorTakeGradient(Operand<String> handle, Operand<Integer> numRequired, Class<T> dtype)` Builds an `AccumulatorTakeGradient` operation
`<T> ApplyAdadelta<T>`	`applyAdadelta(Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, ApplyAdadelta.Options... options)` Builds an `ApplyAdadelta` operation
`<T> ApplyAdagrad<T>`	`applyAdagrad(Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, ApplyAdagrad.Options... options)` Builds an `ApplyAdagrad` operation
`<T> ApplyAdagradDa<T>`	`applyAdagradDa(Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<Long> globalStep, ApplyAdagradDa.Options... options)` Builds an `ApplyAdagradDa` operation
`<T> ApplyAdam<T>`	`applyAdam(Operand<T> var, Operand<T> m, Operand<T> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, ApplyAdam.Options... options)` Builds an `ApplyAdam` operation
`<T> ApplyAddSign<T>`	`applyAddSign(Operand<T> var, Operand<T> m, Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, ApplyAddSign.Options... options)` Builds an `ApplyAddSign` operation
`<T> ApplyCenteredRmsProp<T>`	`applyCenteredRmsProp(Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, ApplyCenteredRmsProp.Options... options)` Builds an `ApplyCenteredRmsProp` operation
`<T> ApplyFtrl<T>`	`applyFtrl(Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, ApplyFtrl.Options... options)` Builds an `ApplyFtrl` operation
`<T> ApplyGradientDescent<T>`	`applyGradientDescent(Operand<T> var, Operand<T> alpha, Operand<T> delta, ApplyGradientDescent.Options... options)` Builds an `ApplyGradientDescent` operation
`<T> ApplyMomentum<T>`	`applyMomentum(Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, ApplyMomentum.Options... options)` Builds an `ApplyMomentum` operation
`<T> ApplyPowerSign<T>`	`applyPowerSign(Operand<T> var, Operand<T> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, ApplyPowerSign.Options... options)` Builds an `ApplyPowerSign` operation
`<T> ApplyProximalAdagrad<T>`	`applyProximalAdagrad(Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, ApplyProximalAdagrad.Options... options)` Builds an `ApplyProximalAdagrad` operation
`<T> ApplyProximalGradientDescent<T>`	`applyProximalGradientDescent(Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta, ApplyProximalGradientDescent.Options... options)` Builds an `ApplyProximalGradientDescent` operation
`<T> ApplyRmsProp<T>`	`applyRmsProp(Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, ApplyRmsProp.Options... options)` Builds an `ApplyRmsProp` operation
`<T> ConditionalAccumulator`	`conditionalAccumulator(Class<T> dtype, Shape shape, ConditionalAccumulator.Options... options)` Builds an `ConditionalAccumulator` operation
`GenerateVocabRemapping`	`generateVocabRemapping(Operand<String> newVocabFile, Operand<String> oldVocabFile, Long newVocabOffset, Long numNewVocab, GenerateVocabRemapping.Options... options)` Builds an `GenerateVocabRemapping` operation
`MergeV2Checkpoints`	`mergeV2Checkpoints(Operand<String> checkpointPrefixes, Operand<String> destinationPrefix, MergeV2Checkpoints.Options... options)` Builds an `MergeV2Checkpoints` operation
`NegTrain`	`negTrain(Operand<Float> wIn, Operand<Float> wOut, Operand<Integer> examples, Operand<Integer> labels, Operand<Float> lr, List<Long> vocabCount, Long numNegativeSamples)` Builds an `NegTrain` operation
`<T> PreventGradient<T>`	`preventGradient(Operand<T> input, PreventGradient.Options... options)` Builds an `PreventGradient` operation
`<T> ResourceApplyAdadelta`	`resourceApplyAdadelta(Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, ResourceApplyAdadelta.Options... options)` Builds an `ResourceApplyAdadelta` operation
`<T> ResourceApplyAdagrad`	`resourceApplyAdagrad(Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, ResourceApplyAdagrad.Options... options)` Builds an `ResourceApplyAdagrad` operation
`<T> ResourceApplyAdagradDa`	`resourceApplyAdagradDa(Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<Long> globalStep, ResourceApplyAdagradDa.Options... options)` Builds an `ResourceApplyAdagradDa` operation
`<T> ResourceApplyAdam`	`resourceApplyAdam(Operand<?> var, Operand<?> m, Operand<?> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, ResourceApplyAdam.Options... options)` Builds an `ResourceApplyAdam` operation
`<T> ResourceApplyAddSign`	`resourceApplyAddSign(Operand<?> var, Operand<?> m, Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, ResourceApplyAddSign.Options... options)` Builds an `ResourceApplyAddSign` operation
`<T> ResourceApplyCenteredRmsProp`	`resourceApplyCenteredRmsProp(Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, ResourceApplyCenteredRmsProp.Options... options)` Builds an `ResourceApplyCenteredRmsProp` operation
`<T> ResourceApplyFtrl`	`resourceApplyFtrl(Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, ResourceApplyFtrl.Options... options)` Builds an `ResourceApplyFtrl` operation
`<T> ResourceApplyGradientDescent`	`resourceApplyGradientDescent(Operand<?> var, Operand<T> alpha, Operand<T> delta, ResourceApplyGradientDescent.Options... options)` Builds an `ResourceApplyGradientDescent` operation
`<T> ResourceApplyMomentum`	`resourceApplyMomentum(Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, ResourceApplyMomentum.Options... options)` Builds an `ResourceApplyMomentum` operation
`<T> ResourceApplyPowerSign`	`resourceApplyPowerSign(Operand<?> var, Operand<?> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, ResourceApplyPowerSign.Options... options)` Builds an `ResourceApplyPowerSign` operation
`<T> ResourceApplyProximalAdagrad`	`resourceApplyProximalAdagrad(Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, ResourceApplyProximalAdagrad.Options... options)` Builds an `ResourceApplyProximalAdagrad` operation
`<T> ResourceApplyProximalGradientDescent`	`resourceApplyProximalGradientDescent(Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta, ResourceApplyProximalGradientDescent.Options... options)` Builds an `ResourceApplyProximalGradientDescent` operation
`<T> ResourceApplyRmsProp`	`resourceApplyRmsProp(Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, ResourceApplyRmsProp.Options... options)` Builds an `ResourceApplyRmsProp` operation
`<T,U extends Number> ResourceSparseApplyAdadelta`	`resourceSparseApplyAdadelta(Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, ResourceSparseApplyAdadelta.Options... options)` Builds an `ResourceSparseApplyAdadelta` operation
`<T,U extends Number> ResourceSparseApplyAdagrad`	`resourceSparseApplyAdagrad(Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, ResourceSparseApplyAdagrad.Options... options)` Builds an `ResourceSparseApplyAdagrad` operation
`<T,U extends Number> ResourceSparseApplyAdagradDa`	`resourceSparseApplyAdagradDa(Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<Long> globalStep, ResourceSparseApplyAdagradDa.Options... options)` Builds an `ResourceSparseApplyAdagradDa` operation
`<T,U extends Number> ResourceSparseApplyCenteredRmsProp`	`resourceSparseApplyCenteredRmsProp(Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, ResourceSparseApplyCenteredRmsProp.Options... options)` Builds an `ResourceSparseApplyCenteredRmsProp` operation
`<T,U extends Number> ResourceSparseApplyFtrl`	`resourceSparseApplyFtrl(Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, ResourceSparseApplyFtrl.Options... options)` Builds an `ResourceSparseApplyFtrl` operation
`<T,U extends Number> ResourceSparseApplyMomentum`	`resourceSparseApplyMomentum(Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, ResourceSparseApplyMomentum.Options... options)` Builds an `ResourceSparseApplyMomentum` operation
`<T,U extends Number> ResourceSparseApplyProximalAdagrad`	`resourceSparseApplyProximalAdagrad(Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, ResourceSparseApplyProximalAdagrad.Options... options)` Builds an `ResourceSparseApplyProximalAdagrad` operation
`<T,U extends Number> ResourceSparseApplyProximalGradientDescent`	`resourceSparseApplyProximalGradientDescent(Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, ResourceSparseApplyProximalGradientDescent.Options... options)` Builds an `ResourceSparseApplyProximalGradientDescent` operation
`<T,U extends Number> ResourceSparseApplyRmsProp`	`resourceSparseApplyRmsProp(Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, ResourceSparseApplyRmsProp.Options... options)` Builds an `ResourceSparseApplyRmsProp` operation
`Restore`	`restore(Operand<String> prefix, Operand<String> tensorNames, Operand<String> shapeAndSlices, List<Class<?>> dtypes)` Builds an `Restore` operation
`<T> RestoreSlice<T>`	`restoreSlice(Operand<String> filePattern, Operand<String> tensorName, Operand<String> shapeAndSlice, Class<T> dt, RestoreSlice.Options... options)` Builds an `RestoreSlice` operation
`Save`	`save(Operand<String> prefix, Operand<String> tensorNames, Operand<String> shapeAndSlices, Iterable<Operand<?>> tensors)` Builds an `Save` operation
`SaveSlices`	`saveSlices(Operand<String> filename, Operand<String> tensorNames, Operand<String> shapesAndSlices, Iterable<Operand<?>> data)` Builds an `SaveSlices` operation
`SdcaFprint`	`sdcaFprint(Operand<String> input)` Builds an `SdcaFprint` operation
`SdcaShrinkL1`	`sdcaShrinkL1(Iterable<Operand<Float>> weights, Float l1, Float l2)` Builds an `SdcaShrinkL1` operation
`<T,U extends Number> SparseApplyAdadelta<T>`	`sparseApplyAdadelta(Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, SparseApplyAdadelta.Options... options)` Builds an `SparseApplyAdadelta` operation
`<T,U extends Number> SparseApplyAdagrad<T>`	`sparseApplyAdagrad(Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, SparseApplyAdagrad.Options... options)` Builds an `SparseApplyAdagrad` operation
`<T,U extends Number> SparseApplyAdagradDa<T>`	`sparseApplyAdagradDa(Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<Long> globalStep, SparseApplyAdagradDa.Options... options)` Builds an `SparseApplyAdagradDa` operation
`<T,U extends Number> SparseApplyCenteredRmsProp<T>`	`sparseApplyCenteredRmsProp(Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, SparseApplyCenteredRmsProp.Options... options)` Builds an `SparseApplyCenteredRmsProp` operation
`<T,U extends Number> SparseApplyFtrl<T>`	`sparseApplyFtrl(Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, SparseApplyFtrl.Options... options)` Builds an `SparseApplyFtrl` operation
`<T,U extends Number> SparseApplyMomentum<T>`	`sparseApplyMomentum(Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, SparseApplyMomentum.Options... options)` Builds an `SparseApplyMomentum` operation
`<T,U extends Number> SparseApplyProximalAdagrad<T>`	`sparseApplyProximalAdagrad(Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, SparseApplyProximalAdagrad.Options... options)` Builds an `SparseApplyProximalAdagrad` operation
`<T,U extends Number> SparseApplyProximalGradientDescent<T>`	`sparseApplyProximalGradientDescent(Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, SparseApplyProximalGradientDescent.Options... options)` Builds an `SparseApplyProximalGradientDescent` operation
`<T,U extends Number> SparseApplyRmsProp<T>`	`sparseApplyRmsProp(Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, SparseApplyRmsProp.Options... options)` Builds an `SparseApplyRmsProp` operation
`<T> TileGrad<T>`	`tileGrad(Operand<T> input, Operand<Integer> multiples)` Builds an `TileGrad` operation

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

Method Detail

sparseApplyRmsProp

public <T,U extends Number> SparseApplyRmsProp<T> sparseApplyRmsProp(Operand<T> var,
                                                                     Operand<T> ms,
                                                                     Operand<T> mom,
                                                                     Operand<T> lr,
                                                                     Operand<T> rho,
                                                                     Operand<T> momentum,
                                                                     Operand<T> epsilon,
                                                                     Operand<T> grad,
                                                                     Operand<U> indices,
                                                                     SparseApplyRmsProp.Options... options)

Builds an SparseApplyRmsProp operation

Parameters:: var - Should be from a Variable().; ms - Should be from a Variable().; mom - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; rho - Decay rate. Must be a scalar.; momentum -; epsilon - Ridge term. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var, ms and mom.; options - carries optional attributes values
Returns:: a new instance of SparseApplyRmsProp
See Also:: SparseApplyRmsProp

applyMomentum

public <T> ApplyMomentum<T> applyMomentum(Operand<T> var,
                                          Operand<T> accum,
                                          Operand<T> lr,
                                          Operand<T> grad,
                                          Operand<T> momentum,
                                          ApplyMomentum.Options... options)

Builds an ApplyMomentum operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; grad - The gradient.; momentum - Momentum. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of ApplyMomentum
See Also:: ApplyMomentum

sparseApplyMomentum

public <T,U extends Number> SparseApplyMomentum<T> sparseApplyMomentum(Operand<T> var,
                                                                       Operand<T> accum,
                                                                       Operand<T> lr,
                                                                       Operand<T> grad,
                                                                       Operand<U> indices,
                                                                       Operand<T> momentum,
                                                                       SparseApplyMomentum.Options... options)

Builds an SparseApplyMomentum operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Learning rate. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; momentum - Momentum. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of SparseApplyMomentum
See Also:: SparseApplyMomentum

resourceSparseApplyRmsProp

public <T,U extends Number> ResourceSparseApplyRmsProp resourceSparseApplyRmsProp(Operand<?> var,
                                                                                  Operand<?> ms,
                                                                                  Operand<?> mom,
                                                                                  Operand<T> lr,
                                                                                  Operand<T> rho,
                                                                                  Operand<T> momentum,
                                                                                  Operand<T> epsilon,
                                                                                  Operand<T> grad,
                                                                                  Operand<U> indices,
                                                                                  ResourceSparseApplyRmsProp.Options... options)

Builds an ResourceSparseApplyRmsProp operation

Parameters:: var - Should be from a Variable().; ms - Should be from a Variable().; mom - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; rho - Decay rate. Must be a scalar.; momentum -; epsilon - Ridge term. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var, ms and mom.; options - carries optional attributes values
Returns:: a new instance of ResourceSparseApplyRmsProp
See Also:: ResourceSparseApplyRmsProp

resourceApplyAdagradDa

public <T> ResourceApplyAdagradDa resourceApplyAdagradDa(Operand<?> var,
                                                         Operand<?> gradientAccumulator,
                                                         Operand<?> gradientSquaredAccumulator,
                                                         Operand<T> grad,
                                                         Operand<T> lr,
                                                         Operand<T> l1,
                                                         Operand<T> l2,
                                                         Operand<Long> globalStep,
                                                         ResourceApplyAdagradDa.Options... options)

Builds an ResourceApplyAdagradDa operation

Parameters:: var - Should be from a Variable().; gradientAccumulator - Should be from a Variable().; gradientSquaredAccumulator - Should be from a Variable().; grad - The gradient.; lr - Scaling factor. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; globalStep - Training step number. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyAdagradDa
See Also:: ResourceApplyAdagradDa

applyAddSign

public <T> ApplyAddSign<T> applyAddSign(Operand<T> var,
                                        Operand<T> m,
                                        Operand<T> lr,
                                        Operand<T> alpha,
                                        Operand<T> signDecay,
                                        Operand<T> beta,
                                        Operand<T> grad,
                                        ApplyAddSign.Options... options)

Builds an ApplyAddSign operation

Parameters:: var - Should be from a Variable().; m - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; alpha - Must be a scalar.; signDecay - Must be a scalar.; beta - Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ApplyAddSign
See Also:: ApplyAddSign

applyGradientDescent

public <T> ApplyGradientDescent<T> applyGradientDescent(Operand<T> var,
                                                        Operand<T> alpha,
                                                        Operand<T> delta,
                                                        ApplyGradientDescent.Options... options)

Builds an ApplyGradientDescent operation

Parameters:: var - Should be from a Variable().; alpha - Scaling factor. Must be a scalar.; delta - The change.; options - carries optional attributes values
Returns:: a new instance of ApplyGradientDescent
See Also:: ApplyGradientDescent

sparseApplyFtrl

public <T,U extends Number> SparseApplyFtrl<T> sparseApplyFtrl(Operand<T> var,
                                                               Operand<T> accum,
                                                               Operand<T> linear,
                                                               Operand<T> grad,
                                                               Operand<U> indices,
                                                               Operand<T> lr,
                                                               Operand<T> l1,
                                                               Operand<T> l2,
                                                               Operand<T> l2Shrinkage,
                                                               Operand<T> lrPower,
                                                               SparseApplyFtrl.Options... options)

Builds an SparseApplyFtrl operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; linear - Should be from a Variable().; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; lr - Scaling factor. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 shrinkage regulariation. Must be a scalar.; l2Shrinkage -; lrPower - Scaling factor. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of SparseApplyFtrl
See Also:: SparseApplyFtrl

applyAdam

public <T> ApplyAdam<T> applyAdam(Operand<T> var,
                                  Operand<T> m,
                                  Operand<T> v,
                                  Operand<T> beta1Power,
                                  Operand<T> beta2Power,
                                  Operand<T> lr,
                                  Operand<T> beta1,
                                  Operand<T> beta2,
                                  Operand<T> epsilon,
                                  Operand<T> grad,
                                  ApplyAdam.Options... options)

Builds an ApplyAdam operation

Parameters:: var - Should be from a Variable().; m - Should be from a Variable().; v - Should be from a Variable().; beta1Power - Must be a scalar.; beta2Power - Must be a scalar.; lr - Scaling factor. Must be a scalar.; beta1 - Momentum factor. Must be a scalar.; beta2 - Momentum factor. Must be a scalar.; epsilon - Ridge term. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ApplyAdam
See Also:: ApplyAdam

negTrain

public NegTrain negTrain(Operand<Float> wIn,
                         Operand<Float> wOut,
                         Operand<Integer> examples,
                         Operand<Integer> labels,
                         Operand<Float> lr,
                         List<Long> vocabCount,
                         Long numNegativeSamples)

Builds an NegTrain operation

Parameters:: wIn - input word embedding.; wOut - output word embedding.; examples - A vector of word ids.; labels - A vector of word ids.; lr -; vocabCount - Count of words in the vocabulary.; numNegativeSamples - Number of negative samples per example.
Returns:: a new instance of NegTrain
See Also:: NegTrain

preventGradient

public <T> PreventGradient<T> preventGradient(Operand<T> input,
                                              PreventGradient.Options... options)

Builds an PreventGradient operation

Parameters:: input - any tensor.; options - carries optional attributes values
Returns:: a new instance of PreventGradient
See Also:: PreventGradient

applyProximalAdagrad

public <T> ApplyProximalAdagrad<T> applyProximalAdagrad(Operand<T> var,
                                                        Operand<T> accum,
                                                        Operand<T> lr,
                                                        Operand<T> l1,
                                                        Operand<T> l2,
                                                        Operand<T> grad,
                                                        ApplyProximalAdagrad.Options... options)

Builds an ApplyProximalAdagrad operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ApplyProximalAdagrad
See Also:: ApplyProximalAdagrad

accumulatorNumAccumulated
```
public AccumulatorNumAccumulated accumulatorNumAccumulated(Operand<String> handle)
```
Builds an AccumulatorNumAccumulated operation

Parameters:

handle - The handle to an accumulator.

Returns:

a new instance of AccumulatorNumAccumulated

See Also:

AccumulatorNumAccumulated

applyAdagrad

public <T> ApplyAdagrad<T> applyAdagrad(Operand<T> var,
                                        Operand<T> accum,
                                        Operand<T> lr,
                                        Operand<T> grad,
                                        ApplyAdagrad.Options... options)

Builds an ApplyAdagrad operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ApplyAdagrad
See Also:: ApplyAdagrad

resourceApplyProximalAdagrad

public <T> ResourceApplyProximalAdagrad resourceApplyProximalAdagrad(Operand<?> var,
                                                                     Operand<?> accum,
                                                                     Operand<T> lr,
                                                                     Operand<T> l1,
                                                                     Operand<T> l2,
                                                                     Operand<T> grad,
                                                                     ResourceApplyProximalAdagrad.Options... options)

Builds an ResourceApplyProximalAdagrad operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyProximalAdagrad
See Also:: ResourceApplyProximalAdagrad

resourceSparseApplyAdagradDa

public <T,U extends Number> ResourceSparseApplyAdagradDa resourceSparseApplyAdagradDa(Operand<?> var,
                                                                                      Operand<?> gradientAccumulator,
                                                                                      Operand<?> gradientSquaredAccumulator,
                                                                                      Operand<T> grad,
                                                                                      Operand<U> indices,
                                                                                      Operand<T> lr,
                                                                                      Operand<T> l1,
                                                                                      Operand<T> l2,
                                                                                      Operand<Long> globalStep,
                                                                                      ResourceSparseApplyAdagradDa.Options... options)

Builds an ResourceSparseApplyAdagradDa operation

Parameters:: var - Should be from a Variable().; gradientAccumulator - Should be from a Variable().; gradientSquaredAccumulator - Should be from a Variable().; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; lr - Learning rate. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; globalStep - Training step number. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of ResourceSparseApplyAdagradDa
See Also:: ResourceSparseApplyAdagradDa

sparseApplyCenteredRmsProp

public <T,U extends Number> SparseApplyCenteredRmsProp<T> sparseApplyCenteredRmsProp(Operand<T> var,
                                                                                     Operand<T> mg,
                                                                                     Operand<T> ms,
                                                                                     Operand<T> mom,
                                                                                     Operand<T> lr,
                                                                                     Operand<T> rho,
                                                                                     Operand<T> momentum,
                                                                                     Operand<T> epsilon,
                                                                                     Operand<T> grad,
                                                                                     Operand<U> indices,
                                                                                     SparseApplyCenteredRmsProp.Options... options)

Builds an SparseApplyCenteredRmsProp operation

Parameters:: var - Should be from a Variable().; mg - Should be from a Variable().; ms - Should be from a Variable().; mom - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; rho - Decay rate. Must be a scalar.; momentum -; epsilon - Ridge term. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var, ms and mom.; options - carries optional attributes values
Returns:: a new instance of SparseApplyCenteredRmsProp
See Also:: SparseApplyCenteredRmsProp

accumulatorSetGlobalStep
```
public AccumulatorSetGlobalStep accumulatorSetGlobalStep(Operand<String> handle,
                                                         Operand<Long> newGlobalStep)
```
Builds an AccumulatorSetGlobalStep operation

Parameters:

handle - The handle to an accumulator.

newGlobalStep - The new global_step value to set.

Returns:

a new instance of AccumulatorSetGlobalStep

See Also:

AccumulatorSetGlobalStep

applyProximalGradientDescent

public <T> ApplyProximalGradientDescent<T> applyProximalGradientDescent(Operand<T> var,
                                                                        Operand<T> alpha,
                                                                        Operand<T> l1,
                                                                        Operand<T> l2,
                                                                        Operand<T> delta,
                                                                        ApplyProximalGradientDescent.Options... options)

Builds an ApplyProximalGradientDescent operation

Parameters:: var - Should be from a Variable().; alpha - Scaling factor. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; delta - The change.; options - carries optional attributes values
Returns:: a new instance of ApplyProximalGradientDescent
See Also:: ApplyProximalGradientDescent

save
```
public Save save(Operand<String> prefix,
                 Operand<String> tensorNames,
                 Operand<String> shapeAndSlices,
                 Iterable<Operand<?>> tensors)
```
Builds an Save operation

Parameters:

prefix - Must have a single element. The prefix of the V2 checkpoint to which we

tensorNames - shape {N}. The names of the tensors to be saved.

shapeAndSlices - shape {N}. The slice specs of the tensors to be saved.

tensors - `N` tensors to save.

Returns:

a new instance of Save

See Also:

Save

applyPowerSign

public <T> ApplyPowerSign<T> applyPowerSign(Operand<T> var,
                                            Operand<T> m,
                                            Operand<T> lr,
                                            Operand<T> logbase,
                                            Operand<T> signDecay,
                                            Operand<T> beta,
                                            Operand<T> grad,
                                            ApplyPowerSign.Options... options)

Builds an ApplyPowerSign operation

Parameters:: var - Should be from a Variable().; m - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; logbase - Must be a scalar.; signDecay - Must be a scalar.; beta - Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ApplyPowerSign
See Also:: ApplyPowerSign

applyAdadelta

public <T> ApplyAdadelta<T> applyAdadelta(Operand<T> var,
                                          Operand<T> accum,
                                          Operand<T> accumUpdate,
                                          Operand<T> lr,
                                          Operand<T> rho,
                                          Operand<T> epsilon,
                                          Operand<T> grad,
                                          ApplyAdadelta.Options... options)

Builds an ApplyAdadelta operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; accumUpdate - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; rho - Decay factor. Must be a scalar.; epsilon - Constant factor. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ApplyAdadelta
See Also:: ApplyAdadelta

restore
```
public Restore restore(Operand<String> prefix,
                       Operand<String> tensorNames,
                       Operand<String> shapeAndSlices,
                       List<Class<?>> dtypes)
```
Builds an Restore operation

Parameters:

prefix - Must have a single element. The prefix of a V2 checkpoint.

tensorNames - shape {N}. The names of the tensors to be restored.

shapeAndSlices - shape {N}. The slice specs of the tensors to be restored.

dtypes - shape {N}. The list of expected dtype for the tensors. Must match

Returns:

a new instance of Restore

See Also:

Restore

resourceApplyRmsProp

public <T> ResourceApplyRmsProp resourceApplyRmsProp(Operand<?> var,
                                                     Operand<?> ms,
                                                     Operand<?> mom,
                                                     Operand<T> lr,
                                                     Operand<T> rho,
                                                     Operand<T> momentum,
                                                     Operand<T> epsilon,
                                                     Operand<T> grad,
                                                     ResourceApplyRmsProp.Options... options)

Builds an ResourceApplyRmsProp operation

Parameters:: var - Should be from a Variable().; ms - Should be from a Variable().; mom - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; rho - Decay rate. Must be a scalar.; momentum -; epsilon - Ridge term. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyRmsProp
See Also:: ResourceApplyRmsProp

restoreSlice

public <T> RestoreSlice<T> restoreSlice(Operand<String> filePattern,
                                        Operand<String> tensorName,
                                        Operand<String> shapeAndSlice,
                                        Class<T> dt,
                                        RestoreSlice.Options... options)

Builds an RestoreSlice operation

Parameters:: filePattern - Must have a single element. The pattern of the files from; tensorName - Must have a single element. The name of the tensor to be; shapeAndSlice - Scalar. The shapes and slice specifications to use when; dt - The type of the tensor to be restored.; options - carries optional attributes values
Returns:: a new instance of RestoreSlice
See Also:: RestoreSlice

resourceApplyCenteredRmsProp

public <T> ResourceApplyCenteredRmsProp resourceApplyCenteredRmsProp(Operand<?> var,
                                                                     Operand<?> mg,
                                                                     Operand<?> ms,
                                                                     Operand<?> mom,
                                                                     Operand<T> lr,
                                                                     Operand<T> rho,
                                                                     Operand<T> momentum,
                                                                     Operand<T> epsilon,
                                                                     Operand<T> grad,
                                                                     ResourceApplyCenteredRmsProp.Options... options)

Builds an ResourceApplyCenteredRmsProp operation

Parameters:: var - Should be from a Variable().; mg - Should be from a Variable().; ms - Should be from a Variable().; mom - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; rho - Decay rate. Must be a scalar.; momentum -; epsilon - Ridge term. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyCenteredRmsProp
See Also:: ResourceApplyCenteredRmsProp

sparseApplyAdagrad

public <T,U extends Number> SparseApplyAdagrad<T> sparseApplyAdagrad(Operand<T> var,
                                                                     Operand<T> accum,
                                                                     Operand<T> lr,
                                                                     Operand<T> grad,
                                                                     Operand<U> indices,
                                                                     SparseApplyAdagrad.Options... options)

Builds an SparseApplyAdagrad operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Learning rate. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; options - carries optional attributes values
Returns:: a new instance of SparseApplyAdagrad
See Also:: SparseApplyAdagrad

resourceApplyProximalGradientDescent

public <T> ResourceApplyProximalGradientDescent resourceApplyProximalGradientDescent(Operand<?> var,
                                                                                     Operand<T> alpha,
                                                                                     Operand<T> l1,
                                                                                     Operand<T> l2,
                                                                                     Operand<T> delta,
                                                                                     ResourceApplyProximalGradientDescent.Options... options)

Builds an ResourceApplyProximalGradientDescent operation

Parameters:: var - Should be from a Variable().; alpha - Scaling factor. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; delta - The change.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyProximalGradientDescent
See Also:: ResourceApplyProximalGradientDescent

applyFtrl

public <T> ApplyFtrl<T> applyFtrl(Operand<T> var,
                                  Operand<T> accum,
                                  Operand<T> linear,
                                  Operand<T> grad,
                                  Operand<T> lr,
                                  Operand<T> l1,
                                  Operand<T> l2,
                                  Operand<T> l2Shrinkage,
                                  Operand<T> lrPower,
                                  ApplyFtrl.Options... options)

Builds an ApplyFtrl operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; linear - Should be from a Variable().; grad - The gradient.; lr - Scaling factor. Must be a scalar.; l1 - L1 regulariation. Must be a scalar.; l2 - L2 shrinkage regulariation. Must be a scalar.; l2Shrinkage -; lrPower - Scaling factor. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of ApplyFtrl
See Also:: ApplyFtrl

resourceApplyFtrl

public <T> ResourceApplyFtrl resourceApplyFtrl(Operand<?> var,
                                               Operand<?> accum,
                                               Operand<?> linear,
                                               Operand<T> grad,
                                               Operand<T> lr,
                                               Operand<T> l1,
                                               Operand<T> l2,
                                               Operand<T> l2Shrinkage,
                                               Operand<T> lrPower,
                                               ResourceApplyFtrl.Options... options)

Builds an ResourceApplyFtrl operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; linear - Should be from a Variable().; grad - The gradient.; lr - Scaling factor. Must be a scalar.; l1 - L1 regulariation. Must be a scalar.; l2 - L2 shrinkage regulariation. Must be a scalar.; l2Shrinkage -; lrPower - Scaling factor. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyFtrl
See Also:: ResourceApplyFtrl

resourceSparseApplyFtrl

public <T,U extends Number> ResourceSparseApplyFtrl resourceSparseApplyFtrl(Operand<?> var,
                                                                            Operand<?> accum,
                                                                            Operand<?> linear,
                                                                            Operand<T> grad,
                                                                            Operand<U> indices,
                                                                            Operand<T> lr,
                                                                            Operand<T> l1,
                                                                            Operand<T> l2,
                                                                            Operand<T> l2Shrinkage,
                                                                            Operand<T> lrPower,
                                                                            ResourceSparseApplyFtrl.Options... options)

Builds an ResourceSparseApplyFtrl operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; linear - Should be from a Variable().; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; lr - Scaling factor. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 shrinkage regulariation. Must be a scalar.; l2Shrinkage -; lrPower - Scaling factor. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of ResourceSparseApplyFtrl
See Also:: ResourceSparseApplyFtrl

resourceSparseApplyProximalGradientDescent

public <T,U extends Number> ResourceSparseApplyProximalGradientDescent resourceSparseApplyProximalGradientDescent(Operand<?> var,
                                                                                                                  Operand<T> alpha,
                                                                                                                  Operand<T> l1,
                                                                                                                  Operand<T> l2,
                                                                                                                  Operand<T> grad,
                                                                                                                  Operand<U> indices,
                                                                                                                  ResourceSparseApplyProximalGradientDescent.Options... options)

Builds an ResourceSparseApplyProximalGradientDescent operation

Parameters:: var - Should be from a Variable().; alpha - Scaling factor. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; options - carries optional attributes values
Returns:: a new instance of ResourceSparseApplyProximalGradientDescent
See Also:: ResourceSparseApplyProximalGradientDescent

resourceApplyAdagrad

public <T> ResourceApplyAdagrad resourceApplyAdagrad(Operand<?> var,
                                                     Operand<?> accum,
                                                     Operand<T> lr,
                                                     Operand<T> grad,
                                                     ResourceApplyAdagrad.Options... options)

Builds an ResourceApplyAdagrad operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyAdagrad
See Also:: ResourceApplyAdagrad

sparseApplyAdagradDa

public <T,U extends Number> SparseApplyAdagradDa<T> sparseApplyAdagradDa(Operand<T> var,
                                                                         Operand<T> gradientAccumulator,
                                                                         Operand<T> gradientSquaredAccumulator,
                                                                         Operand<T> grad,
                                                                         Operand<U> indices,
                                                                         Operand<T> lr,
                                                                         Operand<T> l1,
                                                                         Operand<T> l2,
                                                                         Operand<Long> globalStep,
                                                                         SparseApplyAdagradDa.Options... options)

Builds an SparseApplyAdagradDa operation

Parameters:: var - Should be from a Variable().; gradientAccumulator - Should be from a Variable().; gradientSquaredAccumulator - Should be from a Variable().; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; lr - Learning rate. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; globalStep - Training step number. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of SparseApplyAdagradDa
See Also:: SparseApplyAdagradDa

resourceSparseApplyAdagrad

public <T,U extends Number> ResourceSparseApplyAdagrad resourceSparseApplyAdagrad(Operand<?> var,
                                                                                  Operand<?> accum,
                                                                                  Operand<T> lr,
                                                                                  Operand<T> grad,
                                                                                  Operand<U> indices,
                                                                                  ResourceSparseApplyAdagrad.Options... options)

Builds an ResourceSparseApplyAdagrad operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Learning rate. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; options - carries optional attributes values
Returns:: a new instance of ResourceSparseApplyAdagrad
See Also:: ResourceSparseApplyAdagrad

resourceSparseApplyMomentum

public <T,U extends Number> ResourceSparseApplyMomentum resourceSparseApplyMomentum(Operand<?> var,
                                                                                    Operand<?> accum,
                                                                                    Operand<T> lr,
                                                                                    Operand<T> grad,
                                                                                    Operand<U> indices,
                                                                                    Operand<T> momentum,
                                                                                    ResourceSparseApplyMomentum.Options... options)

Builds an ResourceSparseApplyMomentum operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Learning rate. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; momentum - Momentum. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of ResourceSparseApplyMomentum
See Also:: ResourceSparseApplyMomentum

sdcaShrinkL1
```
public SdcaShrinkL1 sdcaShrinkL1(Iterable<Operand<Float>> weights,
                                 Float l1,
                                 Float l2)
```
Builds an SdcaShrinkL1 operation

Parameters:

weights - a list of vectors where each value is the weight associated with a

l1 - Symmetric l1 regularization strength.

l2 - Symmetric l2 regularization strength. Should be a positive float.

Returns:

a new instance of SdcaShrinkL1

See Also:

SdcaShrinkL1

resourceApplyAddSign

public <T> ResourceApplyAddSign resourceApplyAddSign(Operand<?> var,
                                                     Operand<?> m,
                                                     Operand<T> lr,
                                                     Operand<T> alpha,
                                                     Operand<T> signDecay,
                                                     Operand<T> beta,
                                                     Operand<T> grad,
                                                     ResourceApplyAddSign.Options... options)

Builds an ResourceApplyAddSign operation

Parameters:: var - Should be from a Variable().; m - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; alpha - Must be a scalar.; signDecay - Must be a scalar.; beta - Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyAddSign
See Also:: ResourceApplyAddSign

resourceApplyAdadelta

public <T> ResourceApplyAdadelta resourceApplyAdadelta(Operand<?> var,
                                                       Operand<?> accum,
                                                       Operand<?> accumUpdate,
                                                       Operand<T> lr,
                                                       Operand<T> rho,
                                                       Operand<T> epsilon,
                                                       Operand<T> grad,
                                                       ResourceApplyAdadelta.Options... options)

Builds an ResourceApplyAdadelta operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; accumUpdate - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; rho - Decay factor. Must be a scalar.; epsilon - Constant factor. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyAdadelta
See Also:: ResourceApplyAdadelta

applyCenteredRmsProp

public <T> ApplyCenteredRmsProp<T> applyCenteredRmsProp(Operand<T> var,
                                                        Operand<T> mg,
                                                        Operand<T> ms,
                                                        Operand<T> mom,
                                                        Operand<T> lr,
                                                        Operand<T> rho,
                                                        Operand<T> momentum,
                                                        Operand<T> epsilon,
                                                        Operand<T> grad,
                                                        ApplyCenteredRmsProp.Options... options)

Builds an ApplyCenteredRmsProp operation

Parameters:: var - Should be from a Variable().; mg - Should be from a Variable().; ms - Should be from a Variable().; mom - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; rho - Decay rate. Must be a scalar.; momentum -; epsilon - Ridge term. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ApplyCenteredRmsProp
See Also:: ApplyCenteredRmsProp

resourceSparseApplyAdadelta

public <T,U extends Number> ResourceSparseApplyAdadelta resourceSparseApplyAdadelta(Operand<?> var,
                                                                                    Operand<?> accum,
                                                                                    Operand<?> accumUpdate,
                                                                                    Operand<T> lr,
                                                                                    Operand<T> rho,
                                                                                    Operand<T> epsilon,
                                                                                    Operand<T> grad,
                                                                                    Operand<U> indices,
                                                                                    ResourceSparseApplyAdadelta.Options... options)

Builds an ResourceSparseApplyAdadelta operation

Parameters:: var -; accum - Should be from a Variable().; accumUpdate - : Should be from a Variable().; lr - Learning rate. Must be a scalar.; rho - Decay factor. Must be a scalar.; epsilon - Constant factor. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; options - carries optional attributes values
Returns:: a new instance of ResourceSparseApplyAdadelta
See Also:: ResourceSparseApplyAdadelta

sparseApplyProximalGradientDescent

public <T,U extends Number> SparseApplyProximalGradientDescent<T> sparseApplyProximalGradientDescent(Operand<T> var,
                                                                                                     Operand<T> alpha,
                                                                                                     Operand<T> l1,
                                                                                                     Operand<T> l2,
                                                                                                     Operand<T> grad,
                                                                                                     Operand<U> indices,
                                                                                                     SparseApplyProximalGradientDescent.Options... options)

Builds an SparseApplyProximalGradientDescent operation

Parameters:: var - Should be from a Variable().; alpha - Scaling factor. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; options - carries optional attributes values
Returns:: a new instance of SparseApplyProximalGradientDescent
See Also:: SparseApplyProximalGradientDescent

resourceApplyGradientDescent

public <T> ResourceApplyGradientDescent resourceApplyGradientDescent(Operand<?> var,
                                                                     Operand<T> alpha,
                                                                     Operand<T> delta,
                                                                     ResourceApplyGradientDescent.Options... options)

Builds an ResourceApplyGradientDescent operation

Parameters:: var - Should be from a Variable().; alpha - Scaling factor. Must be a scalar.; delta - The change.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyGradientDescent
See Also:: ResourceApplyGradientDescent

sparseApplyAdadelta

public <T,U extends Number> SparseApplyAdadelta<T> sparseApplyAdadelta(Operand<T> var,
                                                                       Operand<T> accum,
                                                                       Operand<T> accumUpdate,
                                                                       Operand<T> lr,
                                                                       Operand<T> rho,
                                                                       Operand<T> epsilon,
                                                                       Operand<T> grad,
                                                                       Operand<U> indices,
                                                                       SparseApplyAdadelta.Options... options)

Builds an SparseApplyAdadelta operation

Parameters:: var -; accum - Should be from a Variable().; accumUpdate - : Should be from a Variable().; lr - Learning rate. Must be a scalar.; rho - Decay factor. Must be a scalar.; epsilon - Constant factor. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; options - carries optional attributes values
Returns:: a new instance of SparseApplyAdadelta
See Also:: SparseApplyAdadelta

resourceApplyMomentum

public <T> ResourceApplyMomentum resourceApplyMomentum(Operand<?> var,
                                                       Operand<?> accum,
                                                       Operand<T> lr,
                                                       Operand<T> grad,
                                                       Operand<T> momentum,
                                                       ResourceApplyMomentum.Options... options)

Builds an ResourceApplyMomentum operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; grad - The gradient.; momentum - Momentum. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyMomentum
See Also:: ResourceApplyMomentum

applyRmsProp

public <T> ApplyRmsProp<T> applyRmsProp(Operand<T> var,
                                        Operand<T> ms,
                                        Operand<T> mom,
                                        Operand<T> lr,
                                        Operand<T> rho,
                                        Operand<T> momentum,
                                        Operand<T> epsilon,
                                        Operand<T> grad,
                                        ApplyRmsProp.Options... options)

Builds an ApplyRmsProp operation

Parameters:: var - Should be from a Variable().; ms - Should be from a Variable().; mom - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; rho - Decay rate. Must be a scalar.; momentum -; epsilon - Ridge term. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ApplyRmsProp
See Also:: ApplyRmsProp

resourceSparseApplyProximalAdagrad

public <T,U extends Number> ResourceSparseApplyProximalAdagrad resourceSparseApplyProximalAdagrad(Operand<?> var,
                                                                                                  Operand<?> accum,
                                                                                                  Operand<T> lr,
                                                                                                  Operand<T> l1,
                                                                                                  Operand<T> l2,
                                                                                                  Operand<T> grad,
                                                                                                  Operand<U> indices,
                                                                                                  ResourceSparseApplyProximalAdagrad.Options... options)

Builds an ResourceSparseApplyProximalAdagrad operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Learning rate. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; options - carries optional attributes values
Returns:: a new instance of ResourceSparseApplyProximalAdagrad
See Also:: ResourceSparseApplyProximalAdagrad

accumulatorTakeGradient

public <T> AccumulatorTakeGradient<T> accumulatorTakeGradient(Operand<String> handle,
                                                              Operand<Integer> numRequired,
                                                              Class<T> dtype)

Builds an AccumulatorTakeGradient operation

Parameters:: handle - The handle to an accumulator.; numRequired - Number of gradients required before we return an aggregate.; dtype - The data type of accumulated gradients. Needs to correspond to the type
Returns:: a new instance of AccumulatorTakeGradient
See Also:: AccumulatorTakeGradient

generateVocabRemapping

public GenerateVocabRemapping generateVocabRemapping(Operand<String> newVocabFile,
                                                     Operand<String> oldVocabFile,
                                                     Long newVocabOffset,
                                                     Long numNewVocab,
                                                     GenerateVocabRemapping.Options... options)

Builds an GenerateVocabRemapping operation

Parameters:: newVocabFile - Path to the new vocab file.; oldVocabFile - Path to the old vocab file.; newVocabOffset - How many entries into the new vocab file to start reading.; numNewVocab - Number of entries in the new vocab file to remap.; options - carries optional attributes values
Returns:: a new instance of GenerateVocabRemapping
See Also:: GenerateVocabRemapping

resourceSparseApplyCenteredRmsProp

public <T,U extends Number> ResourceSparseApplyCenteredRmsProp resourceSparseApplyCenteredRmsProp(Operand<?> var,
                                                                                                  Operand<?> mg,
                                                                                                  Operand<?> ms,
                                                                                                  Operand<?> mom,
                                                                                                  Operand<T> lr,
                                                                                                  Operand<T> rho,
                                                                                                  Operand<T> momentum,
                                                                                                  Operand<T> epsilon,
                                                                                                  Operand<T> grad,
                                                                                                  Operand<U> indices,
                                                                                                  ResourceSparseApplyCenteredRmsProp.Options... options)

Builds an ResourceSparseApplyCenteredRmsProp operation

Parameters:: var - Should be from a Variable().; mg - Should be from a Variable().; ms - Should be from a Variable().; mom - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; rho - Decay rate. Must be a scalar.; momentum -; epsilon - Ridge term. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var, ms and mom.; options - carries optional attributes values
Returns:: a new instance of ResourceSparseApplyCenteredRmsProp
See Also:: ResourceSparseApplyCenteredRmsProp

sparseApplyProximalAdagrad

public <T,U extends Number> SparseApplyProximalAdagrad<T> sparseApplyProximalAdagrad(Operand<T> var,
                                                                                     Operand<T> accum,
                                                                                     Operand<T> lr,
                                                                                     Operand<T> l1,
                                                                                     Operand<T> l2,
                                                                                     Operand<T> grad,
                                                                                     Operand<U> indices,
                                                                                     SparseApplyProximalAdagrad.Options... options)

Builds an SparseApplyProximalAdagrad operation

Parameters:: var - Should be from a Variable().; accum - Should be from a Variable().; lr - Learning rate. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; grad - The gradient.; indices - A vector of indices into the first dimension of var and accum.; options - carries optional attributes values
Returns:: a new instance of SparseApplyProximalAdagrad
See Also:: SparseApplyProximalAdagrad

accumulatorApplyGradient

public <T> AccumulatorApplyGradient accumulatorApplyGradient(Operand<String> handle,
                                                             Operand<Long> localStep,
                                                             Operand<T> gradient)

Builds an AccumulatorApplyGradient operation

Parameters:: handle - The handle to a accumulator.; localStep - The local_step value at which the gradient was computed.; gradient - A tensor of the gradient to be accumulated.
Returns:: a new instance of AccumulatorApplyGradient
See Also:: AccumulatorApplyGradient

resourceApplyPowerSign

public <T> ResourceApplyPowerSign resourceApplyPowerSign(Operand<?> var,
                                                         Operand<?> m,
                                                         Operand<T> lr,
                                                         Operand<T> logbase,
                                                         Operand<T> signDecay,
                                                         Operand<T> beta,
                                                         Operand<T> grad,
                                                         ResourceApplyPowerSign.Options... options)

Builds an ResourceApplyPowerSign operation

Parameters:: var - Should be from a Variable().; m - Should be from a Variable().; lr - Scaling factor. Must be a scalar.; logbase - Must be a scalar.; signDecay - Must be a scalar.; beta - Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyPowerSign
See Also:: ResourceApplyPowerSign

conditionalAccumulator

public <T> ConditionalAccumulator conditionalAccumulator(Class<T> dtype,
                                                         Shape shape,
                                                         ConditionalAccumulator.Options... options)

Builds an ConditionalAccumulator operation

Parameters:: dtype - The type of the value being accumulated.; shape - The shape of the values, can be [], in which case shape is unknown.; options - carries optional attributes values
Returns:: a new instance of ConditionalAccumulator
See Also:: ConditionalAccumulator

sdcaFprint
```
public SdcaFprint sdcaFprint(Operand<String> input)
```
Builds an SdcaFprint operation

Parameters:

input - vector of strings to compute fingerprints on.

Returns:

a new instance of SdcaFprint

See Also:

SdcaFprint

applyAdagradDa

public <T> ApplyAdagradDa<T> applyAdagradDa(Operand<T> var,
                                            Operand<T> gradientAccumulator,
                                            Operand<T> gradientSquaredAccumulator,
                                            Operand<T> grad,
                                            Operand<T> lr,
                                            Operand<T> l1,
                                            Operand<T> l2,
                                            Operand<Long> globalStep,
                                            ApplyAdagradDa.Options... options)

Builds an ApplyAdagradDa operation

Parameters:: var - Should be from a Variable().; gradientAccumulator - Should be from a Variable().; gradientSquaredAccumulator - Should be from a Variable().; grad - The gradient.; lr - Scaling factor. Must be a scalar.; l1 - L1 regularization. Must be a scalar.; l2 - L2 regularization. Must be a scalar.; globalStep - Training step number. Must be a scalar.; options - carries optional attributes values
Returns:: a new instance of ApplyAdagradDa
See Also:: ApplyAdagradDa

saveSlices
```
public SaveSlices saveSlices(Operand<String> filename,
                             Operand<String> tensorNames,
                             Operand<String> shapesAndSlices,
                             Iterable<Operand<?>> data)
```
Builds an SaveSlices operation

Parameters:

filename - Must have a single element. The name of the file to which we write the

tensorNames - Shape `[N]`. The names of the tensors to be saved.

shapesAndSlices - Shape `[N]`. The shapes and slice specifications to use when

data - `N` tensors to save.

Returns:

a new instance of SaveSlices

See Also:

SaveSlices

mergeV2Checkpoints

public MergeV2Checkpoints mergeV2Checkpoints(Operand<String> checkpointPrefixes,
                                             Operand<String> destinationPrefix,
                                             MergeV2Checkpoints.Options... options)

Builds an MergeV2Checkpoints operation

Parameters:: checkpointPrefixes - prefixes of V2 checkpoints to merge.; destinationPrefix - scalar. The desired final prefix. Allowed to be the same; options - carries optional attributes values
Returns:: a new instance of MergeV2Checkpoints
See Also:: MergeV2Checkpoints

resourceApplyAdam

public <T> ResourceApplyAdam resourceApplyAdam(Operand<?> var,
                                               Operand<?> m,
                                               Operand<?> v,
                                               Operand<T> beta1Power,
                                               Operand<T> beta2Power,
                                               Operand<T> lr,
                                               Operand<T> beta1,
                                               Operand<T> beta2,
                                               Operand<T> epsilon,
                                               Operand<T> grad,
                                               ResourceApplyAdam.Options... options)

Builds an ResourceApplyAdam operation

Parameters:: var - Should be from a Variable().; m - Should be from a Variable().; v - Should be from a Variable().; beta1Power - Must be a scalar.; beta2Power - Must be a scalar.; lr - Scaling factor. Must be a scalar.; beta1 - Momentum factor. Must be a scalar.; beta2 - Momentum factor. Must be a scalar.; epsilon - Ridge term. Must be a scalar.; grad - The gradient.; options - carries optional attributes values
Returns:: a new instance of ResourceApplyAdam
See Also:: ResourceApplyAdam

tileGrad

public <T> TileGrad<T> tileGrad(Operand<T> input,
                                Operand<Integer> multiples)

Builds an TileGrad operation

Parameters:: input -; multiples -
Returns:: a new instance of TileGrad
See Also:: TileGrad

Class TrainOps