tf - org.platanios.tensorflow.api.tf

Type Members

type AbortedException = jni.AbortedException

Definition Classes
API
type AlreadyExistsException = jni.AlreadyExistsException

Definition Classes
API
type Attention[AS, ASS] = ops.rnn.attention.Attention[AS, ASS]

Definition Classes
API
type AttentionWrapperCell[S, SS, AS, ASS] = ops.rnn.attention.AttentionWrapperCell[S, SS, AS, ASS]

Definition Classes
API
type BahdanauAttention = ops.rnn.attention.BahdanauAttention

Definition Classes
API
type BasicDecoder[O, OS, S, SS] = ops.seq2seq.decoders.BasicDecoder[O, OS, S, SS]

Definition Classes
API
type BasicLSTMCell = ops.rnn.cell.BasicLSTMCell

Definition Classes
API
type BasicRNNCell = ops.rnn.cell.BasicRNNCell

Definition Classes
API
type BasicTuple = Tuple[ops.Output, ops.Output]

Definition Classes
API
type BeamSearchDecoder[S, SS] = ops.seq2seq.decoders.BeamSearchDecoder[S, SS]

Definition Classes
API
type CancelledException = jni.CancelledException

Definition Classes
API
type CheckpointNotFoundException = core.exception.CheckpointNotFoundException

Definition Classes
API
sealed trait Combiner extends AnyRef

Definition Classes
Embedding
type DataLossException = jni.DataLossException

Definition Classes
API
type DeadlineExceededException = jni.DeadlineExceededException

Definition Classes
API
type Decoder[O, OS, S, SS, DO, DOS, DS, DSS, DFO, DFS] = ops.seq2seq.decoders.Decoder[O, OS, S, SS, DO, DOS, DS, DSS, DFO, DFS]

Definition Classes
API
type DeviceSpecification = core.DeviceSpecification

Definition Classes
API
type DeviceWrapper[O, OS, S, SS] = ops.rnn.cell.DeviceWrapper[O, OS, S, SS]

Definition Classes
API
type DropoutWrapper[O, OS, S, SS] = ops.rnn.cell.DropoutWrapper[O, OS, S, SS]

Definition Classes
API
type FailedPreconditionException = jni.FailedPreconditionException

Definition Classes
API
type GRUCell = ops.rnn.cell.GRUCell

Definition Classes
API
type GraphMismatchException = core.exception.GraphMismatchException

Definition Classes
API
type HashTable = ops.lookup.HashTable

Definition Classes
API
type IDLookupTableWithHashBuckets = ops.lookup.IDLookupTableWithHashBuckets

Definition Classes
API
type IllegalNameException = core.exception.IllegalNameException

Definition Classes
API
type InternalException = jni.InternalException

Definition Classes
API
type InvalidArgumentException = jni.InvalidArgumentException

Definition Classes
API
type InvalidDataTypeException = core.exception.InvalidDataTypeException

Definition Classes
API
type InvalidDeviceException = core.exception.InvalidDeviceException

Definition Classes
API
type InvalidIndexerException = core.exception.InvalidIndexerException

Definition Classes
API
type InvalidShapeException = core.exception.InvalidShapeException

Definition Classes
API
type LSTMCell = ops.rnn.cell.LSTMCell

Definition Classes
API
type LSTMState = ops.rnn.cell.LSTMState

Definition Classes
API
type LSTMTuple = Tuple[ops.Output, LSTMState]

Definition Classes
API
type LookupTable = ops.lookup.LookupTable

Definition Classes
API
type LookupTableInitializer = ops.lookup.LookupTableInitializer

Definition Classes
API
type LookupTableTensorInitializer = ops.lookup.LookupTableTensorInitializer

Definition Classes
API
type LookupTableTextFileInitializer = ops.lookup.LookupTableTextFileInitializer

Definition Classes
API
type LuongAttention = ops.rnn.attention.LuongAttention

Definition Classes
API
type MultiCell[O, OS, S, SS] = ops.rnn.cell.MultiCell[O, OS, S, SS]

Definition Classes
API
type NotFoundException = jni.NotFoundException

Definition Classes
API
type Op = ops.Op

Definition Classes
API
type OpBuilderUsedException = core.exception.OpBuilderUsedException

Definition Classes
API
type OpCreationContext = ops.OpCreationContext

Definition Classes
API
type OpSpecification = ops.OpSpecification

Definition Classes
API
type OutOfRangeException = jni.OutOfRangeException

Definition Classes
API
type Output = ops.Output

Definition Classes
API
type OutputIndexedSlices = ops.OutputIndexedSlices

Definition Classes
API
type OutputLike = ops.OutputLike

Definition Classes
API
sealed trait PaddingMode extends AnyRef

Definition Classes
Basic
sealed trait PartitionStrategy extends AnyRef

Definition Classes
Embedding
type PartitionedVariable = ops.variables.PartitionedVariable

Definition Classes
API
type PermissionDeniedException = jni.PermissionDeniedException

Definition Classes
API
type RNNCell[O, OS, S, SS] = ops.rnn.cell.RNNCell[O, OS, S, SS]

Definition Classes
API
type RNNTuple[O, S] = Tuple[O, S]

Definition Classes
API
type ResidualWrapper[O, OS, S, SS] = ops.rnn.cell.ResidualWrapper[O, OS, S, SS]

Definition Classes
API
type ResourceExhaustedException = jni.ResourceExhaustedException

Definition Classes
API
type Saver = ops.variables.Saver

Definition Classes
API
type ShapeMismatchException = core.exception.ShapeMismatchException

Definition Classes
API
type SparseOutput = ops.SparseOutput

Definition Classes
API
type UnauthenticatedException = jni.UnauthenticatedException

Definition Classes
API
type UnavailableException = jni.UnavailableException

Definition Classes
API
type UnimplementedException = jni.UnimplementedException

Definition Classes
API
type UnknownException = jni.UnknownException

Definition Classes
API
type Variable = ops.variables.Variable

Definition Classes
API
type VariableGetter = ops.variables.Variable.VariableGetter

Definition Classes
API
type VariableInitializer = Initializer

Definition Classes
API
type VariablePartitioner = Partitioner

Definition Classes
API
type VariableRegularizer = Regularizer

Definition Classes
API
type VariableReuse = Reuse

Definition Classes
API
type VariableReuseAllowed = ReuseAllowed

Definition Classes
API
type VariableScope = ops.variables.VariableScope

Definition Classes
API
type VariableStore = ops.variables.VariableStore

Definition Classes
API

Value Members

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(value: ops.Output): Initializer

Definition Classes
API
def ConstantInitializer(value: tensors.Tensor): Initializer

Definition Classes
API
object ConstantPadding extends PaddingMode

Definition Classes
Basic
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
object DivStrategy extends PartitionStrategy with Product with Serializable

Definition Classes
Embedding
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 Gradients: ops.Gradients.type

Definition Classes
API
val GradientsRegistry: Registry.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(output: ops.Output, state: LSTMState): LSTMTuple

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
object MeanCombiner extends Combiner with Product with Serializable

Definition Classes
Embedding
object ModStrategy extends PartitionStrategy with Product with Serializable

Definition Classes
Embedding
val MultiCell: ops.rnn.cell.MultiCell.type

Definition Classes
API
val NotFoundException: core.exception.NotFoundException.type

Definition Classes
API
val OnesInitializer: ops.variables.OnesInitializer.type

Definition Classes
API
val Op: ops.Op.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
object ReflectivePadding extends PaddingMode

Definition Classes
Basic
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
object SumCombiner extends Combiner with Product with Serializable

Definition Classes
Embedding
object SumSqrtNCombiner extends Combiner with Product with Serializable

Definition Classes
Embedding
object SymmetricPadding extends PaddingMode

Definition Classes
Basic
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 <: ops.OutputLike](x: T, name: String = "Abs")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def acos[T](x: T, name: String = "Acos")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def acosh[T](x: T, name: String = "ACosh")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def add(x: ops.Output, y: ops.Output, name: String = "Add"): ops.Output

Definition Classes
Math
def addBias(value: ops.Output, bias: ops.Output, cNNDataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "AddBias"): ops.Output

Definition Classes
NN
def addN(inputs: Seq[ops.Output], name: String = "AddN"): ops.Output

Definition Classes
Math
def all(input: ops.Output, axes: ops.Output = null, keepDims: Boolean = false, name: String = "All"): ops.Output

Definition Classes
Math
def angle[T <: ops.OutputLike](input: T, name: String = "Angle")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
Annotations
@throws( ... )
def any(input: ops.Output, axes: ops.Output = null, keepDims: Boolean = false, name: String = "Any"): ops.Output

Definition Classes
Math
def approximatelyEqual(x: ops.Output, y: ops.Output, tolerance: Float = 0.00001f, name: String = "ApproximatelyEqual"): ops.Output

Definition Classes
Math
def argmax(input: ops.Output, axes: ops.Output = 0, outputDataType: types.DataType = INT64, name: String = "ArgMax"): ops.Output

Definition Classes
Math
def argmin(input: ops.Output, axes: ops.Output = 0, outputDataType: types.DataType = INT64, name: String = "ArgMin"): ops.Output

Definition Classes
Math
Annotations
@throws( ... )
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asin[T](x: T, name: String = "Asin")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def asinh[T](x: T, name: String = "ASinh")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def assert(condition: ops.Output, data: Seq[ops.Output], summarize: Int = 3, name: String = "Assert"): ops.Op

Definition Classes
Checks
def assertEqual(x: ops.Output, y: ops.Output, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertEqual"): ops.Op

Definition Classes
Checks
def assertGreater(x: ops.Output, y: ops.Output, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertGreater"): ops.Op

Definition Classes
Checks
def assertGreaterEqual(x: ops.Output, y: ops.Output, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertGreaterEqual"): ops.Op

Definition Classes
Checks
def assertLess(x: ops.Output, y: ops.Output, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertLess"): ops.Op

Definition Classes
Checks
def assertLessEqual(x: ops.Output, y: ops.Output, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertLessEqual"): ops.Op

Definition Classes
Checks
def assertNear(x: ops.Output, y: ops.Output, relTolerance: ops.Output = 0.00001f, absTolerance: ops.Output = 0.00001f, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertNear"): ops.Op

Definition Classes
Checks
def assertNegative(input: ops.Output, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertNegative"): ops.Op

Definition Classes
Checks
def assertNonNegative(input: ops.Output, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertNonNegative"): ops.Op

Definition Classes
Checks
def assertNonPositive(input: ops.Output, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertNonPositive"): ops.Op

Definition Classes
Checks
def assertNoneEqual(x: ops.Output, y: ops.Output, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertNoneEqual"): ops.Op

Definition Classes
Checks
def assertPositive(input: ops.Output, message: ops.Output = null, data: Seq[ops.Output] = null, summarize: Int = 3, name: String = "AssertPositive"): ops.Op

Definition Classes
Checks
def atan[T](x: T, name: String = "Atan")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def atan2(x: ops.Output, y: ops.Output, name: String = "ATan2"): ops.Output

Definition Classes
Math
def atanh[T](x: T, name: String = "ATanh")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def batchToSpace(input: ops.Output, blockSize: Int, crops: ops.Output, name: String = "BatchToSpace"): ops.Output

Definition Classes
Basic
def batchToSpaceND(input: ops.Output, blockShape: ops.Output, crops: ops.Output, name: String = "BatchToSpaceND"): ops.Output

Definition Classes
Basic
Annotations
@throws( ... )
def bidirectionalDynamicRNN[O, OS, S, SS](cellFw: ops.rnn.cell.RNNCell[O, OS, S, SS], cellBw: ops.rnn.cell.RNNCell[O, OS, S, SS], input: O, initialStateFw: S = null.asInstanceOf[S], initialStateBw: S = null.asInstanceOf[S], timeMajor: Boolean = false, parallelIterations: Int = 32, swapMemory: Boolean = false, sequenceLengths: ops.Output = null, name: String = "RNN")(implicit evO: Aux[O, OS], evS: Aux[S, SS]): (Tuple[O, S], Tuple[O, S])

Definition Classes
RNN
Annotations
@throws( ... )
def binCount(input: ops.Output, weights: ops.Output = null, minLength: ops.Output = null, maxLength: ops.Output = null, dataType: types.DataType = INT32, name: String = "BinCount"): ops.Output

Definition Classes
Math
def bitcast(input: ops.Output, dataType: types.DataType, name: String = "Bitcast"): ops.Output

Definition Classes
Math
def booleanMask(input: ops.Output, mask: ops.Output, name: String = "BooleanMask"): ops.Output

Definition Classes
Basic
def broadcastShapeDynamic(shape1: ops.Output, shape2: ops.Output, name: String = "BroadcastShape"): ops.Output

Definition Classes
Basic
def bucketize(input: ops.Output, boundaries: Seq[Float], name: String = "Bucketize"): ops.Output

Definition Classes
Math
def callback[T, TS, TD, R, RS, RD](function: (T) ⇒ R, input: TS, outputDataType: RD, stateful: Boolean = true, name: String = "Callback")(implicit evInput: Aux[T, TS, TD], evOutput: Aux[R, RS, RD]): RS

Definition Classes
Callback
def cast[T <: ops.OutputLike](x: T, dataType: types.DataType, name: String = "Cast")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def ceil[T](x: T, name: String = "Ceil")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def checkNumerics(input: ops.Output, message: String = "", name: String = "CheckNumerics"): ops.Output

Definition Classes
Basic
def clipByAverageNorm(input: ops.Output, clipNorm: ops.Output, name: String = "ClipByAverageNorm"): ops.Output

Definition Classes
Clip
def clipByGlobalNorm(inputs: Seq[ops.OutputLike], clipNorm: ops.Output, globalNorm: ops.Output = null, name: String = "ClipByGlobalNorm"): (Seq[ops.OutputLike], ops.Output)

Definition Classes
Clip
def clipByNorm(input: ops.Output, clipNorm: ops.Output, axes: ops.Output = null, name: String = "ClipByNorm"): ops.Output

Definition Classes
Clip
def clipByValue(input: ops.Output, clipValueMin: ops.Output, clipValueMax: ops.Output, name: String = "ClipByValue"): ops.Output

Definition Classes
Clip
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def colocateWith[R](colocationOps: Set[Op], ignoreExisting: Boolean = false)(block: ⇒ R): R

Definition Classes
API
def complex(real: ops.Output, imag: ops.Output, name: String = "Complex"): ops.Output

Definition Classes
Math
def concatenate(inputs: Seq[ops.Output], axis: ops.Output = 0, name: String = "Concatenate"): ops.Output

Definition Classes
Basic
def cond[T, R](predicate: ops.Output, trueFn: () ⇒ T, falseFn: () ⇒ T, name: String = "Cond")(implicit ev: Aux[T, R]): T

Definition Classes
ControlFlow
Annotations
@throws( ... )
def conjugate[T <: ops.OutputLike](input: T, name: String = "Conjugate")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
Annotations
@throws( ... )
def constant(tensor: tensors.Tensor, dataType: types.DataType = null, shape: core.Shape = null, name: String = "Constant")(implicit context: DynamicVariable[Context]): ops.Output

Definition Classes
Basic
Annotations
@throws( ... )
def conv2D(input: ops.Output, filter: ops.Output, stride1: Long, stride2: Long, padding: ops.NN.PaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, useCuDNNOnGPU: Boolean = true, name: String = "Conv2D"): ops.Output

Definition Classes
NN
def conv2DBackpropFilter(input: ops.Output, filterSizes: ops.Output, outputGradient: ops.Output, stride1: Long, stride2: Long, padding: ops.NN.PaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, useCuDNNOnGPU: Boolean = true, name: String = "Conv2DBackpropFilter"): ops.Output

Definition Classes
NN
def conv2DBackpropInput(inputSizes: ops.Output, filter: ops.Output, outputGradient: ops.Output, stride1: Long, stride2: Long, padding: ops.NN.PaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, useCuDNNOnGPU: Boolean = true, name: String = "Conv2DBackpropInput"): ops.Output

Definition Classes
NN
def cos[T](x: T, name: String = "Cos")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def cosh[T](x: T, name: String = "Cosh")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def countNonZero(input: ops.Output, axes: ops.Output = null, keepDims: Boolean = false, name: String = "CountNonZero"): ops.Output

Definition Classes
Math
def createWith[R](graph: core.Graph = null, nameScope: String = null, device: String = "", deviceFunction: (OpSpecification) ⇒ String = _.device, colocationOps: Set[Op] = null, controlDependencies: Set[Op] = null, attributes: Map[String, Any] = null, container: String = null)(block: ⇒ R): R

Definition Classes
API
def createWithNameScope[R](nameScope: String, values: Set[Op] = Set.empty[Op])(block: ⇒ R): R

Definition Classes
API
def createWithUpdatedVariableScope[R](variableScope: VariableScope, reuse: VariableReuseAllowed = ReuseOrCreateNewVariable, dataType: types.DataType = null, initializer: VariableInitializer = null, regularizer: VariableRegularizer = null, partitioner: VariablePartitioner = null, cachingDevice: (ops.OpSpecification) ⇒ String = null, customGetter: VariableGetter = null, isPure: Boolean = false)(block: ⇒ R): R

Definition Classes
API
def createWithVariableScope[R](name: String, reuse: VariableReuseAllowed = ReuseOrCreateNewVariable, dataType: types.DataType = null, initializer: VariableInitializer = null, regularizer: VariableRegularizer = null, partitioner: VariablePartitioner = null, cachingDevice: (ops.OpSpecification) ⇒ String = null, customGetter: VariableGetter = null, isDefaultName: Boolean = false, isPure: Boolean = false)(block: ⇒ R): R

Definition Classes
API
def crelu(input: ops.Output, name: String = "CReLU"): ops.Output

Definition Classes
NN
def cross(a: ops.Output, b: ops.Output, name: String = "Cross"): ops.Output

Definition Classes
Math
def cumprod(input: ops.Output, axis: ops.Output = 0, exclusive: Boolean = false, reverse: Boolean = false, name: String = "CumProd"): ops.Output

Definition Classes
Math
def cumsum(input: ops.Output, axis: ops.Output = 0, exclusive: Boolean = false, reverse: Boolean = false, name: String = "CumSum"): ops.Output

Definition Classes
Math
def currentAttributes: Map[String, Any]

Definition Classes
API
def currentColocationOps: Set[Op]

Definition Classes
API
def currentContainer: String

Definition Classes
API
def currentControlDependencies: Set[Op]

Definition Classes
API
def currentDevice: String

Definition Classes
API
def currentDeviceFunction: (OpSpecification) ⇒ String

Definition Classes
API
def currentGraph: core.Graph

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

Definition Classes
API
def currentNameScope: String

Definition Classes
API
def currentVariableScope: ops.variables.VariableScope

Definition Classes
API
def currentVariableStore: ops.variables.VariableStore

Definition Classes
API
object data extends API
def dataType(name: String): types.DataType

Definition Classes
API
Annotations
@throws( ... )
def dataType(cValue: Int): types.DataType

Definition Classes
API
Annotations
@throws( ... )
def dataTypeOf[T](value: T)(implicit arg0: SupportedType[T]): types.DataType

Definition Classes
API
Annotations
@inline()
def decodeBase64(input: ops.Output, name: String = "DecodeBase64"): ops.Output

Definition Classes
Text
def decodeCSV(records: ops.Output, recordDefaults: Seq[ops.Output], dataTypes: Seq[types.DataType], delimiter: String = ",", useQuoteDelimiters: Boolean = true, name: String = "DecodeCSV"): Seq[ops.Output]

Definition Classes
Parsing
Annotations
@throws( ... )
def decodeJSONExample(jsonExamples: ops.Output, name: String = "DecodeJSONExample"): ops.Output

Definition Classes
Parsing
Annotations
@throws( ... )
def decodeRaw(bytes: ops.Output, dataType: types.DataType, littleEndian: Boolean = true, name: String = "DecodeRaw"): ops.Output

Definition Classes
Parsing
Annotations
@throws( ... )
def decodeTensor(data: ops.Output, dataType: types.DataType, name: String = "DecodeTensor"): ops.Output

Definition Classes
Parsing
Annotations
@throws( ... )
def depthToSpace(input: ops.Output, blockSize: Int, dataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "DepthToSpace"): ops.Output

Definition Classes
Basic
def diag(diagonal: ops.Output, name: String = "Diag"): ops.Output

Definition Classes
Math
def diagPart(input: ops.Output, name: String = "DiagPart"): ops.Output

Definition Classes
Math
def digamma[T](x: T, name: String = "Digamma")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def divide(x: ops.Output, y: ops.Output, name: String = "Div"): ops.Output

Definition Classes
Math
def dropout(input: ops.Output, keepProbability: Float, noiseShape: ops.Output = null, seed: Option[Int] = None, name: String = "Dropout"): ops.Output

Definition Classes
NN
def dynamicDropout(input: ops.Output, keepProbability: ops.Output, noiseShape: ops.Output = null, seed: Option[Int] = None, name: String = "Dropout"): ops.Output

Definition Classes
NN
def dynamicPartition(data: ops.Output, partitions: ops.Output, numberOfPartitions: Int, name: String = "DynamicPartition"): Seq[ops.Output]

Definition Classes
DataFlow
def dynamicRNN[O, OS, S, SS](cell: ops.rnn.cell.RNNCell[O, OS, S, SS], input: O, initialState: S = null.asInstanceOf[S], timeMajor: Boolean = false, parallelIterations: Int = 32, swapMemory: Boolean = false, sequenceLengths: ops.Output = null, name: String = "RNN")(implicit evO: Aux[O, OS], evS: Aux[S, SS]): Tuple[O, S]

Definition Classes
RNN
Annotations
@throws( ... ) @throws( ... )
def dynamicStitch(indices: Seq[ops.Output], data: Seq[ops.Output], name: String = "DynamicStitch"): ops.Output

Definition Classes
DataFlow
def editDistance(hypothesis: ops.SparseOutput, truth: ops.SparseOutput, normalize: Boolean = true, name: String = "EditDistance"): ops.Output

Definition Classes
Basic
def elu(input: ops.Output, name: String = "ELU"): ops.Output

Definition Classes
NN
def embeddingLookup(parameters: EmbeddingMap, ids: ops.Output, partitionStrategy: PartitionStrategy = ModStrategy, transformFn: (ops.Output) ⇒ ops.Output = null, maxNorm: ops.Output = null, name: String = "EmbeddingLookup"): ops.Output

Definition Classes
Embedding
def encodeBase64(input: ops.Output, pad: Boolean = false, name: String = "EncodeBase64"): ops.Output

Definition Classes
Text
def encodeTensor(tensor: ops.Output, name: String = "EncodeTensor"): ops.Output

Definition Classes
Parsing
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equal(x: ops.Output, y: ops.Output, name: String = "Equal"): ops.Output

Definition Classes
Math
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def erf[T](x: T, name: String = "Erf")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def erfc[T](x: T, name: String = "Erfc")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def exp[T](x: T, name: String = "Exp")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def expandDims(input: ops.Output, axis: ops.Output, name: String = "ExpandDims"): ops.Output

Definition Classes
Basic
def expm1[T](x: T, name: String = "Expm1")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def extractImagePatches(images: ops.Output, slidingWindowSizes: Seq[Int], strides: Seq[Int], rates: Seq[Int], name: String = "ExtractImagePatches"): ops.Output

Definition Classes
Image
def fifoQueue(componentTypes: Seq[types.DataType], componentShapes: Seq[core.Shape] = Seq.empty, capacity: Int = 1, sharedName: String = "", name: String = "FIFOQueue"): Queue

Definition Classes
API
def fill(dataType: types.DataType = null, shape: ops.Output = null)(value: ops.Output, name: String = "Fill"): ops.Output

Definition Classes
Basic
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def floor[T](x: T, name: String = "Floor")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def floorMod(x: ops.Output, y: ops.Output, name: String = "FloorMod"): ops.Output

Definition Classes
Math
def gather(input: ops.Output, indices: ops.Output, axis: ops.Output = 0, name: String = "Gather"): ops.Output

Definition Classes
Basic
def gatherND(input: ops.Output, indices: ops.Output, name: String = "GatherND"): ops.Output

Definition Classes
Basic
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def globalNorm(inputs: Seq[ops.OutputLike], name: String = "GlobalNorm"): ops.Output

Definition Classes
Clip
def globalVariablesInitializer(name: String = "GlobalVariablesInitializer"): Op

Definition Classes
API
def greater(x: ops.Output, y: ops.Output, name: String = "Greater"): ops.Output

Definition Classes
Math
def greaterEqual(x: ops.Output, y: ops.Output, name: String = "GreaterEqual"): ops.Output

Definition Classes
Math
def group(inputs: Set[ops.Op], name: String = "Group"): ops.Op

Definition Classes
ControlFlow
def guaranteeConstant(input: ops.Output, name: String = "GuaranteeConstant"): ops.Output

Definition Classes
Basic
def hashCode(): Int

Definition Classes
AnyRef → Any
def identity[T <: ops.OutputLike](input: T, name: String = "Identity"): T

Definition Classes
Basic
def igamma(a: ops.Output, x: ops.Output, name: String = "Igamma"): ops.Output

Definition Classes
Math
def igammac(a: ops.Output, x: ops.Output, name: String = "Igammac"): ops.Output

Definition Classes
Math
def imag[T <: ops.OutputLike](input: T, name: String = "Imag")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def inTopK(predictions: ops.Output, targets: ops.Output, k: ops.Output, name: String = "InTopK"): ops.Output

Definition Classes
NN
def incompleteBeta(a: ops.Output, b: ops.Output, x: ops.Output, name: String = "IncompleteBeta"): ops.Output

Definition Classes
Math
def indexTableFromFile(filename: String, delimiter: String = "\t", vocabularySize: Int = 1, defaultValue: Long = 1L, numOOVBuckets: Int = 0, hashSpecification: HashSpecification = FAST_HASH, keysDataType: types.DataType = STRING, name: String = "IndexTableFromFile"): ops.lookup.LookupTable

Definition Classes
Lookup
def indexedSlicesMask(input: ops.OutputIndexedSlices, maskIndices: ops.Output, name: String = "IndexedSlicesMask"): ops.OutputIndexedSlices

Definition Classes
Basic
def initializer(initializers: Set[ops.Op], name: String = "TablesInitializer"): ops.Op

Definition Classes
Lookup
def initializers: Set[ops.Op]

Definition Classes
Lookup
def invertPermutation(input: ops.Output, name: String = "InvertPermutation"): ops.Output

Definition Classes
Basic
def isFinite[T](x: T, name: String = "IsFinite")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def isInf[T](x: T, name: String = "IsInf")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isNaN[T](x: T, name: String = "IsNaN")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def l2Loss(input: ops.Output, name: String = "L2Loss"): ops.Output

Definition Classes
NN
def l2Normalize(x: ops.Output, axes: ops.Output, epsilon: Float = 1e-12f, name: String = "L2Normalize"): ops.Output

Definition Classes
NN
object learn extends API
def leastPreciseDataType(dataTypes: types.DataType*): types.DataType

Definition Classes
API
def less(x: ops.Output, y: ops.Output, name: String = "Less"): ops.Output

Definition Classes
Math
def lessEqual(x: ops.Output, y: ops.Output, name: String = "LessEqual"): ops.Output

Definition Classes
Math
def linear(x: ops.Output, weights: ops.Output, bias: ops.Output = null, name: String = "Linear"): ops.Output

Definition Classes
NN
def linspace(start: ops.Output, stop: ops.Output, numberOfValues: ops.Output, name: String = "LinSpace"): ops.Output

Definition Classes
Math
def listDiff(x: ops.Output, y: ops.Output, indicesDataType: types.DataType = INT32, name: String = "ListDiff"): (ops.Output, ops.Output)

Definition Classes
Basic
def localPartitionedVariable(name: String, dataType: types.DataType = null, shape: core.Shape = null, initializer: VariableInitializer = null, regularizer: VariableRegularizer = null, partitioner: VariablePartitioner, reuse: Reuse = ReuseOrCreateNew, collections: Set[Key[Variable]] = Set.empty, cachingDevice: (ops.OpSpecification) ⇒ String = null): PartitionedVariable

Definition Classes
API
def localVariable(name: String, dataType: types.DataType = null, shape: core.Shape = null, initializer: VariableInitializer = null, regularizer: VariableRegularizer = null, reuse: Reuse = ReuseOrCreateNew, collections: Set[Key[Variable]] = Set.empty, cachingDevice: (ops.OpSpecification) ⇒ String = null): Variable

Definition Classes
API
def localVariablesInitializer(name: String = "LocalVariablesInitializer"): Op

Definition Classes
API
def log[T](x: T, name: String = "Log")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def log1p[T](x: T, name: String = "Log1p")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def logGamma[T](x: T, name: String = "Lgamma")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def logPoissonLoss(logPredictions: ops.Output, targets: ops.Output, computeFullLoss: Boolean = false, name: String = "LogPoissonLoss"): ops.Output

Definition Classes
NN
def logSoftmax(logits: ops.Output, axis: Int = 1, name: String = "LogSoftmax"): ops.Output

Definition Classes
NN
def logSumExp(input: ops.Output, axes: Seq[Int] = null, keepDims: Boolean = false, name: String = "LogSumExp"): ops.Output

Definition Classes
Math
def logicalAnd(x: ops.Output, y: ops.Output, name: String = "LogicalAnd"): ops.Output

Definition Classes
Math
def logicalNot(x: ops.Output, name: String = "LogicalNot"): ops.Output

Definition Classes
Math
def logicalOr(x: ops.Output, y: ops.Output, name: String = "LogicalOr"): ops.Output

Definition Classes
Math
def logicalXOr(x: ops.Output, y: ops.Output, name: String = "LogicalXOr"): ops.Output

Definition Classes
Math
def matmul(a: ops.Output, b: ops.Output, transposeA: Boolean = false, transposeB: Boolean = false, conjugateA: Boolean = false, conjugateB: Boolean = false, aIsSparse: Boolean = false, bIsSparse: Boolean = false, name: String = "MatMul"): ops.Output

Definition Classes
Math
def matrixBandPart(input: ops.Output, numSubDiagonals: ops.Output, numSuperDiagonals: ops.Output, name: String = "MatrixBandPart"): ops.Output

Definition Classes
Math
def matrixDiag(diagonal: ops.Output, name: String = "MatrixDiag"): ops.Output

Definition Classes
Math
def matrixDiagPart(input: ops.Output, name: String = "MatrixDiagPart"): ops.Output

Definition Classes
Math
def matrixSetDiag(input: ops.Output, diagonal: ops.Output, name: String = "MatrixSetDiag"): ops.Output

Definition Classes
Math
def matrixTranspose(input: ops.Output, conjugate: Boolean = false, name: String = "MatrixTranspose"): ops.Output

Definition Classes
Basic
def max(input: ops.Output, axes: ops.Output = null, keepDims: Boolean = false, name: String = "Max"): ops.Output

Definition Classes
Math
def maxPool(input: ops.Output, windowSize: Seq[Long], stride1: Long, stride2: Long, padding: ops.NN.PaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "MaxPool"): ops.Output

Definition Classes
NN
def maxPoolGrad(originalInput: ops.Output, originalOutput: ops.Output, outputGradient: ops.Output, windowSize: Seq[Long], stride1: Long, stride2: Long, padding: ops.NN.PaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "MaxPoolGrad"): ops.Output

Definition Classes
NN
def maxPoolGradGrad(originalInput: ops.Output, originalOutput: ops.Output, outputGradient: ops.Output, windowSize: Seq[Long], stride1: Long, stride2: Long, padding: ops.NN.PaddingMode, dataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "MaxPoolGradGrad"): ops.Output

Definition Classes
NN
def maximum(x: ops.Output, y: ops.Output, name: String = "Maximum"): ops.Output

Definition Classes
Math
def mean(input: ops.Output, axes: ops.Output = null, keepDims: Boolean = false, name: String = "Mean"): ops.Output

Definition Classes
Math
def meshGrid(inputs: Seq[ops.Output], useCartesianIndexing: Boolean = true, name: String = "MeshGrid"): Seq[ops.Output]

Definition Classes
Basic
object metrics extends API
def min(input: ops.Output, axes: ops.Output = null, keepDims: Boolean = false, name: String = "Min"): ops.Output

Definition Classes
Math
def minimum(x: ops.Output, y: ops.Output, name: String = "Minimum"): ops.Output

Definition Classes
Math
def mod(x: ops.Output, y: ops.Output, name: String = "Mod"): ops.Output

Definition Classes
Math
def modelVariablesInitializer(name: String = "ModelVariablesInitializer"): Op

Definition Classes
API
def moments(input: ops.Output, axes: Seq[Int], weights: ops.Output = null, keepDims: Boolean = false, name: String = "Moments"): (ops.Output, ops.Output)

Definition Classes
Statistics
def momentsFromSufficientStatistics(counts: ops.Output, meanSS: ops.Output, varSS: ops.Output, shift: ops.Output = null, name: String = "MomentsFromSufficientStatistics"): (ops.Output, ops.Output)

Definition Classes
Statistics
def mostPreciseDataType(dataTypes: types.DataType*): types.DataType

Definition Classes
API
def multiply(x: ops.Output, y: ops.Output, name: String = "Mul"): ops.Output

Definition Classes
Math
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def negate[T](x: T, name: String = "Negate")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def newStack(maxSize: ops.Output, elementType: types.DataType, stackName: String = "", name: String = "NewStack"): ops.Output

Definition Classes
DataFlow
def noOp(name: String = "NoOp"): ops.Op

Definition Classes
ControlFlow
def notEqual(x: ops.Output, y: ops.Output, name: String = "NotEqual"): ops.Output

Definition Classes
Math
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def oneHot(indices: ops.Output, depth: ops.Output, onValue: ops.Output = null, offValue: ops.Output = null, axis: Int = 1, dataType: types.DataType = null, name: String = "OneHot"): ops.Output

Definition Classes
Basic
def ones(dataType: types.DataType, shape: ops.Output, name: String = "Ones"): ops.Output

Definition Classes
Basic
def onesLike(input: ops.Output, dataType: types.DataType = null, optimize: Boolean = true, name: String = "OnesLike"): ops.Output

Definition Classes
Basic
def pad(input: ops.Output, paddings: ops.Output, mode: PaddingMode = ConstantPadding, name: String = "Pad"): ops.Output

Definition Classes
Basic
def paddingFifoQueue(componentTypes: Seq[types.DataType], componentShapes: Seq[core.Shape] = Seq.empty, capacity: Int = 1, sharedName: String = "", name: String = "PaddingFIFOQueue"): Queue

Definition Classes
API
def parallelStack(inputs: Array[ops.Output], name: String = "ParallelStack"): ops.Output

Definition Classes
Basic
def partitionedVariable(name: String, dataType: types.DataType = null, shape: core.Shape = null, initializer: VariableInitializer = null, regularizer: VariableRegularizer = null, partitioner: VariablePartitioner, trainable: Boolean = true, reuse: Reuse = ReuseOrCreateNew, collections: Set[Key[Variable]] = Set.empty, cachingDevice: (ops.OpSpecification) ⇒ String = null): PartitionedVariable

Definition Classes
API
def placeholder(dataType: types.DataType, shape: core.Shape = null, name: String = "Placeholder"): ops.Output

Definition Classes
Basic
def placeholderWithDefault(default: ops.Output, shape: core.Shape, name: String = "PlaceholderWithDefault"): ops.Output

Definition Classes
Basic
def polygamma(n: ops.Output, x: ops.Output, name: String = "Polygamma"): ops.Output

Definition Classes
Math
def pow(x: ops.Output, y: ops.Output, name: String = "Pow"): ops.Output

Definition Classes
Math
def preventGradient(input: ops.Output, message: String = "", name: String = "PreventGradient"): ops.Output

Definition Classes
Basic
def print[T](input: T, data: Seq[ops.Output], message: String = "", firstN: Int = 1, summarize: Int = 3, name: String = "Print")(implicit arg0: OutputOps[T]): T

Definition Classes
Logging
def priorityQueue(componentTypes: Seq[types.DataType], componentShapes: Seq[core.Shape] = Seq.empty, capacity: Int = 1, sharedName: String = "", name: String = "PriorityQueue"): Queue

Definition Classes
API
def prod(input: ops.Output, axes: ops.Output = null, keepDims: Boolean = false, name: String = "Prod"): ops.Output

Definition Classes
Math
def randomNormal(dataType: types.DataType = FLOAT32, shape: ops.Output = Shape.scalar(), mean: ops.Output = 0.0, standardDeviation: ops.Output = 1.0, seed: Option[Int] = None, name: String = "RandomNormal"): ops.Output

Definition Classes
Random
Annotations
@throws( ... )
def randomShuffleQueue(componentTypes: Seq[types.DataType], componentShapes: Seq[core.Shape] = Seq.empty, capacity: Int = 1, minAfterDequeue: Int = 0, seed: Option[Int] = None, sharedName: String = "", name: String = "RandomShuffleQueue"): Queue

Definition Classes
API
def randomTruncatedNormal(dataType: types.DataType = FLOAT32, shape: ops.Output = Shape.scalar(), mean: ops.Output = 0.0, standardDeviation: ops.Output = 1.0, seed: Option[Int] = None, name: String = "RandomTruncatedNormal"): ops.Output

Definition Classes
Random
Annotations
@throws( ... )
def randomUniform(dataType: types.DataType = FLOAT32, shape: ops.Output = Shape.scalar(), minValue: ops.Output = 0.0, maxValue: ops.Output = 1.0, seed: Option[Int] = None, name: String = "RandomUniform"): ops.Output

Definition Classes
Random
Annotations
@throws( ... )
def range(start: ops.Output, limit: ops.Output, delta: ops.Output = Basic.constant(1), dataType: types.DataType = null, name: String = "Range"): ops.Output

Definition Classes
Math
def rank[T <: ops.OutputLike](input: T, optimize: Boolean = true, name: String = "Rank"): ops.Output

Definition Classes
Basic
def real[T <: ops.OutputLike](input: T, name: String = "Real")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def realDivide(x: ops.Output, y: ops.Output, name: String = "RealDiv"): ops.Output

Definition Classes
Math
def reciprocal[T](x: T, name: String = "Reciprocal")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def relu(input: ops.Output, alpha: Float = 0.0f, name: String = "ReLU"): ops.Output

Definition Classes
NN
def relu6(input: ops.Output, name: String = "ReLU6"): ops.Output

Definition Classes
NN
def requiredSpaceToBatchPaddingsAndCrops(inputShape: ops.Output, blockShape: ops.Output, basePaddings: ops.Output = null, name: String = "RequiredSpaceToBatchPaddings"): (ops.Output, ops.Output)

Definition Classes
Basic
def reshape(input: ops.Output, shape: ops.Output, name: String = "Reshape"): ops.Output

Definition Classes
Basic
def reverse(input: ops.Output, axes: ops.Output, name: String = "Reverse"): ops.Output

Definition Classes
Basic
def reverseSequence(input: ops.Output, sequenceLengths: ops.Output, sequenceAxis: Int, batchAxis: Int = 0, name: String = "ReverseSequence"): ops.Output

Definition Classes
Basic
def round[T](x: T, name: String = "Round")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def roundInt[T](x: T, name: String = "RoundInt")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def rsqrt[T](x: T, name: String = "Rsqrt")(implicit arg0: OutputOps[T]): T

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](scalar: ops.Output, tensor: T, name: String = "ScalarMul")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def scatterND(indices: ops.Output, updates: ops.Output, shape: ops.Output, name: String = "ScatterND"): ops.Output

Definition Classes
Basic
def segmentMax(data: ops.Output, segmentIndices: ops.Output, name: String = "SegmentMax"): ops.Output

Definition Classes
Math
def segmentMean(data: ops.Output, segmentIndices: ops.Output, name: String = "SegmentMean"): ops.Output

Definition Classes
Math
def segmentMin(data: ops.Output, segmentIndices: ops.Output, name: String = "SegmentMin"): ops.Output

Definition Classes
Math
def segmentProd(data: ops.Output, segmentIndices: ops.Output, name: String = "SegmentProd"): ops.Output

Definition Classes
Math
def segmentSum(data: ops.Output, segmentIndices: ops.Output, name: String = "SegmentSum"): ops.Output

Definition Classes
Math
def select(condition: ops.Output, x: ops.Output, y: ops.Output, name: String = "Select"): ops.Output

Definition Classes
Math
def selu(input: ops.Output, name: String = "SELU"): ops.Output

Definition Classes
NN
def sequenceLoss(logits: ops.Output, labels: ops.Output, weights: ops.Output = null, averageAcrossTimeSteps: Boolean = true, averageAcrossBatch: Boolean = true, lossFn: (ops.Output, ops.Output) ⇒ ops.Output = sparseSoftmaxCrossEntropy(_, _), name: String = "SequenceLoss"): ops.Output

Definition Classes
NN
Annotations
@throws( ... )
def sequenceMask(lengths: ops.Output, maxLength: ops.Output = null, dataType: types.DataType = BOOLEAN, name: String = "SequenceMask"): ops.Output

Definition Classes
Basic
def setCurrentGraphRandomSeed(value: Int): Unit

Definition Classes
API
def setDifference[A, B](a: A, b: B, validateIndices: Boolean = true, name: String = "SetDifference")(implicit ev: Aux[A, B]): ops.SparseOutput

Definition Classes
Sets
Annotations
@throws( ... )
def setIntersection[A, B](a: A, b: B, validateIndices: Boolean = true, name: String = "SetIntersection")(implicit ev: Aux[A, B]): ops.SparseOutput

Definition Classes
Sets
Annotations
@throws( ... )
def setSize(input: ops.SparseOutput, validateIndices: Boolean = true, name: String = "SetSize"): ops.Output

Definition Classes
Sets
Annotations
@throws( ... )
def setUnion[A, B](a: A, b: B, validateIndices: Boolean = true, name: String = "SetUnion")(implicit ev: Aux[A, B]): ops.SparseOutput

Definition Classes
Sets
Annotations
@throws( ... )
def shape[T <: ops.OutputLike](input: T, dataType: types.DataType = INT32, optimize: Boolean = true, name: String = "Shape"): ops.Output

Definition Classes
Basic
def shapeN(inputs: Seq[ops.Output], dataType: types.DataType = INT32, optimize: Boolean = true, name: String = "ShapeN"): Seq[ops.Output]

Definition Classes
Basic
def sigmoid[T](x: T, name: String = "Sigmoid")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def sigmoidCrossEntropy(logits: ops.Output, labels: ops.Output, weights: ops.Output = null, name: String = "SigmoidCrossEntropy"): ops.Output

Definition Classes
NN
def sign[T](x: T, name: String = "Sign")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def sin[T](x: T, name: String = "Sin")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def sinh[T](x: T, name: String = "Sinh")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def size[T <: ops.OutputLike](input: T, dataType: types.DataType = INT32, optimize: Boolean = true, name: String = "Size"): ops.Output

Definition Classes
Basic
def slice(input: ops.Output, begin: ops.Output, size: ops.Output, name: String = "Slice"): ops.Output

Definition Classes
Basic
def softmax(logits: ops.Output, axis: Int = 1, name: String = "Softmax"): ops.Output

Definition Classes
NN
def softmaxCrossEntropy(logits: ops.Output, labels: ops.Output, axis: Int = 1, name: String = "SoftmaxCrossEntropy"): ops.Output

Definition Classes
NN
def softplus(input: ops.Output, name: String = "Softplus"): ops.Output

Definition Classes
NN
def softsign(input: ops.Output, name: String = "Softsign"): ops.Output

Definition Classes
NN
def spaceToBatch(input: ops.Output, blockSize: Int, paddings: ops.Output, name: String = "SpaceToBatch"): ops.Output

Definition Classes
Basic
def spaceToBatchND(input: ops.Output, blockShape: ops.Output, paddings: ops.Output, name: String = "SpaceToBatchND"): ops.Output

Definition Classes
Basic
def spaceToDepth(input: ops.Output, blockSize: Int, dataFormat: CNNDataFormat = CNNDataFormat.default, name: String = "SpaceToDepth"): ops.Output

Definition Classes
Basic
def sparseEmbeddingLookup(parameters: EmbeddingMap, sparseIds: ops.SparseOutput, sparseWeights: ops.SparseOutput = null, partitionStrategy: PartitionStrategy = ModStrategy, combiner: Combiner = SumSqrtNCombiner, maxNorm: ops.Output = null, name: String = "SparseEmbeddingLookup"): ops.Output

Definition Classes
Embedding
def sparsePlaceholder(dataType: types.DataType, shape: core.Shape = null, name: String = "SparsePlaceholder"): ops.SparseOutput

Definition Classes
Basic
def sparseSegmentMean(data: ops.Output, indices: ops.Output, segmentIndices: ops.Output, numSegments: ops.Output = null, name: String = "SparseSegmentMean"): ops.Output

Definition Classes
Math
def sparseSegmentSum(data: ops.Output, indices: ops.Output, segmentIndices: ops.Output, numSegments: ops.Output = null, name: String = "SparseSegmentSum"): ops.Output

Definition Classes
Math
def sparseSegmentSumSqrtN(data: ops.Output, indices: ops.Output, segmentIndices: ops.Output, numSegments: ops.Output = null, name: String = "SparseSegmentSumSqrtN"): ops.Output

Definition Classes
Math
def sparseSoftmaxCrossEntropy(logits: ops.Output, labels: ops.Output, axis: Int = 1, name: String = "SparseSoftmaxCrossEntropy"): ops.Output

Definition Classes
NN
def split(input: ops.Output, splitSizes: ops.Output, axis: ops.Output = 0, name: String = "Split"): Seq[ops.Output]

Definition Classes
Basic
def splitEvenly(input: ops.Output, numSplits: Int, axis: ops.Output = 0, name: String = "Split"): Seq[ops.Output]

Definition Classes
Basic
def sqrt[T](x: T, name: String = "Sqrt")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def square[T](x: T, name: String = "Square")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def squaredDifference(x: ops.Output, y: ops.Output, name: String = "SquaredDifference"): ops.Output

Definition Classes
Math
def squeeze(input: ops.Output, axes: Seq[Int] = null, name: String = "Squeeze"): ops.Output

Definition Classes
Basic
def stack(inputs: Seq[ops.Output], axis: Int = 0, name: String = "Stack"): ops.Output

Definition Classes
Basic
def stackClose(stackHandle: ops.Output, name: String = "StackClose"): ops.Op

Definition Classes
DataFlow
def stackPop(stackHandle: ops.Output, elementType: types.DataType, name: String = "StackPop"): ops.Output

Definition Classes
DataFlow
def stackPush(stackHandle: ops.Output, element: ops.Output, swapMemory: Boolean = false, name: String = "StackPush"): ops.Output

Definition Classes
DataFlow
def stopGradient(input: ops.Output, name: String = "StopGradient"): ops.Output

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

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

Definition Classes
Text
def stringToHashBucketFast(input: ops.Output, numBuckets: Int, name: String = "StringToHashBucketFast"): ops.Output

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

Definition Classes
Text
def stringToNumber(data: ops.Output, dataType: types.DataType, name: String = "StringToNumber"): ops.Output

Definition Classes
Parsing
Annotations
@throws( ... )
def subtract(x: ops.Output, y: ops.Output, name: String = "Sub"): ops.Output

Definition Classes
Math
def sufficientStatistics(input: ops.Output, axes: ops.Output, shift: ops.Output = null, keepDims: Boolean = false, name: String = "SufficientStatistics"): (ops.Output, ops.Output, ops.Output, ops.Output)

Definition Classes
Statistics
def sum(input: ops.Output, axes: ops.Output = null, keepDims: Boolean = false, name: String = "Sum"): ops.Output

Definition Classes
Math
object summary extends Summary

Definition Classes
API
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tan[T](x: T, name: String = "Tan")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def tanh[T](x: T, name: String = "Tanh")(implicit arg0: OutputOps[T]): T

Definition Classes
Math
def tensorDot(a: ops.Output, b: ops.Output, axesA: Seq[Int], axesB: Seq[Int], name: String): ops.Output

Definition Classes
Math
def tensorDot(a: ops.Output, b: ops.Output, axesA: Seq[Int], axesB: Seq[Int]): ops.Output

Definition Classes
Math
def tensorDot(a: ops.Output, b: ops.Output, numAxes: Int, name: String): ops.Output

Definition Classes
Math
def tensorDot(a: ops.Output, b: ops.Output, numAxes: Int): ops.Output

Definition Classes
Math
def tensorDotDynamic(a: ops.Output, b: ops.Output, axesA: ops.Output, axesB: ops.Output, name: String = "TensorDot"): ops.Output

Definition Classes
Math
def tensorDotDynamic(a: ops.Output, b: ops.Output, axesA: ops.Output, axesB: ops.Output): ops.Output

Definition Classes
Math
def tensorDotDynamic(a: ops.Output, b: ops.Output, numAxes: ops.Output, name: String): ops.Output

Definition Classes
Math
def tensorDotDynamic(a: ops.Output, b: ops.Output, numAxes: ops.Output): ops.Output

Definition Classes
Math
def tile(input: ops.Output, multiples: ops.Output, name: String = "Tile"): ops.Output

Definition Classes
Basic
def toString(): String

Definition Classes
AnyRef → Any
def topK(input: ops.Output, k: ops.Output = 1, sorted: Boolean = true, name: String = "TopK"): (ops.Output, ops.Output)

Definition Classes
NN
def trace(input: ops.Output, name: String = "Trace"): ops.Output

Definition Classes
Math
object train extends API

Definition Classes
API
def trainableVariablesInitializer(name: String = "TrainableVariablesInitializer"): Op

Definition Classes
API
def transpose(input: ops.Output, permutation: ops.Output = null, conjugate: Boolean = false, name: String = "Transpose"): ops.Output

Definition Classes
Basic
def truncateDivide(x: ops.Output, y: ops.Output, name: String = "TruncateDiv"): ops.Output

Definition Classes
Math
def truncateMod(x: ops.Output, y: ops.Output, name: String = "TruncateMod"): ops.Output

Definition Classes
Math
def tuple[T <: ops.OutputLike](inputs: Array[T], controlInputs: Set[ops.Op] = Set.empty, name: String = "Tuple")(implicit tag: ClassTag[T]): Array[T]

Definition Classes
ControlFlow
def unique(input: ops.Output, axis: ops.Output, indicesDataType: types.DataType = INT32, name: String = "Unique"): (ops.Output, ops.Output)

Definition Classes
Basic
def uniqueWithCounts(input: ops.Output, indicesDataType: types.DataType = INT32, name: String = "UniqueWithCounts"): (ops.Output, ops.Output, ops.Output)

Definition Classes
Basic
def unsortedSegmentMax(data: ops.Output, segmentIndices: ops.Output, segmentsNumber: ops.Output, name: String = "UnsortedSegmentMax"): ops.Output

Definition Classes
Math
def unsortedSegmentSum(data: ops.Output, segmentIndices: ops.Output, segmentsNumber: ops.Output, name: String = "UnsortedSegmentSum"): ops.Output

Definition Classes
Math
def unstack(input: ops.Output, number: Int = 1, axis: Int = 0, name: String = "Unstack"): Seq[ops.Output]

Definition Classes
Basic
Annotations
@throws( ... ) @throws( ... )
def variable(name: String, dataType: types.DataType = null, shape: core.Shape = null, initializer: VariableInitializer = null, regularizer: VariableRegularizer = null, trainable: Boolean = true, reuse: Reuse = ReuseOrCreateNew, collections: Set[Key[Variable]] = Set.empty, cachingDevice: (ops.OpSpecification) ⇒ String = null): Variable

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
@throws( ... )
def where(input: ops.Output, name: String = "Where"): ops.Output

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

Definition Classes
ControlFlow
def zeros(dataType: types.DataType, shape: ops.Output, name: String = "Zeros"): ops.Output

Definition Classes
Basic
def zerosFraction(input: ops.Output, name: String = "ZerosFraction"): ops.Output

Definition Classes
Math
def zerosLike(input: ops.Output, dataType: types.DataType = null, optimize: Boolean = true, name: String = "ZerosLike"): ops.Output

Definition Classes
Basic
def zeta(x: ops.Output, q: ops.Output, name: String = "Zeta"): ops.Output

Definition Classes
Math

Deprecated Value Members

def floorDivide(x: ops.Output, y: ops.Output, name: String = "FloorDiv"): ops.Output

Definition Classes
Math
Annotations
@deprecated
Deprecated
(Since version 0.1) Use truncateDivide instead.
def stringToHashBucket(input: ops.Output, numBuckets: Int, name: String = "StringToHashBucket"): ops.Output

Definition Classes
Text
Annotations
@deprecated
Deprecated
(Since version 0.1.0) It is recommended to use stringToHashBucketFast or stringToHashBucketStrong.

tf

Related Doc: package api

object tf extends API with API with API

Type Members

type AbortedException = jni.AbortedException

type AlreadyExistsException = jni.AlreadyExistsException

type Attention[AS, ASS] = ops.rnn.attention.Attention[AS, ASS]

type AttentionWrapperCell[S, SS, AS, ASS] = ops.rnn.attention.AttentionWrapperCell[S, SS, AS, ASS]

type BahdanauAttention = ops.rnn.attention.BahdanauAttention

type BasicDecoder[O, OS, S, SS] = ops.seq2seq.decoders.BasicDecoder[O, OS, S, SS]

type BasicLSTMCell = ops.rnn.cell.BasicLSTMCell

type BasicRNNCell = ops.rnn.cell.BasicRNNCell

type BasicTuple = Tuple[ops.Output, ops.Output]

type BeamSearchDecoder[S, SS] = ops.seq2seq.decoders.BeamSearchDecoder[S, SS]

type CancelledException = jni.CancelledException

type CheckpointNotFoundException = core.exception.CheckpointNotFoundException

sealed trait Combiner extends AnyRef

type DataLossException = jni.DataLossException

type DeadlineExceededException = jni.DeadlineExceededException

type Decoder[O, OS, S, SS, DO, DOS, DS, DSS, DFO, DFS] = ops.seq2seq.decoders.Decoder[O, OS, S, SS, DO, DOS, DS, DSS, DFO, DFS]

type DeviceSpecification = core.DeviceSpecification

type DeviceWrapper[O, OS, S, SS] = ops.rnn.cell.DeviceWrapper[O, OS, S, SS]

type DropoutWrapper[O, OS, S, SS] = ops.rnn.cell.DropoutWrapper[O, OS, S, SS]

type FailedPreconditionException = jni.FailedPreconditionException

type GRUCell = ops.rnn.cell.GRUCell

type GraphMismatchException = core.exception.GraphMismatchException

type HashTable = ops.lookup.HashTable

type IDLookupTableWithHashBuckets = ops.lookup.IDLookupTableWithHashBuckets

type IllegalNameException = core.exception.IllegalNameException

type InternalException = jni.InternalException

type InvalidArgumentException = jni.InvalidArgumentException

type InvalidDataTypeException = core.exception.InvalidDataTypeException

type InvalidDeviceException = core.exception.InvalidDeviceException

type InvalidIndexerException = core.exception.InvalidIndexerException

type InvalidShapeException = core.exception.InvalidShapeException

type LSTMCell = ops.rnn.cell.LSTMCell

type LSTMState = ops.rnn.cell.LSTMState

type LSTMTuple = Tuple[ops.Output, LSTMState]

type LookupTable = ops.lookup.LookupTable

type LookupTableInitializer = ops.lookup.LookupTableInitializer

type LookupTableTensorInitializer = ops.lookup.LookupTableTensorInitializer

type LookupTableTextFileInitializer = ops.lookup.LookupTableTextFileInitializer

type LuongAttention = ops.rnn.attention.LuongAttention

type MultiCell[O, OS, S, SS] = ops.rnn.cell.MultiCell[O, OS, S, SS]

type NotFoundException = jni.NotFoundException

type Op = ops.Op

type OpBuilderUsedException = core.exception.OpBuilderUsedException

type OpCreationContext = ops.OpCreationContext

type OpSpecification = ops.OpSpecification

type OutOfRangeException = jni.OutOfRangeException

type Output = ops.Output

type OutputIndexedSlices = ops.OutputIndexedSlices

type OutputLike = ops.OutputLike

sealed trait PaddingMode extends AnyRef

sealed trait PartitionStrategy extends AnyRef

type PartitionedVariable = ops.variables.PartitionedVariable

type PermissionDeniedException = jni.PermissionDeniedException

type RNNCell[O, OS, S, SS] = ops.rnn.cell.RNNCell[O, OS, S, SS]

type RNNTuple[O, S] = Tuple[O, S]

type ResidualWrapper[O, OS, S, SS] = ops.rnn.cell.ResidualWrapper[O, OS, S, SS]

type ResourceExhaustedException = jni.ResourceExhaustedException

type Saver = ops.variables.Saver

type ShapeMismatchException = core.exception.ShapeMismatchException

type SparseOutput = ops.SparseOutput

type UnauthenticatedException = jni.UnauthenticatedException

type UnavailableException = jni.UnavailableException

type UnimplementedException = jni.UnimplementedException

type UnknownException = jni.UnknownException

type Variable = ops.variables.Variable

type VariableGetter = ops.variables.Variable.VariableGetter

type VariableInitializer = Initializer

type VariablePartitioner = Partitioner

type VariableRegularizer = Regularizer

type VariableReuse = Reuse

type VariableReuseAllowed = ReuseAllowed

type VariableScope = ops.variables.VariableScope

type VariableStore = ops.variables.VariableStore

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int