object DivStrategy extends PartitionStrategy with Product with Serializable

Definition Classes: Embedding

object MeanCombiner extends Combiner with Product with Serializable

Definition Classes: Embedding

object ModStrategy extends PartitionStrategy with Product with Serializable

Definition Classes: Embedding

object SumCombiner extends Combiner with Product with Serializable

Definition Classes: Embedding

object SumSqrtNCombiner extends Combiner with Product with Serializable

Definition Classes: Embedding

object ReflectivePadding extends PaddingMode

Definition Classes: Manipulation

object SymmetricPadding extends PaddingMode

Definition Classes: Manipulation

final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

val AbortedException: core.exception.AbortedException.type

Definition Classes: API

val AlreadyExistsException: core.exception.AlreadyExistsException.type

Definition Classes: API

val AttentionWrapperCell: ops.rnn.attention.AttentionWrapperCell.type

Definition Classes: API

val BahdanauAttention: ops.rnn.attention.BahdanauAttention.type

Definition Classes: API

val BasicDecoder: ops.seq2seq.decoders.BasicDecoder.type

Definition Classes: API

val BasicLSTMCell: ops.rnn.cell.BasicLSTMCell.type

Definition Classes: API

val BasicRNNCell: ops.rnn.cell.BasicRNNCell.type

Definition Classes: API

val BeamSearchDecoder: ops.seq2seq.decoders.BeamSearchDecoder.type

Definition Classes: API

val CancelledException: core.exception.CancelledException.type

Definition Classes: API

val CheckpointNotFoundException: core.exception.CheckpointNotFoundException.type

Definition Classes: API

def ConstantInitializer[T](value: ops.Output[T])(implicit arg0: core.types.TF[T]): Initializer

Definition Classes: API

def ConstantInitializer[T](value: tensors.Tensor[T])(implicit arg0: core.types.TF[T]): Initializer

Definition Classes: API

val CreateNewVariableOnly: CreateNewOnly.type

Definition Classes: API

val DataLossException: core.exception.DataLossException.type

Definition Classes: API

val DeadlineExceededException: core.exception.DeadlineExceededException.type

Definition Classes: API

val DeviceWrapper: ops.rnn.cell.DeviceWrapper.type

Definition Classes: API

val DropoutWrapper: ops.rnn.cell.DropoutWrapper.type

Definition Classes: API

val FailedPreconditionException: core.exception.FailedPreconditionException.type

Definition Classes: API

val GRUCell: ops.rnn.cell.GRUCell.type

Definition Classes: API

val GlorotNormalInitializer: ops.variables.GlorotNormalInitializer.type

Definition Classes: API

val GlorotUniformInitializer: ops.variables.GlorotUniformInitializer.type

Definition Classes: API

val GraphMismatchException: core.exception.GraphMismatchException.type

Definition Classes: API

val HashTable: ops.lookup.HashTable.type

Definition Classes: API

val IDLookupTableWithHashBuckets: ops.lookup.IDLookupTableWithHashBuckets.type

Definition Classes: API

val IllegalNameException: core.exception.IllegalNameException.type

Definition Classes: API

val InternalException: core.exception.InternalException.type

Definition Classes: API

val InvalidArgumentException: core.exception.InvalidArgumentException.type

Definition Classes: API

val InvalidDataTypeException: core.exception.InvalidDataTypeException.type

Definition Classes: API

val InvalidDeviceException: core.exception.InvalidDeviceException.type

Definition Classes: API

val InvalidIndexerException: core.exception.InvalidIndexerException.type

Definition Classes: API

val InvalidShapeException: core.exception.InvalidShapeException.type

Definition Classes: API

val LSTMCell: ops.rnn.cell.LSTMCell.type

Definition Classes: API

val LSTMState: ops.rnn.cell.LSTMState.type

Definition Classes: API

def LSTMTuple[T](output: ops.Output[T], state: LSTMState[T]): LSTMTuple[T]

Definition Classes: API

val LookupTableTensorInitializer: ops.lookup.LookupTableTensorInitializer.type

Definition Classes: API

val LookupTableTextFileInitializer: ops.lookup.LookupTableTextFileInitializer.type

Definition Classes: API

val LuongAttention: ops.rnn.attention.LuongAttention.type

Definition Classes: API

val NotFoundException: core.exception.NotFoundException.type

Definition Classes: API

val OnesInitializer: ops.variables.OnesInitializer.type

Definition Classes: API

val OpBuilderUsedException: core.exception.OpBuilderUsedException.type

Definition Classes: API

val OutOfRangeException: core.exception.OutOfRangeException.type

Definition Classes: API

val PermissionDeniedException: core.exception.PermissionDeniedException.type

Definition Classes: API

val RNNTuple: Tuple.type

Definition Classes: API

val RandomNormalInitializer: ops.variables.RandomNormalInitializer.type

Definition Classes: API

val RandomTruncatedNormalInitializer: ops.variables.RandomTruncatedNormalInitializer.type

Definition Classes: API

val RandomUniformInitializer: ops.variables.RandomUniformInitializer.type

Definition Classes: API

val ResidualWrapper: ops.rnn.cell.ResidualWrapper.type

Definition Classes: API

val ResourceExhaustedException: core.exception.ResourceExhaustedException.type

Definition Classes: API

val ReuseExistingVariableOnly: ReuseExistingOnly.type

Definition Classes: API

val ReuseOrCreateNewVariable: ReuseOrCreateNew.type

Definition Classes: API

val Saver: ops.variables.Saver.type

Definition Classes: API

val ShapeMismatchException: core.exception.ShapeMismatchException.type

Definition Classes: API

val StackedCell: ops.rnn.cell.StackedCell.type

Definition Classes: API

val TextFileColumn: ops.lookup.TextFileColumn.type

Definition Classes: API

val TextFileLineNumber: ops.lookup.TextFileLineNumber.type

Definition Classes: API

val TextFileWholeLine: ops.lookup.TextFileWholeLine.type

Definition Classes: API

val Timeline: core.client.Timeline.type

Definition Classes: API

val UnauthenticatedException: core.exception.UnauthenticatedException.type

Definition Classes: API

val UnavailableException: core.exception.UnavailableException.type

Definition Classes: API

val UnimplementedException: core.exception.UnimplementedException.type

Definition Classes: API

val UnknownException: core.exception.UnknownException.type

Definition Classes: API

val VariableScope: ops.variables.VariableScope.type

Definition Classes: API

val VariableStore: ops.variables.VariableStore.type

Definition Classes: API

val VarianceScalingInitializer: ops.variables.VarianceScalingInitializer.type

Definition Classes: API

val ZerosInitializer: ops.variables.ZerosInitializer.type

Definition Classes: API

def abs[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Abs")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def absGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def accumulateN[T](inputs: Seq[ops.Output[T]], shape: core.Shape = null, name: String = "AccumulateN")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[T]

Definition Classes: Math
Annotations: @throws( ... )

def accumulateNGradient[T](op: ops.Op[Seq[ops.Output[T]], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): Seq[ops.Output[T]]

Attributes: protected
Definition Classes: Math

def acos[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Acos")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def acosGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def acosh[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "ACosh")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def acoshGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def add[T](x: ops.Output[T], y: ops.Output[T], name: String = "Add")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def addBias[T](value: ops.Output[T], bias: ops.Output[T], cNNDataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "AddBias")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[T]

Definition Classes: NN

def addBiasGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: NN

def addBiasHessian[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def addGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def addN[T](inputs: Seq[ops.Output[T]], name: String = "AddN")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[T]

Definition Classes: Math

def addNGradient[T](op: ops.Op[Seq[ops.Output[T]], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): Seq[ops.Output[T]]

Attributes: protected
Definition Classes: Math

def all[I](input: ops.Output[Boolean], axes: ops.Output[I] = null, keepDims: Boolean = false, name: String = "All")(implicit arg0: IntDefault[I], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[Boolean]

Definition Classes: Math

def angleDouble[OL[A] <: ops.OutputLike[A]](input: OL[core.types.ComplexDouble], name: String = "Angle")(implicit ev: Aux[OL, core.types.ComplexDouble]): OL[Double]

Definition Classes: Math

def angleFloat[OL[A] <: ops.OutputLike[A]](input: OL[core.types.ComplexFloat], name: String = "Angle")(implicit ev: Aux[OL, core.types.ComplexFloat]): OL[Float]

Definition Classes: Math

def any[I](input: ops.Output[Boolean], axes: ops.Output[I] = null, keepDims: Boolean = false, name: String = "Any")(implicit arg0: IntDefault[I], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[Boolean]

Definition Classes: Math

def approximatelyEqual[T](x: ops.Output[T], y: ops.Output[T], tolerance: Float = 0.00001f, name: String = "ApproximatelyEqual")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[Boolean]

Definition Classes: Math

def argmax[T, I, R](input: ops.Output[T], axes: ops.Output[I], outputDataType: core.types.DataType[R], name: String = "ArgMax")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I], arg4: core.types.TF[R]): ops.Output[R]

Definition Classes: Math

def argmin[T, I, R](input: ops.Output[T], axes: ops.Output[I], outputDataType: core.types.DataType[R], name: String = "ArgMin")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I], arg4: core.types.TF[R]): ops.Output[R]

Definition Classes: Math

final def asInstanceOf[T0]: T0

Definition Classes: Any

def asin[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Asin")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def asinGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def asinh[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "ASinh")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def asinhGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def assert(condition: ops.Output[Boolean], data: Seq[ops.Output[Any]], summarize: Int = 3, name: String = "Assert"): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertAtMostNTrue(predicates: Seq[ops.Output[Boolean]], n: Int, message: ops.Output[String] = null, summarize: Int = 3, name: String = "AssertAtMostNTrue"): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertEqual[T](x: ops.Output[T], y: ops.Output[T], message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertEqual")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertGreater[T](x: ops.Output[T], y: ops.Output[T], message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertGreater")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertGreaterEqual[T](x: ops.Output[T], y: ops.Output[T], message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertGreaterEqual")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertLess[T](x: ops.Output[T], y: ops.Output[T], message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertLess")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertLessEqual[T](x: ops.Output[T], y: ops.Output[T], message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertLessEqual")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertNear[T](x: ops.Output[T], y: ops.Output[T], relTolerance: ops.Output[Float] = 0.00001f, absTolerance: ops.Output[Float] = 0.00001f, message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertNear")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertNegative[T](input: ops.Output[T], message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertNegative")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertNonNegative[T](input: ops.Output[T], message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertNonNegative")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertNonPositive[T](input: ops.Output[T], message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertNonPositive")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertNoneEqual[T](x: ops.Output[T], y: ops.Output[T], message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertNoneEqual")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def assertPositive[T](input: ops.Output[T], message: ops.Output[String] = null, data: Seq[ops.Output[Any]] = null, summarize: Int = 3, name: String = "AssertPositive")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Op[Seq[ops.Output[Any]], Unit]

Definition Classes: Checks

def atan[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Atan")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def atan2[T](x: ops.Output[T], y: ops.Output[T], name: String = "ATan2")(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): ops.Output[T]

Definition Classes: Math

def atan2Gradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def atanGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def atanh[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "ATanh")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def atanhGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def batchMatmulGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def batchNormalization[T](x: ops.Output[T], mean: ops.Output[T], variance: ops.Output[T], offset: Option[ops.Output[T]] = None, scale: Option[ops.Output[T]] = None, epsilon: ops.Output[T], name: String = "BatchNormalization")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: NN

def batchToSpace[T, I](input: ops.Output[T], blockSize: Int, crops: ops.Output[I], name: String = "BatchToSpace")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def batchToSpaceND[T, I1, I2](input: ops.Output[T], blockShape: ops.Output[I1], crops: ops.Output[I2], name: String = "BatchToSpaceND")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I1], arg2: core.types.IsIntOrLong[I1], arg3: core.types.TF[I2], arg4: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Manipulation

def batchToSpaceNDGradient[T, I1, I2](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[I2]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I1], arg2: core.types.IsIntOrLong[I1], arg3: core.types.TF[I2], arg4: core.types.IsIntOrLong[I2]): (ops.Output[T], ops.Output[I1], ops.Output[I2])

Attributes: protected
Definition Classes: Manipulation

def bidirectionalDynamicRNN[Out, State, OutShape, StateShape](cellFw: ops.rnn.cell.RNNCell[Out, State, OutShape, StateShape], cellBw: ops.rnn.cell.RNNCell[Out, State, OutShape, StateShape], input: Out, initialStateFw: Option[State] = None, initialStateBw: Option[State] = None, timeMajor: Boolean = false, parallelIterations: Int = 32, swapMemory: Boolean = false, sequenceLengths: ops.Output[Int] = null, name: String = "RNN")(implicit arg0: OutputStructure[Out], arg1: OutputStructure[State], evZeroOut: Aux[Out, OutShape], evZeroState: Aux[State, StateShape]): (Tuple[Out, State], Tuple[Out, State])

Definition Classes: RNN
Annotations: @throws( ... )

def binCount[T](input: ops.Output[Int], dataType: core.types.DataType[T], weights: ops.Output[T] = null, minLength: ops.Output[Int] = null, maxLength: ops.Output[Int] = null, name: String = "BinCount")(implicit arg0: core.types.TF[T], arg1: core.types.IsIntOrLongOrFloatOrDouble[T]): ops.Output[T]

Definition Classes: Math

def booleanMask[T](input: ops.Output[T], mask: ops.Output[Boolean], name: String = "BooleanMask")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Masking

def broadcastGradientArguments[I](shape1: ops.Output[I], shape2: ops.Output[I], name: String = "BroadcastGradientArguments")(implicit arg0: core.types.TF[I], arg1: core.types.IsIntOrLong[I]): (ops.Output[I], ops.Output[I])

Definition Classes: Basic

def broadcastShapeDynamic[I](shape1: ops.Output[I], shape2: ops.Output[I], name: String = "BroadcastShape")(implicit arg0: core.types.TF[I], arg1: core.types.IsIntOrLong[I]): ops.Output[I]

Definition Classes: Basic

def broadcastTo[T, I](value: ops.Output[T], shape: ops.Output[I], name: String = "BroadcastTo")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Basic

def bucketize[T](input: ops.Output[T], boundaries: Seq[Float], name: String = "Bucketize")(implicit arg0: core.types.TF[T], arg1: core.types.IsIntOrLongOrFloatOrDouble[T]): ops.Output[T]

Definition Classes: Math

def callback[IT, IV, OT, OV, OD](function: (IV) ⇒ OV, input: IT, outputDataType: OD, stateful: Boolean = true, name: String = "Callback")(implicit arg0: OutputStructure[IT], evOutputToTensorI: Aux[IT, IV], evTensorToOutputO: Aux[OV, OT], evOutputToDataType: Aux[OT, OD]): OT

Definition Classes: Callback

def cases[T](predicateFnPairs: Seq[(ops.Output[Boolean], () ⇒ T)], default: () ⇒ T, exclusive: Boolean = false, name: String = "Cases")(implicit evCondArgT: CondArg[T]): T

Definition Classes: ControlFlow
Annotations: @throws( ... )

def castGradient[T, R](op: ops.Op[ops.Output[T], ops.Output[R]], outputGradient: ops.Output[R])(implicit arg0: core.types.TF[R]): ops.Output[T]

Attributes: protected
Definition Classes: Cast

def ceil[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Ceil")(implicit arg0: core.types.TF[T], arg1: core.types.IsHalfOrFloatOrDouble[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def checkNumerics[T](input: ops.Output[T], message: String = "", name: String = "CheckNumerics")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: Basic

def checkNumericsGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Attributes: protected
Definition Classes: Basic

def clipByAverageNorm[T](input: ops.Output[T], clipNorm: ops.Output[T], name: String = "ClipByAverageNorm")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Clip

def clipByGlobalNorm[T](inputs: Seq[ops.OutputLike[T]], clipNorm: ops.Output[T], globalNorm: ops.Output[T] = null, name: String = "ClipByGlobalNorm")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): (Seq[ops.OutputLike[T]], ops.Output[T])

Definition Classes: Clip

def clipByNorm[T, I](input: ops.Output[T], clipNorm: ops.Output[T], axes: ops.Output[I] = null, name: String = "ClipByNorm")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: IntDefault[I], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Clip

def clipByValue[T](input: ops.Output[T], clipValueMin: ops.Output[T], clipValueMax: ops.Output[T], name: String = "ClipByValue")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Clip

def clipByValueGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Clip

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @native() @throws( ... )

def colocateWith[R](colocationOps: Set[ops.UntypedOp], ignoreExisting: Boolean = false)(block: ⇒ R): R

Definition Classes: API

def complexDouble(real: ops.Output[Double], imag: ops.Output[Double], name: String = "Complex"): ops.Output[core.types.ComplexDouble]

Definition Classes: Math

def complexDoubleGradient(op: ops.Op[(ops.Output[Double], ops.Output[Double]), ops.Output[core.types.ComplexDouble]], outputGradient: ops.Output[core.types.ComplexDouble]): (ops.Output[Double], ops.Output[Double])

Definition Classes: Math

def complexFloat(real: ops.Output[Float], imag: ops.Output[Float], name: String = "Complex"): ops.Output[core.types.ComplexFloat]

Definition Classes: Math

def complexFloatGradient(op: ops.Op[(ops.Output[Float], ops.Output[Float]), ops.Output[core.types.ComplexFloat]], outputGradient: ops.Output[core.types.ComplexFloat]): (ops.Output[Float], ops.Output[Float])

Definition Classes: Math

def concatenate[T](inputs: Seq[ops.Output[T]], axis: ops.Output[Int] = 0, name: String = "Concatenate")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Manipulation

def concatenateGradient[T](op: ops.Op[(Seq[ops.Output[T]], ops.Output[Int]), ops.Output[T]], outputGradient: ops.OutputLike[T])(implicit arg0: core.types.TF[T]): (Seq[ops.OutputLike[T]], ops.Output[Int])

Attributes: protected
Definition Classes: Manipulation

def cond[T](predicate: ops.Output[Boolean], trueFn: () ⇒ T, falseFn: () ⇒ T, name: String = "Cond")(implicit evCondArgT: CondArg[T]): T

Definition Classes: ControlFlow
Annotations: @throws( ... )

def conjugate[T, OL[A] <: ops.OutputLike[A]](input: OL[T], name: String = "Conjugate")(implicit arg0: core.types.TF[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def conjugateGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def conjugateTransposeGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def constant[T](tensor: tensors.Tensor[T], shape: core.Shape = null, name: String = "Constant"): ops.Output[T]

Definition Classes: Constructors

def conv2D[T](input: ops.Output[T], filter: ops.Output[T], stride1: Long, stride2: Long, padding: ConvPaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, dilations: (Int, Int, Int, Int) = (1, 1, 1, 1), useCuDNNOnGPU: Boolean = true, name: String = "Conv2D")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: NN

def conv2DBackpropFilter[T](input: ops.Output[T], filterSizes: ops.Output[Int], outputGradient: ops.Output[T], stride1: Long, stride2: Long, padding: ConvPaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, dilations: (Int, Int, Int, Int) = (1, 1, 1, 1), useCuDNNOnGPU: Boolean = true, name: String = "Conv2DBackpropFilter")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: NN

def conv2DBackpropInput[T](inputSizes: ops.Output[Int], filter: ops.Output[T], outputGradient: ops.Output[T], stride1: Long, stride2: Long, padding: ConvPaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, dilations: (Int, Int, Int, Int) = (1, 1, 1, 1), useCuDNNOnGPU: Boolean = true, name: String = "Conv2DBackpropInput")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: NN

def conv2DGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: NN

def cos[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Cos")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def cosGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def cosh[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Cosh")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def coshGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def countNonZero[T, I](input: ops.Output[T], axes: ops.Output[I] = null, keepDims: Boolean = false, name: String = "CountNonZero")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T], arg2: IntDefault[I], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[Long]

Definition Classes: Math

def countNonZeroSparse[T, OL[A] <: ops.OutputLike[A]](input: OL[T], name: String = "CountNonZero")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[Long]

Definition Classes: Math

def createWith[R](graph: Graph = null, nameScope: String = null, device: String = "", deviceFunction: Option[(OpSpecification) ⇒ String] = None, colocationOps: Set[ops.UntypedOp] = null, controlDependencies: Set[ops.UntypedOp] = null, attributes: Map[String, Any] = null, container: String = null)(block: ⇒ R): R

Definition Classes: API

def crelu[T](input: ops.Output[T], axis: ops.Output[Int] = -1, name: String = "CReLU")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): ops.Output[T]

Definition Classes: NN

def cross[T](a: ops.Output[T], b: ops.Output[T], name: String = "Cross")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): ops.Output[T]

Definition Classes: Math

def crossGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def cumprod[T, I](input: ops.Output[T], axis: ops.Output[I], exclusive: Boolean = false, reverse: Boolean = false, name: String = "Cumprod")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def cumprodGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Math

def cumsum[T, I](input: ops.Output[T], axis: ops.Output[I], exclusive: Boolean = false, reverse: Boolean = false, name: String = "Cumsum")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def cumsumGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Math

def currentAttributes: Map[String, Any]

Definition Classes: API

def currentColocationOps: Set[ops.UntypedOp]

Definition Classes: API

def currentContainer: String

Definition Classes: API

def currentControlDependencies: Set[ops.UntypedOp]

Definition Classes: API

def currentDevice: String

Definition Classes: API

def currentDeviceFunction: (OpSpecification) ⇒ String

Definition Classes: API

def currentGraph: Graph

Definition Classes: API

def currentGraphRandomSeed(opSeed: Option[Int] = None): (Option[Int], Option[Int])

Definition Classes: API

def currentNameScope: String

Definition Classes: API

def currentVariableGetters: Seq[VariableGetter]

Definition Classes: API

def currentVariableScope: VariableScope

Definition Classes: API

def currentVariableStore: VariableStore

Definition Classes: API

def decodeBase64(input: ops.Output[String], name: String = "DecodeBase64"): ops.Output[String]

Definition Classes: Text

def decodeCSV[T](records: ops.Output[String], recordDefaults: Seq[ops.Output[T]], dataTypes: Seq[core.types.DataType[T]], delimiter: String = ",", useQuoteDelimiters: Boolean = true, name: String = "DecodeCSV")(implicit arg0: core.types.TF[T]): Seq[ops.Output[T]]

Definition Classes: Parsing

def decodeJSONExample(jsonExamples: ops.Output[String], name: String = "DecodeJSONExample"): ops.Output[String]

Definition Classes: Parsing

def decodeRaw[T](bytes: ops.Output[String], littleEndian: Boolean = true, name: String = "DecodeRaw")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Parsing

def decodeTensor[T](data: ops.Output[String], name: String = "DecodeTensor")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Parsing

def deepCopy[T](x: ops.Output[T], name: String = "DeepCopy")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Inplace

def depthToSpace[T](input: ops.Output[T], blockSize: Int, dataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "DepthToSpace")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Manipulation

def depthToSpaceGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): ops.Output[T]

Attributes: protected
Definition Classes: Manipulation
Annotations: @throws( ... )

def device[R](device: String = "", deviceFunction: Option[(OpSpecification) ⇒ String] = None)(block: ⇒ R): R

Definition Classes: API

def diag[T](diagonal: ops.Output[T], name: String = "Diag")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def diagGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def diagPart[T](input: ops.Output[T], name: String = "DiagPart")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def diagPartGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def digamma[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Digamma")(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def digammaGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): ops.Output[T]

Definition Classes: Math

def divide[T](x: ops.Output[T], y: ops.Output[T], name: String = "Divide")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def divideGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def dropout[T, I](input: ops.Output[T], keepProbability: Float, scaleOutput: Boolean = true, noiseShape: ops.Output[I] = null, seed: Option[Int] = None, name: String = "Dropout")(implicit arg0: core.types.TF[T], arg1: core.types.IsHalfOrFloatOrDouble[T], arg2: IntDefault[I], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: NN
Annotations: @throws( ... )

def dynamicDropout[T, I](input: ops.Output[T], keepProbability: ops.Output[T], scaleOutput: Boolean = true, noiseShape: ops.Output[I] = null, seed: Option[Int] = None, name: String = "Dropout")(implicit arg0: core.types.TF[T], arg1: core.types.IsHalfOrFloatOrDouble[T], arg2: IntDefault[I], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: NN

def dynamicPartition[T](data: ops.Output[T], partitions: ops.Output[Int], numberOfPartitions: Int, name: String = "DynamicPartition")(implicit arg0: core.types.TF[T]): Seq[ops.Output[T]]

Definition Classes: DataFlow

def dynamicPartitionGradient[T](op: ops.Op[(ops.Output[T], ops.Output[Int]), Seq[ops.Output[T]]], outputGradient: Seq[ops.Output[T]])(implicit arg0: core.types.TF[T]): (ops.Output[T], ops.Output[Int])

Attributes: protected
Definition Classes: DataFlow

def dynamicRNN[Out, State, OutShape, StateShape](cell: ops.rnn.cell.RNNCell[Out, State, OutShape, StateShape], input: Out, initialState: Option[State] = None, timeMajor: Boolean = false, parallelIterations: Int = 32, swapMemory: Boolean = false, sequenceLengths: ops.Output[Int] = null, name: String = "RNN")(implicit arg0: OutputStructure[Out], arg1: OutputStructure[State], evZeroOut: Aux[Out, OutShape], evZeroState: Aux[State, StateShape]): Tuple[Out, State]

Definition Classes: RNN
Annotations: @throws( ... ) @throws( ... )

def dynamicStitch[T](indices: Seq[ops.Output[Int]], data: Seq[ops.Output[T]], name: String = "DynamicStitch")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: DataFlow

def dynamicStitchGradient[T](op: ops.Op[(Seq[ops.Output[Int]], Seq[ops.Output[T]]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): (Seq[ops.Output[Int]], Seq[ops.Output[T]])

Attributes: protected
Definition Classes: DataFlow

def editDistance[T](hypothesis: ops.SparseOutput[T], truth: ops.SparseOutput[T], normalize: Boolean = true, name: String = "EditDistance")(implicit arg0: core.types.TF[T]): ops.Output[Float]

Definition Classes: Basic

def elu[T, OL[A] <: ops.OutputLike[A]](input: OL[T], name: String = "ELU")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], ev: Aux[OL, T]): OL[T]

Definition Classes: NN

def eluGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def eluHessian[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: NN

def embeddingLookup[T, I](parameters: EmbeddingMap[T], ids: ops.Output[I], partitionStrategy: PartitionStrategy = ModStrategy, transformFn: (ops.Output[T]) ⇒ ops.Output[T] = null, maxNorm: ops.Output[T] = null, name: String = "EmbeddingLookup")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Embedding

def empty[T](shape: ops.Output[Int], initialize: Boolean = false, name: String = "Empty")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Constructors

def emptyLike[T](input: ops.Output[T], initialize: Boolean = false, optimize: Boolean = true, name: String = "EmptyLike")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Constructors

def encodeBase64(input: ops.Output[String], pad: Boolean = false, name: String = "EncodeBase64"): ops.Output[String]

Definition Classes: Text

def encodeTensor[T](tensor: ops.Output[T], name: String = "EncodeTensor")(implicit arg0: core.types.TF[T]): ops.Output[String]

Definition Classes: Parsing

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equal[T](x: ops.Output[T], y: ops.Output[T], name: String = "Equal")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[Boolean]

Definition Classes: Math

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def erf[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Erf")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def erfGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def erfc[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Erfc")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def erfcGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def exp[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Exp")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def expGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def expandDims[T, I](input: ops.Output[T], axis: ops.Output[I], name: String = "ExpandDims")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def expandDimsGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def expm1[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Expm1")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def expm1Gradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def fill[T, I](dataType: core.types.DataType[T], shape: ops.Output[I])(value: ops.Output[T])(implicit arg0: core.types.TF[I], arg1: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Constructors

def fill[T, I](shape: ops.Output[I])(value: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Constructors

def fillGradient[T, I](op: ops.Op[(ops.Output[I], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[I], ops.Output[T])

Attributes: protected
Definition Classes: Constructors

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

def floor[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Floor")(implicit arg0: core.types.TF[T], arg1: core.types.IsHalfOrFloatOrDouble[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def floorMod[T](x: ops.Output[T], y: ops.Output[T], name: String = "FloorMod")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def fusedBatchNormalization[T](x: ops.Output[T], scale: ops.Output[Float], offset: ops.Output[Float], mean: Option[ops.Output[Float]] = None, variance: Option[ops.Output[Float]] = None, epsilon: Float = 0.0001f, dataFormat: CNNDataFormat = NWCFormat, isTraining: Boolean = true, name: String = "FusedBatchNormalization")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): (ops.Output[T], ops.Output[Float], ops.Output[Float], ops.Output[Float], ops.Output[Float])

Definition Classes: NN
Annotations: @throws( ... )

Attributes: protected
Definition Classes: NN

def gather[T, I1, I2](input: ops.Output[T], indices: ops.Output[I1], axis: ops.Output[I2] = null, name: String = "Gather")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I1], arg2: core.types.IsIntOrLong[I1], arg3: IntDefault[I2], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Manipulation

def gatherDropNegatives[T, I](parameters: ops.Output[T], indices: ops.Output[I], zeroClippedIndices: ops.Output[I] = null, isPositive: ops.Output[Boolean] = null)(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I], ops.Output[Boolean])

Attributes: protected
Definition Classes: Math

def gatherGradient[T, I1, I2](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[I2]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I1], arg2: core.types.IsIntOrLong[I1], arg3: core.types.TF[I2], arg4: core.types.IsIntOrLong[I2]): (ops.OutputLike[T], ops.Output[I1], ops.Output[I2])

Attributes: protected
Definition Classes: Manipulation

def gatherND[T, I](input: ops.Output[T], indices: ops.Output[I], name: String = "GatherND")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def gatherNDGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.OutputLike[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native()

def globalNorm[T](inputs: Seq[ops.OutputLike[T]], name: String = "GlobalNorm")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: Clip

def globalVariablesInitializer(name: String = "GlobalVariablesInitializer"): ops.UntypedOp

Definition Classes: API

val gradients: Gradients.type

Definition Classes: API

def greater[T](x: ops.Output[T], y: ops.Output[T], name: String = "Greater")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[Boolean]

Definition Classes: Math

def greaterEqual[T](x: ops.Output[T], y: ops.Output[T], name: String = "GreaterEqual")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[Boolean]

Definition Classes: Math

def group(inputs: Set[ops.UntypedOp], name: String = "Group"): ops.Op[Unit, Unit]

Definition Classes: ControlFlow

def guaranteeConstant[T](input: ops.Output[T], name: String = "GuaranteeConstant"): ops.Output[T]

Definition Classes: Constructors

def hashCode(): Int

Definition Classes: AnyRef → Any
Annotations: @native()

def identity[T, OL[A] <: ops.OutputLike[A]](input: OL[T], name: String = "Identity")(implicit arg0: core.types.TF[T]): OL[T]

Definition Classes: Manipulation

def igamma[T](a: ops.Output[T], x: ops.Output[T], name: String = "Igamma")(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): ops.Output[T]

Definition Classes: Math

def igammaGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def igammac[T](a: ops.Output[T], x: ops.Output[T], name: String = "Igammac")(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): ops.Output[T]

Definition Classes: Math

def igammacGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def imagDouble[OL[A] <: ops.OutputLike[A]](input: OL[core.types.ComplexDouble], name: String = "Imag")(implicit ev: Aux[OL, core.types.ComplexDouble]): OL[Double]

Definition Classes: Math

def imagDoubleGradient(op: ops.Op[ops.Output[core.types.ComplexDouble], ops.Output[Double]], outputGradient: ops.Output[Double]): ops.Output[core.types.ComplexDouble]

Attributes: protected
Definition Classes: Math

def imagFloat[OL[A] <: ops.OutputLike[A]](input: OL[core.types.ComplexFloat], name: String = "Imag")(implicit ev: Aux[OL, core.types.ComplexFloat]): OL[Float]

Definition Classes: Math

def imagFloatGradient(op: ops.Op[ops.Output[core.types.ComplexFloat], ops.Output[Float]], outputGradient: ops.Output[Float]): ops.Output[core.types.ComplexFloat]

Attributes: protected
Definition Classes: Math

def immutableConstant[T](shape: core.Shape, memoryRegionName: String, name: String = "ImmutableConstant")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Constructors

def inTopK[I](predictions: ops.Output[Float], targets: ops.Output[I], k: ops.Output[I], name: String = "InTopK")(implicit arg0: core.types.TF[I], arg1: core.types.IsIntOrLong[I]): ops.Output[Boolean]

Definition Classes: NN

def incompleteBeta[T](a: ops.Output[T], b: ops.Output[T], x: ops.Output[T], name: String = "IncompleteBeta")(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): ops.Output[T]

Definition Classes: Math

def incompleteBetaGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): (ops.Output[T], ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def indexTableFromFile[K](filename: String, keysDataType: core.types.DataType[K], delimiter: String = "\t", vocabularySize: Int = -1, defaultValue: Long = -1L, numOOVBuckets: Int = 0, hashSpecification: HashSpecification = FAST_HASH, name: String = "IndexTableFromFile")(implicit arg0: core.types.TF[K], arg1: core.types.IsStringOrIntOrUInt[K]): ops.lookup.LookupTable[K, Long]

Definition Classes: Lookup

def indexedSlicesMask[T](input: ops.OutputIndexedSlices[T], maskIndices: ops.Output[Int], name: String = "IndexedSlicesMask")(implicit arg0: core.types.TF[T]): ops.OutputIndexedSlices[T]

Definition Classes: Masking

def initializationScope[R](block: ⇒ R): R

Definition Classes: API

def inplaceAdd[T](x: ops.Output[T], i: Option[ops.Output[Int]], v: ops.Output[T], name: String = "InplaceAdd")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Inplace

def inplaceSubtract[T](x: ops.Output[T], i: Option[ops.Output[Int]], v: ops.Output[T], name: String = "InplaceSubtract")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Inplace

def inplaceUpdate[T](x: ops.Output[T], i: Option[ops.Output[Int]], v: ops.Output[T], name: String = "InplaceUpdate")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Inplace

def invertPermutation[I](input: ops.Output[I], name: String = "InvertPermutation")(implicit arg0: core.types.TF[I], arg1: core.types.IsIntOrLong[I]): ops.Output[I]

Definition Classes: Manipulation

def isFinite[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "IsFinite")(implicit arg0: core.types.TF[T], arg1: core.types.IsHalfOrFloatOrDouble[T], ev: Aux[OL, T]): OL[Boolean]

Definition Classes: Math

def isInf[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "IsInf")(implicit arg0: core.types.TF[T], arg1: core.types.IsHalfOrFloatOrDouble[T], ev: Aux[OL, T]): OL[Boolean]

Definition Classes: Math

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def isNaN[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "IsNaN")(implicit arg0: core.types.TF[T], arg1: core.types.IsHalfOrFloatOrDouble[T], ev: Aux[OL, T]): OL[Boolean]

Definition Classes: Math

def l2Loss[T](input: ops.Output[T], name: String = "L2Loss")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: NN

def l2LossGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def l2Normalize[T, I](x: ops.Output[T], axes: ops.Output[I], epsilon: Float = 1e-12f, name: String = "L2Normalize")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: NN

def less[T](x: ops.Output[T], y: ops.Output[T], name: String = "Less")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[Boolean]

Definition Classes: Math

def lessEqual[T](x: ops.Output[T], y: ops.Output[T], name: String = "LessEqual")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[Boolean]

Definition Classes: Math

def linear[T](x: ops.Output[T], weights: ops.Output[T], bias: ops.Output[T] = null, name: String = "Linear")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: NN

def linspace[T, I](start: ops.Output[T], stop: ops.Output[T], numberOfValues: ops.Output[I], name: String = "LinSpace")(implicit arg0: core.types.TF[T], arg1: core.types.IsTruncatedHalfOrFloatOrDouble[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def listDiff[T, I](x: ops.Output[T], y: ops.Output[T], indicesDataType: core.types.DataType[I], name: String = "ListDiff")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Definition Classes: Masking

def localResources: Set[ResourceWrapper]

Definition Classes: Resources

def localResponseNormalization[T](input: ops.Output[T], depthRadius: Int = 5, bias: Float = 1.0f, alpha: Float = 1.0f, beta: Float = 0.5f, name: String = "LocalResponseNormalization")(implicit arg0: core.types.TF[T], arg1: core.types.IsTruncatedHalfOrHalfOrFloat[T]): ops.Output[T]

Definition Classes: NN

def localVariable[T](name: String, shape: core.Shape = null, initializer: VariableInitializer = null, regularizer: VariableRegularizer = null, reuse: Reuse = ReuseOrCreateNew, collections: Set[Key[Variable[Any]]] = Set.empty, cachingDevice: (ops.OpSpecification) ⇒ String = null)(implicit arg0: core.types.TF[T]): Variable[T]

Definition Classes: API

def localVariablesInitializer(name: String = "LocalVariablesInitializer"): ops.UntypedOp

Definition Classes: API

def log[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Log")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def log1p[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Log1p")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def log1pGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def logGamma[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "LogGamma")(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def logGammaGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def logGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def logPoissonLoss[T](logPredictions: ops.Output[T], targets: ops.Output[T], computeFullLoss: Boolean = false, name: String = "LogPoissonLoss")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: NN

def logSigmoid[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "LogSigmoid")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def logSoftmax[T](logits: ops.Output[T], axis: Int = -1, name: String = "LogSoftmax")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: NN

def logSoftmaxGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def logSumExp[T, I](input: ops.Output[T], axes: ops.Output[I] = null, keepDims: Boolean = false, name: String = "LogSumExp")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: IntDefault[I], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def logicalAnd(x: ops.Output[Boolean], y: ops.Output[Boolean], name: String = "LogicalAnd"): ops.Output[Boolean]

Definition Classes: Math

def logicalNot(x: ops.Output[Boolean], name: String = "LogicalNot"): ops.Output[Boolean]

Definition Classes: Math

def logicalOr(x: ops.Output[Boolean], y: ops.Output[Boolean], name: String = "LogicalOr"): ops.Output[Boolean]

Definition Classes: Math

def logicalXOr(x: ops.Output[Boolean], y: ops.Output[Boolean], name: String = "LogicalXOr"): ops.Output[Boolean]

Definition Classes: Math

def lrn[T](input: ops.Output[T], depthRadius: Int = 5, bias: Float = 1.0f, alpha: Float = 1.0f, beta: Float = 0.5f, name: String = "LRN")(implicit arg0: core.types.TF[T], arg1: core.types.IsTruncatedHalfOrHalfOrFloat[T]): ops.Output[T]

Definition Classes: NN

def lrnGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsTruncatedHalfOrHalfOrFloat[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def magnitudeDouble[OL[A] <: ops.OutputLike[A]](x: OL[core.types.ComplexDouble], name: String = "Magnitude")(implicit ev: Aux[OL, core.types.ComplexDouble]): OL[Double]

Definition Classes: Math

def magnitudeDoubleGradient(op: ops.Op[ops.Output[core.types.ComplexDouble], ops.Output[Double]], outputGradient: ops.Output[Double]): ops.Output[core.types.ComplexDouble]

Attributes: protected
Definition Classes: Math

def magnitudeFloat[OL[A] <: ops.OutputLike[A]](x: OL[core.types.ComplexFloat], name: String = "Magnitude")(implicit ev: Aux[OL, core.types.ComplexFloat]): OL[Float]

Definition Classes: Math

def magnitudeFloatGradient(op: ops.Op[ops.Output[core.types.ComplexFloat], ops.Output[Float]], outputGradient: ops.Output[Float]): ops.Output[core.types.ComplexFloat]

Attributes: protected
Definition Classes: Math

def matmul[T](a: ops.Output[T], b: ops.Output[T], transposeA: Boolean = false, transposeB: Boolean = false, conjugateA: Boolean = false, conjugateB: Boolean = false, aIsSparse: Boolean = false, bIsSparse: Boolean = false, name: String = "MatMul")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def matmulGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def matrixBandPart[T, I](input: ops.Output[T], numSubDiagonals: ops.Output[I], numSuperDiagonals: ops.Output[I], name: String = "MatrixBandPart")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def matrixBandPartGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I], ops.Output[I])

Attributes: protected
Definition Classes: Math

def matrixDiag[T](diagonal: ops.Output[T], name: String = "MatrixDiag")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Math

def matrixDiagGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def matrixDiagPart[T](input: ops.Output[T], name: String = "MatrixDiagPart")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Math

def matrixDiagPartGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def matrixSetDiag[T](input: ops.Output[T], diagonal: ops.Output[T], name: String = "MatrixSetDiag")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Math

def matrixSetDiagGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def matrixTranspose[T](input: ops.Output[T], conjugate: Boolean = false, name: String = "MatrixTranspose")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Manipulation
Annotations: @throws( ... )

def max[T, I](input: ops.Output[T], axes: ops.Output[I] = null, keepDims: Boolean = false, name: String = "Max")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: IntDefault[I], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def maxPool[T](input: ops.Output[T], windowSize: ops.Output[Int], strides: ops.Output[Int], padding: ConvPaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "MaxPool")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[T]

Definition Classes: NN

def maxPoolGrad[T](originalInput: ops.Output[T], originalOutput: ops.Output[T], outputGradient: ops.Output[T], windowSize: ops.Output[Int], strides: ops.Output[Int], padding: ConvPaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "MaxPoolGrad")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[T]

Definition Classes: NN

def maxPoolGradGrad[T](originalInput: ops.Output[T], originalOutput: ops.Output[T], outputGradient: ops.Output[T], windowSize: ops.Output[Int], strides: ops.Output[Int], padding: ConvPaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "MaxPoolGradGrad")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[T]

Definition Classes: NN

def maxPoolGradient[T](op: ops.Op[(ops.Output[T], ops.Output[Int], ops.Output[Int]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): (ops.Output[T], ops.Output[Int], ops.Output[Int])

Attributes: protected
Definition Classes: NN

def maxPoolHessian[T](op: ops.Op[(ops.Output[T], ops.Output[T], ops.Output[T], ops.Output[Int], ops.Output[Int]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): (ops.Output[T], ops.Output[T], ops.Output[T], ops.Output[Int], ops.Output[Int])

Attributes: protected
Definition Classes: NN

def maxPoolHessianGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T], ops.Output[T], ops.Output[Int], ops.Output[Int]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): (ops.Output[T], ops.Output[T], ops.Output[T], ops.Output[Int], ops.Output[Int])

Attributes: protected
Definition Classes: NN

def maximum[T](x: ops.Output[T], y: ops.Output[T], name: String = "Maximum")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def maximumGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def mean[T, I](input: ops.Output[T], axes: ops.Output[I] = null, keepDims: Boolean = false, name: String = "Mean")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: IntDefault[I], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def meanGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Math

def meshGrid[T](inputs: Seq[ops.Output[T]], useCartesianIndexing: Boolean = true, name: String = "MeshGrid")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): Seq[ops.Output[T]]

Definition Classes: Basic

def metricVariablesInitializer(name: String = "MetricVariablesInitializer"): ops.UntypedOp

Definition Classes: API

def min[T, I](input: ops.Output[T], axes: ops.Output[I] = null, keepDims: Boolean = false, name: String = "Min")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: IntDefault[I], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def minOrMaxGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Math

def minimum[T](x: ops.Output[T], y: ops.Output[T], name: String = "Minimum")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def minimumGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def mirrorPadGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def mirrorPadHessian[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def mod[T](x: ops.Output[T], y: ops.Output[T], name: String = "Mod")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def modelVariablesInitializer(name: String = "ModelVariablesInitializer"): ops.UntypedOp

Definition Classes: API

def moments[T](input: ops.Output[T], axes: Seq[Int], weights: ops.Output[T] = null, keepDims: Boolean = false, name: String = "Moments")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Definition Classes: Statistics

def momentsFromSufficientStatistics[T](counts: ops.Output[T], meanSS: ops.Output[T], varSS: ops.Output[T], shift: ops.Output[T] = null, name: String = "MomentsFromSufficientStatistics")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Definition Classes: Statistics

def multiply[T](x: ops.Output[T], y: ops.Output[T], name: String = "Multiply")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def multiplyGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def nameScope[R](nameScope: String)(block: ⇒ R): R

Definition Classes: API

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def negate[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Negate")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def negateGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def newStack(maxSize: ops.Output[Int], elementType: core.types.DataType[Any], stackName: String = "", name: String = "NewStack"): ops.Output[core.types.Resource]

Definition Classes: DataFlow

def noOp(name: String = "NoOp"): ops.Op[Unit, Unit]

Definition Classes: ControlFlow

def notEqual[T](x: ops.Output[T], y: ops.Output[T], name: String = "NotEqual")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[Boolean]

Definition Classes: Math

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native()

def oneHot[T, I](indices: ops.Output[I], depth: ops.Output[Int], onValue: ops.Output[T] = null, offValue: ops.Output[T] = null, axis: Int = -1, name: String = "OneHot")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLongOrUByte[I]): ops.Output[T]

Definition Classes: Basic

def ones[T, I](dataType: core.types.DataType[T], shape: ops.Output[I])(implicit arg0: core.types.TF[I], arg1: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Constructors

def ones[T](dataType: core.types.DataType[T], shape: ops.Output[Int]): ops.Output[T]

Definition Classes: Constructors

def ones[T, I](shape: ops.Output[I])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Constructors

def ones[T](shape: ops.Output[Int])(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Constructors

def onesLike[T](input: ops.Output[T], optimize: Boolean = true, name: String = "OnesLike"): ops.Output[T]

Definition Classes: Constructors

def pad[T, I](input: ops.Output[T], paddings: ops.Output[I], mode: PaddingMode = ..., name: String = "Pad")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def padGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I], ops.Output[T])

Attributes: protected
Definition Classes: Manipulation

def parallelStack[T](inputs: Seq[ops.Output[T]], name: String = "ParallelStack")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Manipulation

def placeholder[T](shape: core.Shape = null, name: String = "Placeholder")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Constructors

def placeholderWithDefault[T](default: ops.Output[T], shape: core.Shape, name: String = "PlaceholderWithDefault")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Constructors

def polygamma[T](n: ops.Output[T], x: ops.Output[T], name: String = "Polygamma")(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): ops.Output[T]

Definition Classes: Math

def polygammaGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def pow[T](x: ops.Output[T], y: ops.Output[T], name: String = "Pow")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def powGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def preventGradient[T](input: ops.Output[T], message: String = "", name: String = "PreventGradient")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Basic

def preventGradientGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradients: ops.Output[T])(implicit arg0: core.types.TF[T]): ops.Output[T]

Attributes: protected
Definition Classes: Basic
Annotations: @throws( ... )

def print[T, OL[A] <: ops.OutputLike[A]](input: OL[T], data: Seq[ops.Output[Any]], message: String = "", firstN: Int = -1, summarize: Int = 3, name: String = "Print")(implicit arg0: core.types.TF[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Logging

def printGradient[T](op: ops.Op[(ops.Output[T], Seq[ops.Output[Any]]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): (ops.Output[T], Seq[ops.Output[Any]])

Attributes: protected
Definition Classes: Logging

def prod[T, I](input: ops.Output[T], axes: ops.Output[I] = null, keepDims: Boolean = false, name: String = "Prod")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: IntDefault[I], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def prodGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Definition Classes: Math

def randomNormal[T, I](shape: ops.Output[I], mean: ops.Output[T] = null, standardDeviation: ops.Output[T] = null, seed: Option[Int] = None, name: String = "RandomNormal")(implicit arg0: FloatDefault[T], arg1: core.types.TF[T], arg2: core.types.IsHalfOrFloatOrDouble[T], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Random

def randomShuffle[T](value: ops.Output[T], seed: Option[Int] = None, name: String = "RandomShuffle")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Random

def randomTruncatedNormal[T, I](shape: ops.Output[I], mean: ops.Output[T] = null, standardDeviation: ops.Output[T] = null, seed: Option[Int] = None, name: String = "RandomTruncatedNormal")(implicit arg0: FloatDefault[T], arg1: core.types.TF[T], arg2: core.types.IsHalfOrFloatOrDouble[T], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Random

def randomUniform[T, I](shape: ops.Output[I], minValue: ops.Output[T] = null, maxValue: ops.Output[T] = null, seed: Option[Int] = None, name: String = "RandomUniform")(implicit arg0: FloatDefault[T], arg1: core.types.TF[T], arg2: core.types.IsIntOrLongOrHalfOrFloatOrDouble[T], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Random

def range[T](start: ops.Output[T], limit: ops.Output[T], delta: ops.Output[T] = null, name: String = "Range")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[T]

Definition Classes: Math

def rank[T, OL[A] <: ops.OutputLike[A]](input: OL[T], optimize: Boolean = true, name: String = "Rank")(implicit arg0: core.types.TF[T]): ops.Output[Int]

Definition Classes: Manipulation

def realDivide[T](x: ops.Output[T], y: ops.Output[T], name: String = "RealDivide")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def realDivideGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def realDouble[OL[A] <: ops.OutputLike[A]](input: OL[core.types.ComplexDouble], name: String = "Real")(implicit ev: Aux[OL, core.types.ComplexDouble]): OL[Double]

Definition Classes: Math

def realDoubleGradient(op: ops.Op[ops.Output[core.types.ComplexDouble], ops.Output[Double]], outputGradient: ops.Output[Double]): ops.Output[core.types.ComplexDouble]

Attributes: protected
Definition Classes: Math

def realFloat[OL[A] <: ops.OutputLike[A]](input: OL[core.types.ComplexFloat], name: String = "Real")(implicit ev: Aux[OL, core.types.ComplexFloat]): OL[Float]

Definition Classes: Math

def realFloatGradient(op: ops.Op[ops.Output[core.types.ComplexFloat], ops.Output[Float]], outputGradient: ops.Output[Float]): ops.Output[core.types.ComplexFloat]

Attributes: protected
Definition Classes: Math

def reciprocal[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Reciprocal")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def reciprocalGradient[T](op: ops.Op[ops.OutputLike[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.OutputLike[T]

Attributes: protected
Definition Classes: Math

def reciprocalHessian[T](op: ops.Op[(ops.Output[T], ops.OutputLike[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.OutputLike[T])

Attributes: protected
Definition Classes: Math

def reductionAxes[T, I, OL[A] <: ops.OutputLike[A]](tensor: OL[T], axes: ops.Output[I])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[I]

Attributes: protected
Definition Classes: Math

def regexReplace(input: ops.Output[String], pattern: ops.Output[String], rewrite: ops.Output[String], replaceGlobal: Boolean = true, name: String = "RegexReplace"): ops.Output[String]

Definition Classes: Text

def relu[T](input: ops.Output[T], alpha: Float = 0.0f, name: String = "ReLU")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): ops.Output[T]

Definition Classes: NN

def relu6[T, OL[A] <: ops.OutputLike[A]](input: OL[T], name: String = "ReLU6")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], ev: Aux[OL, T]): OL[T]

Definition Classes: NN

def relu6Gradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def relu6Hessian[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: NN

def reluGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def reluHessian[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: NN

def requiredSpaceToBatchPaddingsAndCrops(inputShape: ops.Output[Int], blockShape: ops.Output[Int], basePaddings: ops.Output[Int] = null, name: String = "RequiredSpaceToBatchPaddings"): (ops.Output[Int], ops.Output[Int])

Definition Classes: Manipulation

def reshape[T, I](input: ops.Output[T], shape: ops.Output[I], name: String = "Reshape")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def reshapeGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def reshapeToInput[T](input: ops.Output[T], gradient: ops.Output[T])(implicit arg0: core.types.TF[T]): ops.Output[T]

Attributes: protected
Definition Classes: Manipulation

def reverse[T, I](input: ops.Output[T], axes: ops.Output[I], name: String = "Reverse")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def reverseGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def reverseSequence[T, I](input: ops.Output[T], sequenceLengths: ops.Output[I], sequenceAxis: Int, batchAxis: Int = 0, name: String = "ReverseSequence")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def reverseSequenceGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def round[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Round")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def roundInt[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "RoundInt")(implicit arg0: core.types.TF[T], arg1: core.types.IsHalfOrFloatOrDouble[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def rsqrt[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Rqsrt")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def rsqrtGradient[T](op: ops.Op[ops.OutputLike[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.OutputLike[T]

Attributes: protected
Definition Classes: Math

def rsqrtHessian[T](op: ops.Op[(ops.Output[T], ops.OutputLike[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.OutputLike[T])

Attributes: protected
Definition Classes: Math

def safeShapeDiv(x: ops.Output[Int], y: ops.Output[Int]): ops.Output[Int]

Attributes: protected
Definition Classes: Math

def saver(saveables: Set[Saveable] = null, reshape: Boolean = false, sharded: Boolean = false, maxToKeep: Int = 5, keepCheckpointEveryNHours: Float = 10000.0f, restoreSequentially: Boolean = false, filename: String = "model", builder: SaverDefBuilder = DefaultSaverDefBuilder, allowEmpty: Boolean = false, writerVersion: WriterVersion = V2, saveRelativePaths: Boolean = false, padGlobalStep: Boolean = false, name: String = "Saver"): Saver

Definition Classes: API

def scalarMul[T, OL[A] <: ops.OutputLike[A]](scalar: ops.Output[T], tensor: OL[T], name: String = "ScalarMul")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def scatterND[T, I](indices: ops.Output[I], updates: ops.Output[T], shape: ops.Output[I], name: String = "ScatterND")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def scatterNDGradient[T, I](op: ops.Op[(ops.Output[I], ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[I], ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def segmentMax[T, I](data: ops.Output[T], segmentIndices: ops.Output[I], name: String = "SegmentMax")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def segmentMean[T, I](data: ops.Output[T], segmentIndices: ops.Output[I], name: String = "SegmentMean")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def segmentMeanGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Math

def segmentMin[T, I](data: ops.Output[T], segmentIndices: ops.Output[I], name: String = "SegmentMin")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def segmentMinOrMaxGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Math

def segmentProd[T, I](data: ops.Output[T], segmentIndices: ops.Output[I], name: String = "SegmentProd")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def segmentSum[T, I](data: ops.Output[T], segmentIndices: ops.Output[I], name: String = "SegmentSum")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def segmentSumGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Math

def select[T](condition: ops.Output[Boolean], x: ops.Output[T], y: ops.Output[T], name: String = "Select")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Math

def selectGradient[T](op: ops.Op[(ops.Output[Boolean], ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): (ops.Output[Boolean], ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def selu[T, OL[A] <: ops.OutputLike[A]](input: OL[T], name: String = "SELU")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], ev: Aux[OL, T]): OL[T]

Definition Classes: NN

def seluGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def seluHessian[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: NN

def sequenceLoss[T, L](logits: ops.Output[T], labels: ops.Output[L], lossFn: (ops.Output[T], ops.Output[L]) ⇒ ops.Output[T], weights: ops.Output[T] = null, averageAcrossTimeSteps: Boolean = true, averageAcrossBatch: Boolean = true, name: String = "SequenceLoss")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T], arg2: core.types.TF[L]): ops.Output[T]

Definition Classes: NN
Annotations: @throws( ... )

def sequenceMask[T](lengths: ops.Output[T], maxLength: ops.Output[T] = null, name: String = "SequenceMask")(implicit arg0: core.types.TF[T], arg1: core.types.IsIntOrUInt[T]): ops.Output[Boolean]

Definition Classes: Masking
Annotations: @throws( ... )

def setCurrentGraphRandomSeed(value: Int): Unit

Definition Classes: API

def setDifference[A, B, T](a: A, b: B, aMinusB: Boolean = true, validateIndices: Boolean = true, name: String = "SetDifference")(implicit ev: Aux[A, B, T], evSupported: core.types.TF[T]): ops.SparseOutput[T]

Definition Classes: Sets

def setIntersection[A, B, T](a: A, b: B, validateIndices: Boolean = true, name: String = "SetIntersection")(implicit ev: Aux[A, B, T], evSupported: core.types.TF[T]): ops.SparseOutput[T]

Definition Classes: Sets

def setSize[T](input: ops.SparseOutput[T], validateIndices: Boolean = true, name: String = "SetSize")(implicit arg0: core.types.TF[T], arg1: core.types.IsIntOrUInt[T]): ops.Output[Int]

Definition Classes: Sets

def setUnion[A, B, T](a: A, b: B, validateIndices: Boolean = true, name: String = "SetUnion")(implicit ev: Aux[A, B, T], evSupported: core.types.TF[T]): ops.SparseOutput[T]

Definition Classes: Sets

def shape[T, OL[A] <: ops.OutputLike[A]](input: OL[T], optimize: Boolean = true, name: String = "Shape")(implicit arg0: core.types.TF[T]): ops.Output[Int]

Definition Classes: Manipulation

def shapeFullySpecifiedAndEqual[T](x: ops.Output[T], y: ops.Output[T], gradient: ops.Output[T])(implicit arg0: core.types.TF[T]): Boolean

Attributes: protected
Definition Classes: Math

def shapeN[T, I](inputs: Seq[ops.Output[T]], dataType: core.types.DataType[I])(implicit arg0: core.types.TF[T], arg1: core.types.IsIntOrLong[I]): Seq[ops.Output[I]]

Definition Classes: Manipulation

def shapeN[T, I](inputs: Seq[ops.Output[T]])(implicit arg0: core.types.TF[T], arg1: IntDefault[I], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): Seq[ops.Output[I]]

Definition Classes: Manipulation

def sharedResources: Set[ResourceWrapper]

Definition Classes: Resources

def sigmoid[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Sigmoid")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def sigmoidCrossEntropy[T](logits: ops.Output[T], labels: ops.Output[T], weights: ops.Output[T] = null, name: String = "SigmoidCrossEntropy")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: NN

def sigmoidGradient[T](op: ops.Op[ops.OutputLike[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.OutputLike[T]

Attributes: protected
Definition Classes: Math

def sigmoidHessian[T](op: ops.Op[(ops.Output[T], ops.OutputLike[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.OutputLike[T])

Attributes: protected
Definition Classes: Math

def sign[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Sign")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def signGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def sin[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Sin")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def sinGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def sinh[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Sinh")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def sinhGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def size[T, OL[A] <: ops.OutputLike[A]](input: OL[T], optimize: Boolean = true, name: String = "Size")(implicit arg0: core.types.TF[T]): ops.Output[Long]

Definition Classes: Manipulation

def sliceGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def softmax[T](logits: ops.Output[T], axis: Int = -1, name: String = "Softmax")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: NN

def softmaxCrossEntropy[T](logits: ops.Output[T], labels: ops.Output[T], axis: Int = -1, name: String = "SoftmaxCrossEntropy")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Definition Classes: NN

def softmaxCrossEntropyGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), (ops.Output[T], ops.Output[T])], outputGradient: (ops.Output[T], ops.Output[T]))(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: NN

def softmaxGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def softmaxHelper[T](logits: ops.Output[T], opType: String, axis: Int = -1, name: String = "Softmax")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def softplus[T, OL[A] <: ops.OutputLike[A]](input: OL[T], name: String = "Softplus")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T], ev: Aux[OL, T]): OL[T]

Definition Classes: NN

def softplusGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def softplusHessian[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: NN

def softsign[T, OL[A] <: ops.OutputLike[A]](input: OL[T], name: String = "Softsign")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T], ev: Aux[OL, T]): OL[T]

Definition Classes: NN

def softsignGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T]): ops.Output[T]

Attributes: protected
Definition Classes: NN

def spaceToBatch[T, I](input: ops.Output[T], blockSize: Int, paddings: ops.Output[I], name: String = "SpaceToBatch")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def spaceToBatchND[T, I1, I2](input: ops.Output[T], blockShape: ops.Output[I1], paddings: ops.Output[I2], name: String = "SpaceToBatchND")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I1], arg2: core.types.IsIntOrLong[I1], arg3: core.types.TF[I2], arg4: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Manipulation

def spaceToBatchNDGradient[T, I1, I2](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[I2]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I1], arg2: core.types.IsIntOrLong[I1], arg3: core.types.TF[I2], arg4: core.types.IsIntOrLong[I2]): (ops.Output[T], ops.Output[I1], ops.Output[I2])

Attributes: protected
Definition Classes: Manipulation

def spaceToDepth[T](input: ops.Output[T], blockSize: Int, dataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "SpaceToDepth")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Manipulation

def spaceToDepthGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): ops.Output[T]

Attributes: protected
Definition Classes: Manipulation
Annotations: @throws( ... )

def sparseEmbeddingLookup[T, I](parameters: EmbeddingMap[T], sparseIds: ops.SparseOutput[I], sparseWeights: ops.SparseOutput[T] = null, partitionStrategy: PartitionStrategy = ModStrategy, combiner: Combiner = SumSqrtNCombiner, maxNorm: ops.Output[T] = null, name: String = "SparseEmbeddingLookup")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Embedding

def sparseMatmulGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def sparsePlaceholder[T](shape: core.Shape = null, name: String = "SparsePlaceholder")(implicit arg0: core.types.TF[T]): ops.SparseOutput[T]

Definition Classes: Constructors

def sparseSegmentMean[T, I1, I2](data: ops.Output[T], indices: ops.Output[I1], segmentIndices: ops.Output[Int], numSegments: ops.Output[I2] = null, name: String = "SparseSegmentMean")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: IntDefault[I2], arg5: core.types.TF[I2], arg6: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Math

def sparseSegmentMeanGradient[T, I1](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[Int]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1]): (ops.Output[T], ops.Output[I1], ops.Output[Int])

Attributes: protected
Definition Classes: Math

def sparseSegmentMeanWithNumSegmentsGradient[T, I1, I2](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[Int], ops.Output[I2]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): (ops.Output[T], ops.Output[I1], ops.Output[Int], ops.Output[I2])

Attributes: protected
Definition Classes: Math

def sparseSegmentSum[T, I1, I2](data: ops.Output[T], indices: ops.Output[I1], segmentIndices: ops.Output[Int], numSegments: ops.Output[I2] = null, name: String = "SparseSegmentSum")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: IntDefault[I2], arg5: core.types.TF[I2], arg6: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Math

def sparseSegmentSumGradient[T, I1](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[Int]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1]): (ops.Output[T], ops.Output[I1], ops.Output[Int])

Attributes: protected
Definition Classes: Math

def sparseSegmentSumSqrtN[T, I1, I2](data: ops.Output[T], indices: ops.Output[I1], segmentIndices: ops.Output[Int], numSegments: ops.Output[I2] = null, name: String = "SparseSegmentSumSqrtN")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: IntDefault[I2], arg5: core.types.TF[I2], arg6: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Math

def sparseSegmentSumSqrtNGradient[T, I1](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[Int]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1]): (ops.Output[T], ops.Output[I1], ops.Output[Int])

Attributes: protected
Definition Classes: Math

def sparseSegmentSumSqrtNWithNumSegmentsGradient[T, I1, I2](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[Int], ops.Output[I2]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): (ops.Output[T], ops.Output[I1], ops.Output[Int], ops.Output[I2])

Attributes: protected
Definition Classes: Math

def sparseSegmentSumWithNumSegmentsGradient[T, I1, I2](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[Int], ops.Output[I2]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): (ops.Output[T], ops.Output[I1], ops.Output[Int], ops.Output[I2])

Attributes: protected
Definition Classes: Math

def sparseSoftmaxCrossEntropy[T, I](logits: ops.Output[T], labels: ops.Output[I], axis: Int = -1, name: String = "SparseSoftmaxCrossEntropy")(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: NN

def sparseSoftmaxCrossEntropyGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), (ops.Output[T], ops.Output[T])], outputGradient: (ops.Output[T], ops.Output[T]))(implicit arg0: core.types.TF[T], arg1: core.types.IsDecimal[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: NN

def split[T, I](input: ops.Output[T], splitSizes: ops.Output[I], axis: ops.Output[Int] = 0, name: String = "Split")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): Seq[ops.Output[T]]

Definition Classes: Manipulation

def splitEvenly[T](input: ops.Output[T], numSplits: Int, axis: ops.Output[Int] = 0, name: String = "Split")(implicit arg0: core.types.TF[T]): Seq[ops.Output[T]]

Definition Classes: Manipulation

def splitEvenlyGradient[T](op: ops.Op[(ops.Output[Int], ops.Output[T]), Seq[ops.Output[T]]], outputGradient: Seq[ops.Output[T]])(implicit arg0: core.types.TF[T]): (ops.Output[Int], ops.Output[T])

Attributes: protected
Definition Classes: Manipulation

def splitGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I], ops.Output[Int]), Seq[ops.Output[T]]], outputGradient: Seq[ops.Output[T]])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I], ops.Output[Int])

Attributes: protected
Definition Classes: Manipulation

def sqrt[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Sqrt")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def sqrtGradient[T](op: ops.Op[ops.OutputLike[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.OutputLike[T]

Attributes: protected
Definition Classes: Math

def sqrtHessian[T](op: ops.Op[(ops.Output[T], ops.OutputLike[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.OutputLike[T])

Attributes: protected
Definition Classes: Math

def square[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Reciprocal")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def squareGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def squaredDifference[T](x: ops.Output[T], y: ops.Output[T], name: String = "SquaredDifference")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def squaredDifferenceGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def squeeze[T](input: ops.Output[T], axes: Seq[Int] = null, name: String = "Squeeze")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Manipulation

def squeezeGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): ops.Output[T]

Attributes: protected
Definition Classes: Manipulation

def stack[T](inputs: Seq[ops.Output[T]], axis: Int = 0, name: String = "Stack")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Manipulation

def stackClose(stackHandle: ops.Output[core.types.Resource], name: String = "StackClose"): ops.Op[ops.Output[core.types.Resource], Unit]

Definition Classes: DataFlow

def stackGradient[T](op: ops.Op[Seq[ops.Output[T]], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T]): Seq[ops.Output[T]]

Attributes: protected
Definition Classes: Manipulation

def stackPop[T](stackHandle: ops.Output[core.types.Resource], elementType: core.types.DataType[T], name: String = "StackPop")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: DataFlow

def stackPush[T](stackHandle: ops.Output[core.types.Resource], element: ops.Output[T], swapMemory: Boolean = false, name: String = "StackPush")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: DataFlow

def stopGradient[T](input: ops.Output[T], name: String = "StopGradient")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Basic

def stridedSlice[T, I](input: ops.Output[T], begin: ops.Output[I], end: ops.Output[I], strides: ops.Output[I] = null, beginMask: Long = 0, endMask: Long = 0, ellipsisMask: Long = 0, newAxisMask: Long = 0, shrinkAxisMask: Long = 0, name: String = "StridedSlice")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def stridedSliceGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I], ops.Output[I], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I], ops.Output[I], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def stridedSliceHessian[T, I](op: ops.Op[(ops.Output[I], ops.Output[I], ops.Output[I], ops.Output[I], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[I], ops.Output[I], ops.Output[I], ops.Output[I], ops.Output[T])

Attributes: protected
Definition Classes: Manipulation

def stringJoin(inputs: Seq[ops.Output[String]], separator: String = "", name: String = "StringJoin"): ops.Output[String]

Definition Classes: Text

def stringSplit(input: ops.Output[String], delimiter: ops.Output[String] = " ", skipEmpty: Boolean = true, name: String = "StringSplit"): ops.SparseOutput[String]

Definition Classes: Text

def stringToHashBucketFast(input: ops.Output[String], numBuckets: Int, name: String = "StringToHashBucketFast"): ops.Output[Long]

Definition Classes: Text

def stringToHashBucketStrong(input: ops.Output[String], numBuckets: Int, key1: Long, key2: Long, name: String = "StringToHashBucketStrong"): ops.Output[Long]

Definition Classes: Text

def stringToNumber[T](data: ops.Output[String], name: String = "StringToNumber")(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Parsing

def subtract[T](x: ops.Output[T], y: ops.Output[T], name: String = "Subtract")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def subtractGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

def sufficientStatistics[T, I](input: ops.Output[T], axes: ops.Output[I], shift: ops.Output[T] = null, keepDims: Boolean = false, name: String = "SufficientStatistics")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[T], ops.Output[T], ops.Output[T])

Definition Classes: Statistics

def sum[T, I](input: ops.Output[T], axes: ops.Output[I] = null, keepDims: Boolean = false, name: String = "Sum")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T], arg2: IntDefault[I], arg3: core.types.TF[I], arg4: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Math

def sumGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Math

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes: AnyRef

def tableInitializers: Set[ops.UntypedOp]

Definition Classes: Lookup

def tan[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Tan")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def tanGradient[T](op: ops.Op[ops.Output[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def tanh[T, OL[A] <: ops.OutputLike[A]](x: OL[T], name: String = "Tanh")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], ev: Aux[OL, T]): OL[T]

Definition Classes: Math

def tanhGradient[T](op: ops.Op[ops.OutputLike[T], ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.OutputLike[T]

Attributes: protected
Definition Classes: Math

def tanhHessian[T](op: ops.Op[(ops.Output[T], ops.OutputLike[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], ops.OutputLike[T])

Attributes: protected
Definition Classes: Math

def tensorDot[T](a: ops.Output[T], b: ops.Output[T], axesA: Seq[Int], axesB: Seq[Int], name: String)(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math
Annotations: @throws( ... )

def tensorDot[T](a: ops.Output[T], b: ops.Output[T], axesA: Seq[Int], axesB: Seq[Int])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math
Annotations: @throws( ... )

def tensorDot[T](a: ops.Output[T], b: ops.Output[T], numAxes: Int, name: String)(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math
Annotations: @throws( ... )

def tensorDot[T](a: ops.Output[T], b: ops.Output[T], numAxes: Int)(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math
Annotations: @throws( ... )

def tensorDotDynamic[T](a: ops.Output[T], b: ops.Output[T], axesA: ops.Output[Int], axesB: ops.Output[Int], name: String = "TensorDot")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math
Annotations: @throws( ... )

def tensorDotDynamic[T](a: ops.Output[T], b: ops.Output[T], axesA: ops.Output[Int], axesB: ops.Output[Int])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math
Annotations: @throws( ... )

def tensorDotDynamic[T](a: ops.Output[T], b: ops.Output[T], numAxes: ops.Output[Int], name: String)(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math
Annotations: @throws( ... )

def tensorDotDynamic[T](a: ops.Output[T], b: ops.Output[T], numAxes: ops.Output[Int])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math
Annotations: @throws( ... )

def tile[T, I](input: ops.Output[T], multiples: ops.Output[I], name: String = "Tile")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def tileGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.OutputLike[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def timestamp(name: String = "Timestamp"): ops.Output[Double]

Definition Classes: Logging

def toString(): String

Definition Classes: AnyRef → Any

def topK[T](input: ops.Output[T], k: ops.Output[Int], sorted: Boolean = true, name: String = "TopK")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): (ops.Output[T], ops.Output[Int])

Definition Classes: NN

def topKGradient[T](op: ops.Op[(ops.Output[T], ops.Output[Int]), (ops.Output[T], ops.Output[Int])], outputGradient: (ops.Output[T], ops.Output[Int]))(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T]): (ops.Output[T], ops.Output[Int])

Attributes: protected
Definition Classes: NN

def trace[T](input: ops.Output[T], name: String = "Trace")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[T]

Definition Classes: Math

def trainableVariablesInitializer(name: String = "TrainableVariablesInitializer"): ops.UntypedOp

Definition Classes: API

def transpose[T, I](input: ops.Output[T], permutation: ops.Output[I] = null, conjugate: Boolean = false, name: String = "Transpose")(implicit arg0: core.types.TF[T], arg1: IntDefault[I], arg2: core.types.TF[I], arg3: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Manipulation

def transposeConjugateToAdjoint[T](tensor: ops.Output[T], transpose: Boolean, conj: Boolean)(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], Boolean)

Attributes: protected
Definition Classes: Math

def transposeConjugateToTranspose[T](tensor: ops.Output[T], transpose: Boolean, conj: Boolean)(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): (ops.Output[T], Boolean)

Attributes: protected
Definition Classes: Math

def transposeGradient[T, I](op: ops.Op[(ops.Output[T], ops.Output[I]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): (ops.Output[T], ops.Output[I])

Attributes: protected
Definition Classes: Manipulation

def truncateDivide[T](x: ops.Output[T], y: ops.Output[T], name: String = "TruncateDivide")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def truncateMod[T](x: ops.Output[T], y: ops.Output[T], name: String = "TruncateMod")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T]): ops.Output[T]

Definition Classes: Math

def tuple[T, OL[A] <: ops.OutputLike[A]](inputs: Seq[OL[T]], controlInputs: Set[ops.UntypedOp] = Set.empty, name: String = "Tuple")(implicit arg0: core.types.TF[T]): Seq[OL[T]]

Definition Classes: ControlFlow

def unique[T, I1, I2](input: ops.Output[T], axis: ops.Output[I1], indicesDataType: core.types.DataType[I2], name: String = "Unique")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I1], arg2: core.types.IsIntOrLong[I1], arg3: core.types.TF[I2], arg4: core.types.IsIntOrLong[I2]): (ops.Output[T], ops.Output[I2])

Definition Classes: Basic

def uniqueWithCounts[T, I1, I2](input: ops.Output[T], axis: ops.Output[I1], indicesDataType: core.types.DataType[I2], name: String = "UniqueWithCounts")(implicit arg0: core.types.TF[T], arg1: core.types.TF[I1], arg2: core.types.IsIntOrLong[I1], arg3: core.types.TF[I2], arg4: core.types.IsIntOrLong[I2]): (ops.Output[T], ops.Output[I2], ops.Output[I2])

Definition Classes: Basic

def unsortedSegmentMax[T, I1, I2](data: ops.Output[T], segmentIndices: ops.Output[I1], segmentsNumber: ops.Output[I2], name: String = "UnsortedSegmentMax")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Math

def unsortedSegmentMean[T, I1, I2](data: ops.Output[T], segmentIndices: ops.Output[I1], segmentsNumber: ops.Output[I2], name: String = "UnsortedSegmentMean")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Math

def unsortedSegmentMin[T, I1, I2](data: ops.Output[T], segmentIndices: ops.Output[I1], segmentsNumber: ops.Output[I2], name: String = "UnsortedSegmentMin")(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Math

def unsortedSegmentMinOrMaxGradient[T, I1, I2](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[I2]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsReal[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): (ops.Output[T], ops.Output[I1], ops.Output[I2])

Attributes: protected
Definition Classes: Math

def unsortedSegmentN[T, I1, I2](data: ops.Output[T], segmentIndices: ops.Output[I1], segmentsNumber: ops.Output[I2], name: String = "UnsortedSegmentN")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): ops.Output[T]

Attributes: protected
Definition Classes: Math

def unsortedSegmentProd[T, I1, I2](data: ops.Output[T], segmentIndices: ops.Output[I1], segmentsNumber: ops.Output[I2], name: String = "UnsortedSegmentProd")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Math

def unsortedSegmentProdGradient[T, I1, I2](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[I2]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): (ops.Output[T], ops.Output[I1], ops.Output[I2])

Attributes: protected
Definition Classes: Math

def unsortedSegmentSqrtN[T, I1, I2](data: ops.Output[T], segmentIndices: ops.Output[I1], segmentsNumber: ops.Output[I2], name: String = "UnsortedSegmentSqrtN")(implicit arg0: core.types.TF[T], arg1: core.types.IsNotQuantized[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Math

def unsortedSegmentSum[T, I1, I2](data: ops.Output[T], segmentIndices: ops.Output[I1], segmentsNumber: ops.Output[I2], name: String = "UnsortedSegmentSum")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): ops.Output[T]

Definition Classes: Math

def unsortedSegmentSumGradient[T, I1, I2](op: ops.Op[(ops.Output[T], ops.Output[I1], ops.Output[I2]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T], arg2: core.types.TF[I1], arg3: core.types.IsIntOrLong[I1], arg4: core.types.TF[I2], arg5: core.types.IsIntOrLong[I2]): (ops.Output[T], ops.Output[I1], ops.Output[I2])

Attributes: protected
Definition Classes: Math

def unstack[T](input: ops.Output[T], number: Int = -1, axis: Int = 0, name: String = "Unstack")(implicit arg0: core.types.TF[T]): Seq[ops.Output[T]]

Definition Classes: Manipulation
Annotations: @throws( ... ) @throws( ... )

def unstackGradient[T](op: ops.Op[ops.Output[T], Seq[ops.Output[T]]], outputGradient: Seq[ops.Output[T]])(implicit arg0: core.types.TF[T]): ops.Output[T]

Attributes: protected
Definition Classes: Manipulation

def updatedVariableScope[R](variableScope: VariableScope = VariableScope.current, reuse: VariableReuse = ReuseOrCreateNewVariable, initializer: VariableInitializer = null, regularizer: VariableRegularizer = null, cachingDevice: (ops.OpSpecification) ⇒ String = null, underlyingGetter: VariableGetter = null, isPure: Boolean = false)(block: ⇒ R): R

Definition Classes: API

def variable[T](name: String, shape: core.Shape = null, initializer: VariableInitializer = null, regularizer: VariableRegularizer = null, trainable: Boolean = true, reuse: Reuse = ReuseOrCreateNew, collections: Set[Key[Variable[Any]]] = Set.empty, cachingDevice: (ops.OpSpecification) ⇒ String = null)(implicit arg0: core.types.TF[T]): Variable[T]

Definition Classes: API

def variableGetter[R](getter: VariableGetter)(block: ⇒ R): R

Definition Classes: API

def variableScope[R](name: String, reuse: VariableReuse = ReuseOrCreateNewVariable, initializer: VariableInitializer = null, regularizer: VariableRegularizer = null, cachingDevice: (ops.OpSpecification) ⇒ String = null, underlyingGetter: VariableGetter = null, isDefaultName: Boolean = false, isPure: Boolean = false)(block: ⇒ R): R

Definition Classes: API

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long, arg1: Int): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @native() @throws( ... )

def where[T](input: ops.Output[T], name: String = "Where")(implicit arg0: core.types.TF[T], arg1: core.types.IsBooleanOrNumeric[T]): ops.Output[Long]

Definition Classes: Masking

def whileLoop[T, S](predicateFn: (T) ⇒ ops.Output[Boolean], bodyFn: (T) ⇒ T, loopVariables: T, shapeInvariants: Option[S] = None, parallelIterations: Int = 10, enableBackPropagation: Boolean = true, swapMemory: Boolean = false, maximumIterations: ops.Output[Int] = null, name: String = "WhileLoop")(implicit evOutputToShape: Aux[T, S]): T

Definition Classes: ControlFlow

def zeros[T, I](dataType: core.types.DataType[T], shape: ops.Output[I])(implicit arg0: core.types.TF[I], arg1: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Constructors

def zeros[T](dataType: core.types.DataType[T], shape: ops.Output[Int]): ops.Output[T]

Definition Classes: Constructors

def zeros[T, I](shape: ops.Output[I])(implicit arg0: core.types.TF[T], arg1: core.types.TF[I], arg2: core.types.IsIntOrLong[I]): ops.Output[T]

Definition Classes: Constructors

def zeros[T](shape: ops.Output[Int])(implicit arg0: core.types.TF[T]): ops.Output[T]

Definition Classes: Constructors

def zerosFraction[T](input: ops.Output[T], name: String = "ZerosFraction")(implicit arg0: core.types.TF[T], arg1: core.types.IsNumeric[T]): ops.Output[Float]

Definition Classes: Math

def zerosLike[T](input: ops.Output[T], optimize: Boolean = true, name: String = "ZerosLike"): ops.Output[T]

Definition Classes: Constructors

def zeta[T](x: ops.Output[T], q: ops.Output[T], name: String = "Zeta")(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): ops.Output[T]

Definition Classes: Math

def zetaGradient[T](op: ops.Op[(ops.Output[T], ops.Output[T]), ops.Output[T]], outputGradient: ops.Output[T])(implicit arg0: core.types.TF[T], arg1: core.types.IsFloatOrDouble[T]): (ops.Output[T], ops.Output[T])

Attributes: protected
Definition Classes: Math

object data extends API

Definition Classes: API

object image extends Image

Definition Classes: API

object learn extends API

object metrics extends API

Definition Classes: API

object summary extends Summary

Definition Classes: API

object train extends API

Definition Classes: API

Packages

tf 

object tf extends API with API

Type Members

Value Members

Deprecated Value Members

Inherited from API

Inherited from API

Inherited from API

Inherited from API

Inherited from API

Inherited from RNN

Inherited from API

Inherited from API

Inherited from API

Inherited from Lookup

Inherited from API

Inherited from ControlFlow

Inherited from API

Inherited from Text

Inherited from Statistics

Inherited from Sets

Inherited from Resources

Inherited from Random

Inherited from Parsing

Inherited from NN

Inherited from Math

Inherited from Logging

Inherited from Embedding

Inherited from DataFlow

Inherited from Clip

Inherited from Checks

Inherited from Cast

Inherited from Callback

Inherited from Basic

Inherited from API

Inherited from Masking

Inherited from Manipulation

Inherited from Inplace

Inherited from Constructors

Inherited from API

Inherited from AnyRef

Inherited from Any

Ungrouped

tf