| 
            
             Abort
            
            | 
           
            Raise a exception to abort the process when called.
            | 
          
          
           | 
            
             All
            
            | 
           
            Computes the "logical and" of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             AllToAll
            
            <T>
            | 
           
            An Op to exchange data across TPU replicas.
            | 
          
          
           | 
            
             AnonymousIteratorV2
            
            | 
           
            A container for an iterator resource.
            | 
          
          
           | 
            
             AnonymousMemoryCache
            
            | 
           
            | 
          
          
           | 
            
             AnonymousMultiDeviceIterator
            
            | 
           
            A container for a multi device iterator resource.
            | 
          
          
           | 
            
             AnonymousRandomSeedGenerator
            
            | 
           
            | 
          
          
           | 
            
             AnonymousSeedGenerator
            
            | 
           
            | 
          
          
           | 
            
             Any
            
            | 
           
            Computes the "logical or" of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             ApplyAdagradV2
            
            <T>
            | 
           
            Update '*var' according to the adagrad scheme.
            | 
          
          
           | 
            
             AssertCardinalityDataset
            
            | 
           
            | 
          
          
           | 
            
             AssertNextDataset
            
            | 
           
            A transformation that asserts which transformations happen next.
            | 
          
          
           | 
            
             AssertThat
            
            | 
           
            Asserts that the given condition is true.
            | 
          
          
           | 
            
             Assign
            
            <T>
            | 
           
            Update 'ref' by assigning 'value' to it.
            | 
          
          
           | 
            
             AssignAdd
            
            <T>
            | 
           
            Update 'ref' by adding 'value' to it.
            | 
          
          
           | 
            
             AssignAddVariableOp
            
            | 
           
            Adds a value to the current value of a variable.
            | 
          
          
           | 
            
             AssignSub
            
            <T>
            | 
           
            Update 'ref' by subtracting 'value' from it.
            | 
          
          
           | 
            
             AssignSubVariableOp
            
            | 
           
            Subtracts a value from the current value of a variable.
            | 
          
          
           | 
            
             AssignVariableOp
            
            | 
           
            Assigns a new value to a variable.
            | 
          
          
           | 
            
             AutoShardDataset
            
            | 
           
            Creates a dataset that shards the input dataset.
            | 
          
          
           | 
            
             BandedTriangularSolve
            
            <T>
            | 
           
            | 
          
          
           | 
            
             Barrier
            
            | 
           
            Defines a barrier that persists across different graph executions.
            | 
          
          
           | 
            
             BarrierClose
            
            | 
           
            Closes the given barrier.
            | 
          
          
           | 
            
             BarrierIncompleteSize
            
            | 
           
            Computes the number of incomplete elements in the given barrier.
            | 
          
          
           | 
            
             BarrierInsertMany
            
            | 
           
            For each key, assigns the respective value to the specified component.
            | 
          
          
           | 
            
             BarrierReadySize
            
            | 
           
            Computes the number of complete elements in the given barrier.
            | 
          
          
           | 
            
             BarrierTakeMany
            
            | 
           
            Takes the given number of completed elements from a barrier.
            | 
          
          
           | 
            
             Batch
            
            | 
           
            Batches all input tensors nondeterministically.
            | 
          
          
           | 
            
             BatchMatMulV2
            
            <T>
            | 
           
            Multiplies slices of two tensors in batches.
            | 
          
          
           | 
            
             BatchMatMulV3
            
            <V>
            | 
           
            Multiplies slices of two tensors in batches.
            | 
          
          
           | 
            
             BatchToSpace
            
            <T>
            | 
           
            BatchToSpace for 4-D tensors of type T.
            | 
          
          
           | 
            
             BatchToSpaceNd
            
            <T>
            | 
           
            BatchToSpace for N-D tensors of type T.
            | 
          
          
           | 
            
             BesselI0
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             BesselI1
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             BesselJ0
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             BesselJ1
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             BesselK0
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             BesselK0e
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             BesselK1
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             BesselK1e
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             BesselY0
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             BesselY1
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             Bitcast
            
            <U>
            | 
           
            Bitcasts a tensor from one type to another without copying data.
            | 
          
          
           | 
            
             BlockLSTM
            
            <T extends Number>
            | 
           
            Computes the LSTM cell forward propagation for all the time steps.
            | 
          
          
           | 
            
             BlockLSTMGrad
            
            <T extends Number>
            | 
           
            Computes the LSTM cell backward propagation for the entire time sequence.
            | 
          
          
           | 
            
             BlockLSTMGradV2
            
            <T extends Number>
            | 
           
            Computes the LSTM cell backward propagation for the entire time sequence.
            | 
          
          
           | 
            
             BlockLSTMV2
            
            <T extends Number>
            | 
           
            Computes the LSTM cell forward propagation for all the time steps.
            | 
          
          
           | 
            
             BoostedTreesAggregateStats
            
            | 
           
            Aggregates the summary of accumulated stats for the batch.
            | 
          
          
           | 
            
             BoostedTreesBucketize
            
            | 
           
            Bucketize each feature based on bucket boundaries.
            | 
          
          
           | 
            
             BoostedTreesCalculateBestFeatureSplit
            
            | 
           
            Calculates gains for each feature and returns the best possible split information for the feature.
            | 
          
          
           | 
            
             BoostedTreesCalculateBestFeatureSplitV2
            
            | 
           
            Calculates gains for each feature and returns the best possible split information for each node.
            | 
          
          
           | 
            
             BoostedTreesCalculateBestGainsPerFeature
            
            | 
           
            Calculates gains for each feature and returns the best possible split information for the feature.
            | 
          
          
           | 
            
             BoostedTreesCenterBias
            
            | 
           
            Calculates the prior from the training data (the bias) and fills in the first node with the logits' prior.
            | 
          
          
           | 
            
             BoostedTreesCreateEnsemble
            
            | 
           
            Creates a tree ensemble model and returns a handle to it.
            | 
          
          
           | 
            
             BoostedTreesCreateQuantileStreamResource
            
            | 
           
            Create the Resource for Quantile Streams.
            | 
          
          
           | 
            
             BoostedTreesDeserializeEnsemble
            
            | 
           
            Deserializes a serialized tree ensemble config and replaces current tree
             
             ensemble.
             
            | 
          
          
           | 
            
             BoostedTreesEnsembleResourceHandleOp
            
            | 
           
            Creates a handle to a BoostedTreesEnsembleResource
            | 
          
          
           | 
            
             BoostedTreesExampleDebugOutputs
            
            | 
           
            Debugging/model interpretability outputs for each example.
            | 
          
          
           | 
            
             BoostedTreesFlushQuantileSummaries
            
            | 
           
            Flush the quantile summaries from each quantile stream resource.
            | 
          
          
           | 
            
             BoostedTreesGetEnsembleStates
            
            | 
           
            Retrieves the tree ensemble resource stamp token, number of trees and growing statistics.
            | 
          
          
           | 
            
             BoostedTreesMakeQuantileSummaries
            
            | 
           
            Makes the summary of quantiles for the batch.
            | 
          
          
           | 
            
             BoostedTreesMakeStatsSummary
            
            | 
           
            Makes the summary of accumulated stats for the batch.
            | 
          
          
           | 
            
             BoostedTreesPredict
            
            | 
           
            Runs multiple additive regression ensemble predictors on input instances and
             
             computes the logits.
             
            | 
          
          
           | 
            
             BoostedTreesQuantileStreamResourceAddSummaries
            
            | 
           
            Add the quantile summaries to each quantile stream resource.
            | 
          
          
           | 
            
             BoostedTreesQuantileStreamResourceDeserialize
            
            | 
           
            Deserialize bucket boundaries and ready flag into current QuantileAccumulator.
            | 
          
          
           | 
            
             BoostedTreesQuantileStreamResourceFlush
            
            | 
           
            Flush the summaries for a quantile stream resource.
            | 
          
          
           | 
            
             BoostedTreesQuantileStreamResourceGetBucketBoundaries
            
            | 
           
            Generate the bucket boundaries for each feature based on accumulated summaries.
            | 
          
          
           | 
            
             BoostedTreesQuantileStreamResourceHandleOp
            
            | 
           
            Creates a handle to a BoostedTreesQuantileStreamResource.
            | 
          
          
           | 
            
             BoostedTreesSerializeEnsemble
            
            | 
           
            Serializes the tree ensemble to a proto.
            | 
          
          
           | 
            
             BoostedTreesSparseAggregateStats
            
            | 
           
            Aggregates the summary of accumulated stats for the batch.
            | 
          
          
           | 
            
             BoostedTreesSparseCalculateBestFeatureSplit
            
            | 
           
            Calculates gains for each feature and returns the best possible split information for the feature.
            | 
          
          
           | 
            
             BoostedTreesTrainingPredict
            
            | 
           
            Runs multiple additive regression ensemble predictors on input instances and
             
             computes the update to cached logits.
             
            | 
          
          
           | 
            
             BoostedTreesUpdateEnsemble
            
            | 
           
            Updates the tree ensemble by either adding a layer to the last tree being grown
             
             or by starting a new tree.
             
            | 
          
          
           | 
            
             BoostedTreesUpdateEnsembleV2
            
            | 
           
            Updates the tree ensemble by adding a layer to the last tree being grown
             
             or by starting a new tree.
             
            | 
          
          
           | 
            
             BroadcastDynamicShape
            
            <T extends Number>
            | 
           
            Return the shape of s0 op s1 with broadcast.
            | 
          
          
           | 
            
             BroadcastGradientArgs
            
            <T extends Number>
            | 
           
            Return the reduction indices for computing gradients of s0 op s1 with broadcast.
            | 
          
          
           | 
            
             BroadcastTo
            
            <T>
            | 
           
            Broadcast an array for a compatible shape.
            | 
          
          
           | 
            
             Bucketize
            
            | 
           
            Bucketizes 'input' based on 'boundaries'.
            | 
          
          
           | 
            
             CSRSparseMatrixComponents
            
            <T>
            | 
           
            Reads out the CSR components at batch `index`.
            | 
          
          
           | 
            
             CSRSparseMatrixToDense
            
            <T>
            | 
           
            Convert a (possibly batched) CSRSparseMatrix to dense.
            | 
          
          
           | 
            
             CSRSparseMatrixToSparseTensor
            
            <T>
            | 
           
            Converts a (possibly batched) CSRSparesMatrix to a SparseTensor.
            | 
          
          
           | 
            
             CSVDataset
            
            | 
           
            | 
          
          
           | 
            
             CSVDatasetV2
            
            | 
           
            | 
          
          
           | 
            
             CTCLossV2
            
            | 
           
            Calculates the CTC Loss (log probability) for each batch entry.
            | 
          
          
           | 
            
             CacheDatasetV2
            
            | 
           
            | 
          
          
           | 
            
             CheckNumericsV2
            
            <T extends Number>
            | 
           
            Checks a tensor for NaN, -Inf and +Inf values.
            | 
          
          
           | 
            
             ChooseFastestDataset
            
            | 
           
            | 
          
          
           | 
            
             ClipByValue
            
            <T>
            | 
           
            Clips tensor values to a specified min and max.
            | 
          
          
           | 
            
             CollectiveBcastRecvV2
            
            <U>
            | 
           
            Receives a tensor value broadcast from another device.
            | 
          
          
           | 
            
             CollectiveBcastSendV2
            
            <T>
            | 
           
            Broadcasts a tensor value to one or more other devices.
            | 
          
          
           | 
            
             CollectiveGather
            
            <T extends Number>
            | 
           
            Mutually accumulates multiple tensors of identical type and shape.
            | 
          
          
           | 
            
             CollectiveGatherV2
            
            <T extends Number>
            | 
           
            Mutually accumulates multiple tensors of identical type and shape.
            | 
          
          
           | 
            
             CollectivePermute
            
            <T>
            | 
           
            An Op to permute tensors across replicated TPU instances.
            | 
          
          
           | 
            
             CollectiveReduceV2
            
            <T extends Number>
            | 
           
            Mutually reduces multiple tensors of identical type and shape.
            | 
          
          
           | 
            
             CombinedNonMaxSuppression
            
            | 
           
            Greedily selects a subset of bounding boxes in descending order of score,
             
             This operation performs non_max_suppression on the inputs per batch, across
 all classes.
             
            | 
          
          
           | 
            
             CompositeTensorVariantFromComponents
            
            | 
           
            Encodes an `ExtensionType` value into a `variant` scalar Tensor.
            | 
          
          
           | 
            
             CompositeTensorVariantToComponents
            
            | 
           
            Decodes a `variant` scalar Tensor into an `ExtensionType` value.
            | 
          
          
           | 
            
             CompressElement
            
            | 
           
            Compresses a dataset element.
            | 
          
          
           | 
            
             ComputeBatchSize
            
            | 
           
            Computes the static batch size of a dataset sans partial batches.
            | 
          
          
           | 
            
             Concat
            
            <T>
            | 
           
            Concatenates tensors along one dimension.
            | 
          
          
           | 
            
             ConfigureDistributedTPU
            
            | 
           
            Sets up the centralized structures for a distributed TPU system.
            | 
          
          
           | 
            
             ConfigureTPUEmbedding
            
            | 
           
            Sets up TPUEmbedding in a distributed TPU system.
            | 
          
          
           | 
            
             Constant
            
            <T>
            | 
           
            An operator producing a constant value.
            | 
          
          
           | 
            
             ConsumeMutexLock
            
            | 
           
            This op consumes a lock created by `MutexLock`.
            | 
          
          
           | 
            
             ControlTrigger
            
            | 
           
            Does nothing.
            | 
          
          
           | 
            
             Copy
            
            <T>
            | 
           
            Copy a tensor from CPU-to-CPU or GPU-to-GPU.
            | 
          
          
           | 
            
             CopyHost
            
            <T>
            | 
           
            Copy a tensor to host.
            | 
          
          
           | 
            
             CountUpTo
            
            <T extends Number>
            | 
           
            Increments 'ref' until it reaches 'limit'.
            | 
          
          
           | 
            
             CrossReplicaSum
            
            <T extends Number>
            | 
           
            An Op to sum inputs across replicated TPU instances.
            | 
          
          
           | 
            
             CudnnRNNBackpropV3
            
            <T extends Number>
            | 
           
            Backprop step of CudnnRNNV3.
            | 
          
          
           | 
            
             CudnnRNNCanonicalToParamsV2
            
            <T extends Number>
            | 
           
            Converts CudnnRNN params from canonical form to usable form.
            | 
          
          
           | 
            
             CudnnRNNParamsToCanonicalV2
            
            <T extends Number>
            | 
           
            Retrieves CudnnRNN params in canonical form.
            | 
          
          
           | 
            
             CudnnRNNV3
            
            <T extends Number>
            | 
           
            A RNN backed by cuDNN.
            | 
          
          
           | 
            
             CumulativeLogsumexp
            
            <T extends Number>
            | 
           
            Compute the cumulative product of the tensor `x` along `axis`.
            | 
          
          
           | 
            
             DataServiceDataset
            
            | 
           
            Creates a dataset that reads data from the tf.data service.
            | 
          
          
           | 
            
             DataServiceDatasetV2
            
            | 
           
            Creates a dataset that reads data from the tf.data service.
            | 
          
          
           | 
            
             DatasetCardinality
            
            | 
           
            Returns the cardinality of `input_dataset`.
            | 
          
          
           | 
            
             DatasetFromGraph
            
            | 
           
            Creates a dataset from the given `graph_def`.
            | 
          
          
           | 
            
             DatasetToGraphV2
            
            | 
           
            Returns a serialized GraphDef representing `input_dataset`.
            | 
          
          
           | 
            
             Dawsn
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             DebugGradientIdentity
            
            <T>
            | 
           
            Identity op for gradient debugging.
            | 
          
          
           | 
            
             DebugGradientRefIdentity
            
            <T>
            | 
           
            Identity op for gradient debugging.
            | 
          
          
           | 
            
             DebugIdentity
            
            <T>
            | 
           
            Provides an identity mapping of the non-Ref type input tensor for debugging.
            | 
          
          
           | 
            
             DebugIdentityV2
            
            <T>
            | 
           
            Debug Identity V2 Op.
            | 
          
          
           | 
            
             DebugNanCount
            
            | 
           
            Debug NaN Value Counter Op.
            | 
          
          
           | 
            
             DebugNumericSummary
            
            | 
           
            Debug Numeric Summary Op.
            | 
          
          
           | 
            
             DebugNumericSummaryV2
            
            <U extends Number>
            | 
           
            Debug Numeric Summary V2 Op.
            | 
          
          
           | 
            
             DecodeImage
            
            <T extends Number>
            | 
           
            Function for decode_bmp, decode_gif, decode_jpeg, and decode_png.
            | 
          
          
           | 
            
             DecodePaddedRaw
            
            <T extends Number>
            | 
           
            Reinterpret the bytes of a string as a vector of numbers.
            | 
          
          
           | 
            
             DecodeProto
            
            | 
           
            The op extracts fields from a serialized protocol buffers message into tensors.
            | 
          
          
           | 
            
             DeepCopy
            
            <T>
            | 
           
            Makes a copy of `x`.
            | 
          
          
           | 
            
             DeleteIterator
            
            | 
           
            A container for an iterator resource.
            | 
          
          
           | 
            
             DeleteMemoryCache
            
            | 
           
            | 
          
          
           | 
            
             DeleteMultiDeviceIterator
            
            | 
           
            A container for an iterator resource.
            | 
          
          
           | 
            
             DeleteRandomSeedGenerator
            
            | 
           
            | 
          
          
           | 
            
             DeleteSeedGenerator
            
            | 
           
            | 
          
          
           | 
            
             DeleteSessionTensor
            
            | 
           
            Delete the tensor specified by its handle in the session.
            | 
          
          
           | 
            
             DenseBincount
            
            <U extends Number>
            | 
           
            Counts the number of occurrences of each value in an integer array.
            | 
          
          
           | 
            
             DenseCountSparseOutput
            
            <U extends Number>
            | 
           
            Performs sparse-output bin counting for a tf.tensor input.
            | 
          
          
           | 
            
             DenseToCSRSparseMatrix
            
            | 
           
            Converts a dense tensor to a (possibly batched) CSRSparseMatrix.
            | 
          
          
           | 
            
             DestroyResourceOp
            
            | 
           
            Deletes the resource specified by the handle.
            | 
          
          
           | 
            
             DestroyTemporaryVariable
            
            <T>
            | 
           
            Destroys the temporary variable and returns its final value.
            | 
          
          
           | 
            
             DeviceIndex
            
            | 
           
            Return the index of device the op runs.
            | 
          
          
           | 
            
             DirectedInterleaveDataset
            
            | 
           
            A substitute for `InterleaveDataset` on a fixed list of `N` datasets.
            | 
          
          
           | 
            
             DrawBoundingBoxesV2
            
            <T extends Number>
            | 
           
            Draw bounding boxes on a batch of images.
            | 
          
          
           | 
            
             DummyIterationCounter
            
            | 
           
            | 
          
          
           | 
            
             DummyMemoryCache
            
            | 
           
            | 
          
          
           | 
            
             DummySeedGenerator
            
            | 
           
            | 
          
          
           | 
            
             DynamicPartition
            
            <T>
            | 
           
            Partitions `data` into `num_partitions` tensors using indices from `partitions`.
            | 
          
          
           | 
            
             DynamicStitch
            
            <T>
            | 
           
            Interleave the values from the `data` tensors into a single tensor.
            | 
          
          
           | 
            
             EditDistance
            
            | 
           
            Computes the (possibly normalized) Levenshtein Edit Distance.
            | 
          
          
           | 
            
             Eig
            
            <U>
            | 
           
            Computes the eigen decomposition of one or more square matrices.
            | 
          
          
           | 
            
             Einsum
            
            <T>
            | 
           
            Tensor contraction according to Einstein summation convention.
            | 
          
          
           | 
            
             Empty
            
            <T>
            | 
           
            Creates a tensor with the given shape.
            | 
          
          
           | 
            
             EmptyTensorList
            
            | 
           
            Creates and returns an empty tensor list.
            | 
          
          
           | 
            
             EmptyTensorMap
            
            | 
           
            Creates and returns an empty tensor map.
            | 
          
          
           | 
            
             EncodeProto
            
            | 
           
            The op serializes protobuf messages provided in the input tensors.
            | 
          
          
           | 
            
             EnqueueTPUEmbeddingIntegerBatch
            
            | 
           
            An op that enqueues a list of input batch tensors to TPUEmbedding.
            | 
          
          
           | 
            
             EnqueueTPUEmbeddingRaggedTensorBatch
            
            | 
           
            Eases the porting of code that uses tf.nn.embedding_lookup().
            | 
          
          
           | 
            
             EnqueueTPUEmbeddingSparseBatch
            
            | 
           
            An op that enqueues TPUEmbedding input indices from a SparseTensor.
            | 
          
          
           | 
            
             EnqueueTPUEmbeddingSparseTensorBatch
            
            | 
           
            Eases the porting of code that uses tf.nn.embedding_lookup_sparse().
            | 
          
          
           | 
            
             EnsureShape
            
            <T>
            | 
           
            Ensures that the tensor's shape matches the expected shape.
            | 
          
          
           | 
            
             Enter
            
            <T>
            | 
           
            Creates or finds a child frame, and makes `data` available to the child frame.
            | 
          
          
           | 
            
             Erfinv
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             EuclideanNorm
            
            <T>
            | 
           
            Computes the euclidean norm of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             Exit
            
            <T>
            | 
           
            Exits the current frame to its parent frame.
            | 
          
          
           | 
            
             ExpandDims
            
            <T>
            | 
           
            Inserts a dimension of 1 into a tensor's shape.
            | 
          
          
           | 
            
             ExperimentalAutoShardDataset
            
            | 
           
            Creates a dataset that shards the input dataset.
            | 
          
          
           | 
            
             ExperimentalBytesProducedStatsDataset
            
            | 
           
            Records the bytes size of each element of `input_dataset` in a StatsAggregator.
            | 
          
          
           | 
            
             ExperimentalChooseFastestDataset
            
            | 
           
            | 
          
          
           | 
            
             ExperimentalDatasetCardinality
            
            | 
           
            Returns the cardinality of `input_dataset`.
            | 
          
          
           | 
            
             ExperimentalDatasetToTFRecord
            
            | 
           
            Writes the given dataset to the given file using the TFRecord format.
            | 
          
          
           | 
            
             ExperimentalDenseToSparseBatchDataset
            
            | 
           
            Creates a dataset that batches input elements into a SparseTensor.
            | 
          
          
           | 
            
             ExperimentalLatencyStatsDataset
            
            | 
           
            Records the latency of producing `input_dataset` elements in a StatsAggregator.
            | 
          
          
           | 
            
             ExperimentalMatchingFilesDataset
            
            | 
           
            | 
          
          
           | 
            
             ExperimentalMaxIntraOpParallelismDataset
            
            | 
           
            Creates a dataset that overrides the maximum intra-op parallelism.
            | 
          
          
           | 
            
             ExperimentalParseExampleDataset
            
            | 
           
            Transforms `input_dataset` containing `Example` protos as vectors of DT_STRING into a dataset of `Tensor` or `SparseTensor` objects representing the parsed features.
            | 
          
          
           | 
            
             ExperimentalPrivateThreadPoolDataset
            
            | 
           
            Creates a dataset that uses a custom thread pool to compute `input_dataset`.
            | 
          
          
           | 
            
             ExperimentalRandomDataset
            
            | 
           
            Creates a Dataset that returns pseudorandom numbers.
            | 
          
          
           | 
            
             ExperimentalRebatchDataset
            
            | 
           
            Creates a dataset that changes the batch size.
            | 
          
          
           | 
            
             ExperimentalSetStatsAggregatorDataset
            
            | 
           
            | 
          
          
           | 
            
             ExperimentalSlidingWindowDataset
            
            | 
           
            Creates a dataset that passes a sliding window over `input_dataset`.
            | 
          
          
           | 
            
             ExperimentalSqlDataset
            
            | 
           
            Creates a dataset that executes a SQL query and emits rows of the result set.
            | 
          
          
           | 
            
             ExperimentalStatsAggregatorHandle
            
            | 
           
            Creates a statistics manager resource.
            | 
          
          
           | 
            
             ExperimentalStatsAggregatorSummary
            
            | 
           
            Produces a summary of any statistics recorded by the given statistics manager.
            | 
          
          
           | 
            
             ExperimentalUnbatchDataset
            
            | 
           
            A dataset that splits the elements of its input into multiple elements.
            | 
          
          
           | 
            
             Expint
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             ExtractGlimpseV2
            
            | 
           
            Extracts a glimpse from the input tensor.
            | 
          
          
           | 
            
             ExtractVolumePatches
            
            <T extends Number>
            | 
           
            Extract `patches` from `input` and put them in the `"depth"` output dimension.
            | 
          
          
           | 
            
             Fill
            
            <U>
            | 
           
            Creates a tensor filled with a scalar value.
            | 
          
          
           | 
            
             FinalizeDataset
            
            | 
           
            Creates a dataset by applying `tf.data.Options` to `input_dataset`.
            | 
          
          
           | 
            
             Fingerprint
            
            | 
           
            Generates fingerprint values.
            | 
          
          
           | 
            
             FresnelCos
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             FresnelSin
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             FusedBatchNormGradV3
            
            <T extends Number, U extends Number>
            | 
           
            Gradient for batch normalization.
            | 
          
          
           | 
            
             FusedBatchNormV3
            
            <T extends Number, U extends Number>
            | 
           
            Batch normalization.
            | 
          
          
           | 
            
             GRUBlockCell
            
            <T extends Number>
            | 
           
            Computes the GRU cell forward propagation for 1 time step.
            | 
          
          
           | 
            
             GRUBlockCellGrad
            
            <T extends Number>
            | 
           
            Computes the GRU cell back-propagation for 1 time step.
            | 
          
          
           | 
            
             Gather
            
            <T>
            | 
           
            Gather slices from `params` axis `axis` according to `indices`.
            | 
          
          
           | 
            
             GatherNd
            
            <T>
            | 
           
            Gather slices from `params` into a Tensor with shape specified by `indices`.
            | 
          
          
           | 
            
             GenerateBoundingBoxProposals
            
            | 
           
            This op produces Region of Interests from given bounding boxes(bbox_deltas) encoded wrt anchors according to eq.2 in arXiv:1506.01497
             
             The op selects top `pre_nms_topn` scoring boxes, decodes them with respect to anchors,
       applies non-maximal suppression on overlapping boxes with higher than
       `nms_threshold` intersection-over-union (iou) value, discarding boxes where shorter
       side is less than `min_size`.
             
            | 
          
          
           | 
            
             GetOptions
            
            | 
           
            Returns the `tf.data.Options` attached to `input_dataset`.
            | 
          
          
           | 
            
             GetSessionHandle
            
            | 
           
            Store the input tensor in the state of the current session.
            | 
          
          
           | 
            
             GetSessionTensor
            
            <T>
            | 
           
            Get the value of the tensor specified by its handle.
            | 
          
          
           | 
            
             GuaranteeConst
            
            <T>
            | 
           
            Gives a guarantee to the TF runtime that the input tensor is a constant.
            | 
          
          
           | 
            
             HashTable
            
            | 
           
            Creates a non-initialized hash table.
            | 
          
          
           | 
            
             HistogramFixedWidth
            
            <U extends Number>
            | 
           
            Return histogram of values.
            | 
          
          
           | 
            
             Identity
            
            <T>
            | 
           
            Return a tensor with the same shape and contents as the input tensor or value.
            | 
          
          
           | 
            
             IdentityN
            
            | 
           
            Returns a list of tensors with the same shapes and contents as the input
             
             tensors.
             
            | 
          
          
           | 
            
             IgnoreErrorsDataset
            
            | 
           
            Creates a dataset that contains the elements of `input_dataset` ignoring errors.
            | 
          
          
           | 
            
             ImageProjectiveTransformV2
            
            <T extends Number>
            | 
           
            Applies the given transform to each of the images.
            | 
          
          
           | 
            
             ImageProjectiveTransformV3
            
            <T extends Number>
            | 
           
            Applies the given transform to each of the images.
            | 
          
          
           | 
            
             ImmutableConst
            
            <T>
            | 
           
            Returns immutable tensor from memory region.
            | 
          
          
           | 
            
             InfeedDequeue
            
            <T>
            | 
           
            A placeholder op for a value that will be fed into the computation.
            | 
          
          
           | 
            
             InfeedDequeueTuple
            
            | 
           
            Fetches multiple values from infeed as an XLA tuple.
            | 
          
          
           | 
            
             InfeedEnqueue
            
            | 
           
            An op which feeds a single Tensor value into the computation.
            | 
          
          
           | 
            
             InfeedEnqueuePrelinearizedBuffer
            
            | 
           
            An op which enqueues prelinearized buffer into TPU infeed.
            | 
          
          
           | 
            
             InfeedEnqueueTuple
            
            | 
           
            Feeds multiple Tensor values into the computation as an XLA tuple.
            | 
          
          
           | 
            
             InitializeTable
            
            | 
           
            Table initializer that takes two tensors for keys and values respectively.
            | 
          
          
           | 
            
             InitializeTableFromDataset
            
            | 
           
            | 
          
          
           | 
            
             InitializeTableFromTextFile
            
            | 
           
            Initializes a table from a text file.
            | 
          
          
           | 
            
             InplaceAdd
            
            <T>
            | 
           
            Adds v into specified rows of x.
            | 
          
          
           | 
            
             InplaceSub
            
            <T>
            | 
           
            Subtracts `v` into specified rows of `x`.
            | 
          
          
           | 
            
             InplaceUpdate
            
            <T>
            | 
           
            Updates specified rows 'i' with values 'v'.
            | 
          
          
           | 
            
             IsBoostedTreesEnsembleInitialized
            
            | 
           
            Checks whether a tree ensemble has been initialized.
            | 
          
          
           | 
            
             IsBoostedTreesQuantileStreamResourceInitialized
            
            | 
           
            Checks whether a quantile stream has been initialized.
            | 
          
          
           | 
            
             IsVariableInitialized
            
            | 
           
            Checks whether a tensor has been initialized.
            | 
          
          
           | 
            
             IsotonicRegression
            
            <U extends Number>
            | 
           
            Solves a batch of isotonic regression problems.
            | 
          
          
           | 
            
             IteratorGetDevice
            
            | 
           
            Returns the name of the device on which `resource` has been placed.
            | 
          
          
           | 
            
             KMC2ChainInitialization
            
            | 
           
            Returns the index of a data point that should be added to the seed set.
            | 
          
          
           | 
            
             KmeansPlusPlusInitialization
            
            | 
           
            Selects num_to_sample rows of input using the KMeans++ criterion.
            | 
          
          
           | 
            
             KthOrderStatistic
            
            | 
           
            Computes the Kth order statistic of a data set.
            | 
          
          
           | 
            
             LMDBDataset
            
            | 
           
            Creates a dataset that emits the key-value pairs in one or more LMDB files.
            | 
          
          
           | 
            
             LSTMBlockCell
            
            <T extends Number>
            | 
           
            Computes the LSTM cell forward propagation for 1 time step.
            | 
          
          
           | 
            
             LSTMBlockCellGrad
            
            <T extends Number>
            | 
           
            Computes the LSTM cell backward propagation for 1 timestep.
            | 
          
          
           | 
            
             LinSpace
            
            <T extends Number>
            | 
           
            Generates values in an interval.
            | 
          
          
           | 
            
             LoadTPUEmbeddingADAMParameters
            
            | 
           
            Load ADAM embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingADAMParametersGradAccumDebug
            
            | 
           
            Load ADAM embedding parameters with debug support.
            | 
          
          
           | 
            
             LoadTPUEmbeddingAdadeltaParameters
            
            | 
           
            Load Adadelta embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingAdadeltaParametersGradAccumDebug
            
            | 
           
            Load Adadelta parameters with debug support.
            | 
          
          
           | 
            
             LoadTPUEmbeddingAdagradParameters
            
            | 
           
            Load Adagrad embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingAdagradParametersGradAccumDebug
            
            | 
           
            Load Adagrad embedding parameters with debug support.
            | 
          
          
           | 
            
             LoadTPUEmbeddingCenteredRMSPropParameters
            
            | 
           
            Load centered RMSProp embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingFTRLParameters
            
            | 
           
            Load FTRL embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingFTRLParametersGradAccumDebug
            
            | 
           
            Load FTRL embedding parameters with debug support.
            | 
          
          
           | 
            
             LoadTPUEmbeddingFrequencyEstimatorParameters
            
            | 
           
            Load frequency estimator embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingFrequencyEstimatorParametersGradAccumDebug
            
            | 
           
            Load frequency estimator embedding parameters with debug support.
            | 
          
          
           | 
            
             LoadTPUEmbeddingMDLAdagradLightParameters
            
            | 
           
            Load MDL Adagrad Light embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingMomentumParameters
            
            | 
           
            Load Momentum embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingMomentumParametersGradAccumDebug
            
            | 
           
            Load Momentum embedding parameters with debug support.
            | 
          
          
           | 
            
             LoadTPUEmbeddingProximalAdagradParameters
            
            | 
           
            Load proximal Adagrad embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug
            
            | 
           
            Load proximal Adagrad embedding parameters with debug support.
            | 
          
          
           | 
            
             LoadTPUEmbeddingProximalYogiParameters
            
            | 
           
            | 
          
          
           | 
            
             LoadTPUEmbeddingProximalYogiParametersGradAccumDebug
            
            | 
           
            | 
          
          
           | 
            
             LoadTPUEmbeddingRMSPropParameters
            
            | 
           
            Load RMSProp embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingRMSPropParametersGradAccumDebug
            
            | 
           
            Load RMSProp embedding parameters with debug support.
            | 
          
          
           | 
            
             LoadTPUEmbeddingStochasticGradientDescentParameters
            
            | 
           
            Load SGD embedding parameters.
            | 
          
          
           | 
            
             LoadTPUEmbeddingStochasticGradientDescentParametersGradAccumDebug
            
            | 
           
            Load SGD embedding parameters.
            | 
          
          
           | 
            
             LookupTableExport
            
            <T, U>
            | 
           
            Outputs all keys and values in the table.
            | 
          
          
           | 
            
             LookupTableFind
            
            <U>
            | 
           
            Looks up keys in a table, outputs the corresponding values.
            | 
          
          
           | 
            
             LookupTableImport
            
            | 
           
            Replaces the contents of the table with the specified keys and values.
            | 
          
          
           | 
            
             LookupTableInsert
            
            | 
           
            Updates the table to associates keys with values.
            | 
          
          
           | 
            
             LookupTableRemove
            
            | 
           
            Removes keys and its associated values from a table.
            | 
          
          
           | 
            
             LookupTableSize
            
            | 
           
            Computes the number of elements in the given table.
            | 
          
          
           | 
            
             LoopCond
            
            | 
           
            Forwards the input to the output.
            | 
          
          
           | 
            
             LowerBound
            
            <U extends Number>
            | 
           
            Applies lower_bound(sorted_search_values, values) along each row.
            | 
          
          
           | 
            
             Lu
            
            <T, U extends Number>
            | 
           
            Computes the LU decomposition of one or more square matrices.
            | 
          
          
           | 
            
             MakeUnique
            
            | 
           
            Make all elements in the non-Batch dimension unique, but \"close\" to
             
             their initial value.
             
            | 
          
          
           | 
            
             MapClear
            
            | 
           
            Op removes all elements in the underlying container.
            | 
          
          
           | 
            
             MapIncompleteSize
            
            | 
           
            Op returns the number of incomplete elements in the underlying container.
            | 
          
          
           | 
            
             MapPeek
            
            | 
           
            Op peeks at the values at the specified key.
            | 
          
          
           | 
            
             MapSize
            
            | 
           
            Op returns the number of elements in the underlying container.
            | 
          
          
           | 
            
             MapStage
            
            | 
           
            Stage (key, values) in the underlying container which behaves like a hashtable.
            | 
          
          
           | 
            
             MapUnstage
            
            | 
           
            Op removes and returns the values associated with the key
             
             from the underlying container.
             
            | 
          
          
           | 
            
             MapUnstageNoKey
            
            | 
           
            Op removes and returns a random (key, value)
             
             from the underlying container.
             
            | 
          
          
           | 
            
             MatrixDiagPartV2
            
            <T>
            | 
           
            Returns the batched diagonal part of a batched tensor.
            | 
          
          
           | 
            
             MatrixDiagPartV3
            
            <T>
            | 
           
            Returns the batched diagonal part of a batched tensor.
            | 
          
          
           | 
            
             MatrixDiagV2
            
            <T>
            | 
           
            Returns a batched diagonal tensor with given batched diagonal values.
            | 
          
          
           | 
            
             MatrixDiagV3
            
            <T>
            | 
           
            Returns a batched diagonal tensor with given batched diagonal values.
            | 
          
          
           | 
            
             MatrixSetDiagV2
            
            <T>
            | 
           
            Returns a batched matrix tensor with new batched diagonal values.
            | 
          
          
           | 
            
             MatrixSetDiagV3
            
            <T>
            | 
           
            Returns a batched matrix tensor with new batched diagonal values.
            | 
          
          
           | 
            
             Max
            
            <T>
            | 
           
            Computes the maximum of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             MaxIntraOpParallelismDataset
            
            | 
           
            Creates a dataset that overrides the maximum intra-op parallelism.
            | 
          
          
           | 
            
             Merge
            
            <T>
            | 
           
            Forwards the value of an available tensor from `inputs` to `output`.
            | 
          
          
           | 
            
             Min
            
            <T>
            | 
           
            Computes the minimum of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             MirrorPad
            
            <T>
            | 
           
            Pads a tensor with mirrored values.
            | 
          
          
           | 
            
             MirrorPadGrad
            
            <T>
            | 
           
            Gradient op for `MirrorPad` op.
            | 
          
          
           | 
            
             MlirPassthroughOp
            
            | 
           
            Wraps an arbitrary MLIR computation expressed as a module with a main() function.
            | 
          
          
           | 
            
             MulNoNan
            
            <T>
            | 
           
            Returns x * y element-wise.
            | 
          
          
           | 
            
             MutableDenseHashTable
            
            | 
           
            Creates an empty hash table that uses tensors as the backing store.
            | 
          
          
           | 
            
             MutableHashTable
            
            | 
           
            Creates an empty hash table.
            | 
          
          
           | 
            
             MutableHashTableOfTensors
            
            | 
           
            Creates an empty hash table.
            | 
          
          
           | 
            
             Mutex
            
            | 
           
            Creates a Mutex resource that can be locked by `MutexLock`.
            | 
          
          
           | 
            
             MutexLock
            
            | 
           
            Locks a mutex resource.
            | 
          
          
           | 
            
             NcclAllReduce
            
            <T extends Number>
            | 
           
            Outputs a tensor containing the reduction across all input tensors.
            | 
          
          
           | 
            
             NcclBroadcast
            
            <T extends Number>
            | 
           
            Sends `input` to all devices that are connected to the output.
            | 
          
          
           | 
            
             NcclReduce
            
            <T extends Number>
            | 
           
            Reduces `input` from `num_devices` using `reduction` to a single device.
            | 
          
          
           | 
            
             Ndtri
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             NearestNeighbors
            
            | 
           
            Selects the k nearest centers for each point.
            | 
          
          
           | 
            
             NextAfter
            
            <T extends Number>
            | 
           
            Returns the next representable value of `x1` in the direction of `x2`, element-wise.
            | 
          
          
           | 
            
             NextIteration
            
            <T>
            | 
           
            Makes its input available to the next iteration.
            | 
          
          
           | 
            
             NoOp
            
            | 
           
            Does nothing.
            | 
          
          
           | 
            
             NonDeterministicInts
            
            <U>
            | 
           
            Non-deterministically generates some integers.
            | 
          
          
           | 
            
             NonMaxSuppressionV5
            
            <T extends Number>
            | 
           
            Greedily selects a subset of bounding boxes in descending order of score,
             
             pruning away boxes that have high intersection-over-union (IOU) overlap
 with previously selected boxes.
             
            | 
          
          
           | 
            
             NonSerializableDataset
            
            | 
           
            | 
          
          
           | 
            
             OneHot
            
            <U>
            | 
           
            Returns a one-hot tensor.
            | 
          
          
           | 
            
             OnesLike
            
            <T>
            | 
           
            Returns a tensor of ones with the same shape and type as x.
            | 
          
          
           | 
            
             OptimizeDatasetV2
            
            | 
           
            Creates a dataset by applying related optimizations to `input_dataset`.
            | 
          
          
           | 
            
             OptionsDataset
            
            | 
           
            Creates a dataset by attaching tf.data.Options to `input_dataset`.
            | 
          
          
           | 
            
             OrderedMapClear
            
            | 
           
            Op removes all elements in the underlying container.
            | 
          
          
           | 
            
             OrderedMapIncompleteSize
            
            | 
           
            Op returns the number of incomplete elements in the underlying container.
            | 
          
          
           | 
            
             OrderedMapPeek
            
            | 
           
            Op peeks at the values at the specified key.
            | 
          
          
           | 
            
             OrderedMapSize
            
            | 
           
            Op returns the number of elements in the underlying container.
            | 
          
          
           | 
            
             OrderedMapStage
            
            | 
           
            Stage (key, values) in the underlying container which behaves like a ordered
             
             associative container.
             
            | 
          
          
           | 
            
             OrderedMapUnstage
            
            | 
           
            Op removes and returns the values associated with the key
             
             from the underlying container.
             
            | 
          
          
           | 
            
             OrderedMapUnstageNoKey
            
            | 
           
            Op removes and returns the (key, value) element with the smallest
             
             key from the underlying container.
             
            | 
          
          
           | 
            
             OutfeedDequeue
            
            <T>
            | 
           
            Retrieves a single tensor from the computation outfeed.
            | 
          
          
           | 
            
             OutfeedDequeueTuple
            
            | 
           
            Retrieve multiple values from the computation outfeed.
            | 
          
          
           | 
            
             OutfeedDequeueTupleV2
            
            | 
           
            Retrieve multiple values from the computation outfeed.
            | 
          
          
           | 
            
             OutfeedDequeueV2
            
            <T>
            | 
           
            Retrieves a single tensor from the computation outfeed.
            | 
          
          
           | 
            
             OutfeedEnqueue
            
            | 
           
            Enqueue a Tensor on the computation outfeed.
            | 
          
          
           | 
            
             OutfeedEnqueueTuple
            
            | 
           
            Enqueue multiple Tensor values on the computation outfeed.
            | 
          
          
           | 
            
             Pad
            
            <T>
            | 
           
            Pads a tensor.
            | 
          
          
           | 
            
             ParallelBatchDataset
            
            | 
           
            | 
          
          
           | 
            
             ParallelConcat
            
            <T>
            | 
           
            Concatenates a list of `N` tensors along the first dimension.
            | 
          
          
           | 
            
             ParallelDynamicStitch
            
            <T>
            | 
           
            Interleave the values from the `data` tensors into a single tensor.
            | 
          
          
           | 
            
             ParseExampleDatasetV2
            
            | 
           
            Transforms `input_dataset` containing `Example` protos as vectors of DT_STRING into a dataset of `Tensor` or `SparseTensor` objects representing the parsed features.
            | 
          
          
           | 
            
             ParseExampleV2
            
            | 
           
            Transforms a vector of tf.Example protos (as strings) into typed tensors.
            | 
          
          
           | 
            
             ParseSequenceExampleV2
            
            | 
           
            Transforms a vector of tf.io.SequenceExample protos (as strings) into
 typed tensors.
            | 
          
          
           | 
            
             Placeholder
            
            <T>
            | 
           
            A placeholder op for a value that will be fed into the computation.
            | 
          
          
           | 
            
             PlaceholderWithDefault
            
            <T>
            | 
           
            A placeholder op that passes through `input` when its output is not fed.
            | 
          
          
           | 
            
             Prelinearize
            
            | 
           
            An op which linearizes one Tensor value to an opaque variant tensor.
            | 
          
          
           | 
            
             PrelinearizeTuple
            
            | 
           
            An op which linearizes multiple Tensor values to an opaque variant tensor.
            | 
          
          
           | 
            
             Print
            
            | 
           
            Prints a string scalar.
            | 
          
          
           | 
            
             PrivateThreadPoolDataset
            
            | 
           
            Creates a dataset that uses a custom thread pool to compute `input_dataset`.
            | 
          
          
           | 
            
             Prod
            
            <T>
            | 
           
            Computes the product of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             QuantizeAndDequantizeV4
            
            <T extends Number>
            | 
           
            Quantizes then dequantizes a tensor.
            | 
          
          
           | 
            
             QuantizeAndDequantizeV4Grad
            
            <T extends Number>
            | 
           
            Returns the gradient of `QuantizeAndDequantizeV4`.
            | 
          
          
           | 
            
             QuantizedConcat
            
            <T>
            | 
           
            Concatenates quantized tensors along one dimension.
            | 
          
          
           | 
            
             QuantizedConcatV2
            
            <T>
            | 
           
            | 
          
          
           | 
            
             QuantizedConv2DAndRelu
            
            <V>
            | 
           
            | 
          
          
           | 
            
             QuantizedConv2DAndReluAndRequantize
            
            <V>
            | 
           
            | 
          
          
           | 
            
             QuantizedConv2DAndRequantize
            
            <V>
            | 
           
            | 
          
          
           | 
            
             QuantizedConv2DPerChannel
            
            <V>
            | 
           
            Computes QuantizedConv2D per channel.
            | 
          
          
           | 
            
             QuantizedConv2DWithBias
            
            <V>
            | 
           
            | 
          
          
           | 
            
             QuantizedConv2DWithBiasAndRelu
            
            <V>
            | 
           
            | 
          
          
           | 
            
             QuantizedConv2DWithBiasAndReluAndRequantize
            
            <W>
            | 
           
            | 
          
          
           | 
            
             QuantizedConv2DWithBiasAndRequantize
            
            <W>
            | 
           
            | 
          
          
           | 
            
             QuantizedConv2DWithBiasSignedSumAndReluAndRequantize
            
            <X>
            | 
           
            | 
          
          
           | 
            
             QuantizedConv2DWithBiasSumAndRelu
            
            <V>
            | 
           
            | 
          
          
           | 
            
             QuantizedConv2DWithBiasSumAndReluAndRequantize
            
            <X>
            | 
           
            | 
          
          
           | 
            
             QuantizedDepthwiseConv2D
            
            <V>
            | 
           
            Computes quantized depthwise Conv2D.
            | 
          
          
           | 
            
             QuantizedDepthwiseConv2DWithBias
            
            <V>
            | 
           
            Computes quantized depthwise Conv2D with Bias.
            | 
          
          
           | 
            
             QuantizedDepthwiseConv2DWithBiasAndRelu
            
            <V>
            | 
           
            Computes quantized depthwise Conv2D with Bias and Relu.
            | 
          
          
           | 
            
             QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize
            
            <W>
            | 
           
            Computes quantized depthwise Conv2D with Bias, Relu and Requantize.
            | 
          
          
           | 
            
             QuantizedMatMulWithBias
            
            <W>
            | 
           
            Performs a quantized matrix multiplication of `a` by the matrix `b` with bias
 add.
            | 
          
          
           | 
            
             QuantizedMatMulWithBiasAndDequantize
            
            <W extends Number>
            | 
           
            | 
          
          
           | 
            
             QuantizedMatMulWithBiasAndRelu
            
            <V>
            | 
           
            Perform a quantized matrix multiplication of  `a` by the matrix `b` with bias
 add and relu fusion.
            | 
          
          
           | 
            
             QuantizedMatMulWithBiasAndReluAndRequantize
            
            <W>
            | 
           
            Perform a quantized matrix multiplication of  `a` by the matrix `b` with bias
 add and relu and requantize fusion.
            | 
          
          
           | 
            
             QuantizedMatMulWithBiasAndRequantize
            
            <W>
            | 
           
            | 
          
          
           | 
            
             QuantizedReshape
            
            <T>
            | 
           
            Reshapes a quantized tensor as per the Reshape op.
            | 
          
          
           | 
            
             RaggedBincount
            
            <U extends Number>
            | 
           
            Counts the number of occurrences of each value in an integer array.
            | 
          
          
           | 
            
             RaggedCountSparseOutput
            
            <U extends Number>
            | 
           
            Performs sparse-output bin counting for a ragged tensor input.
            | 
          
          
           | 
            
             RaggedCross
            
            <T, U extends Number>
            | 
           
            Generates a feature cross from a list of tensors, and returns it as a
 RaggedTensor.
            | 
          
          
           | 
            
             RaggedGather
            
            <T extends Number, U>
            | 
           
            Gather ragged slices from `params` axis `0` according to `indices`.
            | 
          
          
           | 
            
             RaggedRange
            
            <U extends Number, T extends Number>
            | 
           
            Returns a `RaggedTensor` containing the specified sequences of numbers.
            | 
          
          
           | 
            
             RaggedTensorFromVariant
            
            <U extends Number, T>
            | 
           
            Decodes a `variant` Tensor into a `RaggedTensor`.
            | 
          
          
           | 
            
             RaggedTensorToSparse
            
            <U>
            | 
           
            Converts a `RaggedTensor` into a `SparseTensor` with the same values.
            | 
          
          
           | 
            
             RaggedTensorToTensor
            
            <U>
            | 
           
            Create a dense tensor from a ragged tensor, possibly altering its shape.
            | 
          
          
           | 
            
             RaggedTensorToVariant
            
            | 
           
            Encodes a `RaggedTensor` into a `variant` Tensor.
            | 
          
          
           | 
            
             RaggedTensorToVariantGradient
            
            <U>
            | 
           
            Helper used to compute the gradient for `RaggedTensorToVariant`.
            | 
          
          
           | 
            
             Range
            
            <T extends Number>
            | 
           
            Creates a sequence of numbers.
            | 
          
          
           | 
            
             Rank
            
            | 
           
            Returns the rank of a tensor.
            | 
          
          
           | 
            
             ReadVariableOp
            
            <T>
            | 
           
            Reads the value of a variable.
            | 
          
          
           | 
            
             RebatchDataset
            
            | 
           
            Creates a dataset that changes the batch size.
            | 
          
          
           | 
            
             RebatchDatasetV2
            
            | 
           
            Creates a dataset that changes the batch size.
            | 
          
          
           | 
            
             Recv
            
            <T>
            | 
           
            Receives the named tensor from send_device on recv_device.
            | 
          
          
           | 
            
             RecvTPUEmbeddingActivations
            
            | 
           
            An op that receives embedding activations on the TPU.
            | 
          
          
           | 
            
             ReduceAll
            
            | 
           
            Computes the "logical and" of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             ReduceAny
            
            | 
           
            Computes the "logical or" of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             ReduceMax
            
            <T>
            | 
           
            Computes the maximum of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             ReduceMin
            
            <T>
            | 
           
            Computes the minimum of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             ReduceProd
            
            <T>
            | 
           
            Computes the product of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             ReduceSum
            
            <T>
            | 
           
            Computes the sum of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             RefEnter
            
            <T>
            | 
           
            Creates or finds a child frame, and makes `data` available to the child frame.
            | 
          
          
           | 
            
             RefExit
            
            <T>
            | 
           
            Exits the current frame to its parent frame.
            | 
          
          
           | 
            
             RefIdentity
            
            <T>
            | 
           
            Return the same ref tensor as the input ref tensor.
            | 
          
          
           | 
            
             RefMerge
            
            <T>
            | 
           
            Forwards the value of an available tensor from `inputs` to `output`.
            | 
          
          
           | 
            
             RefNextIteration
            
            <T>
            | 
           
            Makes its input available to the next iteration.
            | 
          
          
           | 
            
             RefSelect
            
            <T>
            | 
           
            Forwards the `index`th element of `inputs` to `output`.
            | 
          
          
           | 
            
             RefSwitch
            
            <T>
            | 
           
            Forwards the ref tensor `data` to the output port determined by `pred`.
            | 
          
          
           | 
            
             RegisterDataset
            
            | 
           
            Registers a dataset with the tf.data service.
            | 
          
          
           | 
            
             RequantizationRangePerChannel
            
            | 
           
            Computes requantization range per channel.
            | 
          
          
           | 
            
             RequantizePerChannel
            
            <U>
            | 
           
            Requantizes input with min and max values known per channel.
            | 
          
          
           | 
            
             Reshape
            
            <T>
            | 
           
            Reshapes a tensor.
            | 
          
          
           | 
            
             ResourceAccumulatorApplyGradient
            
            | 
           
            Applies a gradient to a given accumulator.
            | 
          
          
           | 
            
             ResourceAccumulatorNumAccumulated
            
            | 
           
            Returns the number of gradients aggregated in the given accumulators.
            | 
          
          
           | 
            
             ResourceAccumulatorSetGlobalStep
            
            | 
           
            Updates the accumulator with a new value for global_step.
            | 
          
          
           | 
            
             ResourceAccumulatorTakeGradient
            
            <T>
            | 
           
            Extracts the average gradient in the given ConditionalAccumulator.
            | 
          
          
           | 
            
             ResourceApplyAdagradV2
            
            | 
           
            Update '*var' according to the adagrad scheme.
            | 
          
          
           | 
            
             ResourceApplyAdamWithAmsgrad
            
            | 
           
            Update '*var' according to the Adam algorithm.
            | 
          
          
           | 
            
             ResourceApplyKerasMomentum
            
            | 
           
            Update '*var' according to the momentum scheme.
            | 
          
          
           | 
            
             ResourceConditionalAccumulator
            
            | 
           
            A conditional accumulator for aggregating gradients.
            | 
          
          
           | 
            
             ResourceCountUpTo
            
            <T extends Number>
            | 
           
            Increments variable pointed to by 'resource' until it reaches 'limit'.
            | 
          
          
           | 
            
             ResourceGather
            
            <U>
            | 
           
            Gather slices from the variable pointed to by `resource` according to `indices`.
            | 
          
          
           | 
            
             ResourceGatherNd
            
            <U>
            | 
           
            | 
          
          
           | 
            
             ResourceScatterAdd
            
            | 
           
            Adds sparse updates to the variable referenced by `resource`.
            | 
          
          
           | 
            
             ResourceScatterDiv
            
            | 
           
            Divides sparse updates into the variable referenced by `resource`.
            | 
          
          
           | 
            
             ResourceScatterMax
            
            | 
           
            Reduces sparse updates into the variable referenced by `resource` using the `max` operation.
            | 
          
          
           | 
            
             ResourceScatterMin
            
            | 
           
            Reduces sparse updates into the variable referenced by `resource` using the `min` operation.
            | 
          
          
           | 
            
             ResourceScatterMul
            
            | 
           
            Multiplies sparse updates into the variable referenced by `resource`.
            | 
          
          
           | 
            
             ResourceScatterNdAdd
            
            | 
           
            Applies sparse addition to individual values or slices in a Variable.
            | 
          
          
           | 
            
             ResourceScatterNdMax
            
            | 
           
            | 
          
          
           | 
            
             ResourceScatterNdMin
            
            | 
           
            | 
          
          
           | 
            
             ResourceScatterNdSub
            
            | 
           
            Applies sparse subtraction to individual values or slices in a Variable.
            | 
          
          
           | 
            
             ResourceScatterNdUpdate
            
            | 
           
            Applies sparse `updates` to individual values or slices within a given
             
             variable according to `indices`.
             
            | 
          
          
           | 
            
             ResourceScatterSub
            
            | 
           
            Subtracts sparse updates from the variable referenced by `resource`.
            | 
          
          
           | 
            
             ResourceScatterUpdate
            
            | 
           
            Assigns sparse updates to the variable referenced by `resource`.
            | 
          
          
           | 
            
             ResourceSparseApplyAdagradV2
            
            | 
           
            Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
            | 
          
          
           | 
            
             ResourceSparseApplyKerasMomentum
            
            | 
           
            Update relevant entries in '*var' and '*accum' according to the momentum scheme.
            | 
          
          
           | 
            
             ResourceStridedSliceAssign
            
            | 
           
            Assign `value` to the sliced l-value reference of `ref`.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingADAMParameters
            
            | 
           
            Retrieve ADAM embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingADAMParametersGradAccumDebug
            
            | 
           
            Retrieve ADAM embedding parameters with debug support.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingAdadeltaParameters
            
            | 
           
            Retrieve Adadelta embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug
            
            | 
           
            Retrieve Adadelta embedding parameters with debug support.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingAdagradParameters
            
            | 
           
            Retrieve Adagrad embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingAdagradParametersGradAccumDebug
            
            | 
           
            Retrieve Adagrad embedding parameters with debug support.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingCenteredRMSPropParameters
            
            | 
           
            Retrieve centered RMSProp embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingFTRLParameters
            
            | 
           
            Retrieve FTRL embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingFTRLParametersGradAccumDebug
            
            | 
           
            Retrieve FTRL embedding parameters with debug support.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingFrequencyEstimatorParameters
            
            | 
           
            Retrieve frequency estimator embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingFrequencyEstimatorParametersGradAccumDebug
            
            | 
           
            Retrieve frequency estimator embedding parameters with debug support.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingMDLAdagradLightParameters
            
            | 
           
            Retrieve MDL Adagrad Light embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingMomentumParameters
            
            | 
           
            Retrieve Momentum embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingMomentumParametersGradAccumDebug
            
            | 
           
            Retrieve Momentum embedding parameters with debug support.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingProximalAdagradParameters
            
            | 
           
            Retrieve proximal Adagrad embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug
            
            | 
           
            Retrieve proximal Adagrad embedding parameters with debug support.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingProximalYogiParameters
            
            | 
           
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingProximalYogiParametersGradAccumDebug
            
            | 
           
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingRMSPropParameters
            
            | 
           
            Retrieve RMSProp embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug
            
            | 
           
            Retrieve RMSProp embedding parameters with debug support.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingStochasticGradientDescentParameters
            
            | 
           
            Retrieve SGD embedding parameters.
            | 
          
          
           | 
            
             RetrieveTPUEmbeddingStochasticGradientDescentParametersGradAccumDebug
            
            | 
           
            Retrieve SGD embedding parameters with debug support.
            | 
          
          
           | 
            
             Reverse
            
            <T>
            | 
           
            Reverses specific dimensions of a tensor.
            | 
          
          
           | 
            
             ReverseSequence
            
            <T>
            | 
           
            Reverses variable length slices.
            | 
          
          
           | 
            
             RiscAbs
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscAdd
            
            <T extends Number>
            | 
           
            Returns x + y element-wise.
            | 
          
          
           | 
            
             RiscBinaryArithmetic
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscBinaryComparison
            
            | 
           
            | 
          
          
           | 
            
             RiscBitcast
            
            <U>
            | 
           
            | 
          
          
           | 
            
             RiscBroadcast
            
            <T>
            | 
           
            | 
          
          
           | 
            
             RiscCast
            
            <U>
            | 
           
            | 
          
          
           | 
            
             RiscCeil
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscCholesky
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscConcat
            
            <T>
            | 
           
            | 
          
          
           | 
            
             RiscConv
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscCos
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscDiv
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscDot
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscExp
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscFft
            
            <T>
            | 
           
            | 
          
          
           | 
            
             RiscFloor
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscGather
            
            <T>
            | 
           
            | 
          
          
           | 
            
             RiscImag
            
            <U extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscIsFinite
            
            | 
           
            | 
          
          
           | 
            
             RiscLog
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscLogicalAnd
            
            | 
           
            | 
          
          
           | 
            
             RiscLogicalNot
            
            | 
           
            | 
          
          
           | 
            
             RiscLogicalOr
            
            | 
           
            | 
          
          
           | 
            
             RiscMax
            
            <T extends Number>
            | 
           
            Returns max(x, y) element-wise.
            | 
          
          
           | 
            
             RiscMin
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscMul
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscNeg
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscPad
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscPool
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscPow
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscRandomUniform
            
            | 
           
            | 
          
          
           | 
            
             RiscReal
            
            <U extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscReduce
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscRem
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscReshape
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscReverse
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscScatter
            
            <U extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscShape
            
            <U extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscSign
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscSlice
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscSort
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscSqueeze
            
            <T>
            | 
           
            | 
          
          
           | 
            
             RiscSub
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscTranspose
            
            <T>
            | 
           
            | 
          
          
           | 
            
             RiscTriangularSolve
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RiscUnary
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             RngReadAndSkip
            
            | 
           
            Advance the counter of a counter-based RNG.
            | 
          
          
           | 
            
             RngSkip
            
            | 
           
            Advance the counter of a counter-based RNG.
            | 
          
          
           | 
            
             Roll
            
            <T>
            | 
           
            Rolls the elements of a tensor along an axis.
            | 
          
          
           | 
            
             SamplingDataset
            
            | 
           
            Creates a dataset that takes a Bernoulli sample of the contents of another dataset.
            | 
          
          
           | 
            
             ScaleAndTranslate
            
            | 
           
            | 
          
          
           | 
            
             ScaleAndTranslateGrad
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             ScatterAdd
            
            <T>
            | 
           
            Adds sparse updates to a variable reference.
            | 
          
          
           | 
            
             ScatterDiv
            
            <T>
            | 
           
            Divides a variable reference by sparse updates.
            | 
          
          
           | 
            
             ScatterMax
            
            <T extends Number>
            | 
           
            Reduces sparse updates into a variable reference using the `max` operation.
            | 
          
          
           | 
            
             ScatterMin
            
            <T extends Number>
            | 
           
            Reduces sparse updates into a variable reference using the `min` operation.
            | 
          
          
           | 
            
             ScatterMul
            
            <T>
            | 
           
            Multiplies sparse updates into a variable reference.
            | 
          
          
           | 
            
             ScatterNd
            
            <U>
            | 
           
            Scatter `updates` into a new tensor according to `indices`.
            | 
          
          
           | 
            
             ScatterNdAdd
            
            <T>
            | 
           
            Applies sparse addition to individual values or slices in a Variable.
            | 
          
          
           | 
            
             ScatterNdMax
            
            <T>
            | 
           
            Computes element-wise maximum.
            | 
          
          
           | 
            
             ScatterNdMin
            
            <T>
            | 
           
            Computes element-wise minimum.
            | 
          
          
           | 
            
             ScatterNdNonAliasingAdd
            
            <T>
            | 
           
            Applies sparse addition to `input` using individual values or slices
             
             from `updates` according to indices `indices`.
             
            | 
          
          
           | 
            
             ScatterNdSub
            
            <T>
            | 
           
            Applies sparse subtraction to individual values or slices in a Variable.
            | 
          
          
           | 
            
             ScatterNdUpdate
            
            <T>
            | 
           
            Applies sparse `updates` to individual values or slices within a given
             
             variable according to `indices`.
             
            | 
          
          
           | 
            
             ScatterSub
            
            <T>
            | 
           
            Subtracts sparse updates to a variable reference.
            | 
          
          
           | 
            
             ScatterUpdate
            
            <T>
            | 
           
            Applies sparse updates to a variable reference.
            | 
          
          
           | 
            
             SelectV2
            
            <T>
            | 
           
            | 
          
          
           | 
            
             Send
            
            | 
           
            Sends the named tensor from send_device to recv_device.
            | 
          
          
           | 
            
             SendTPUEmbeddingGradients
            
            | 
           
            Performs gradient updates of embedding tables.
            | 
          
          
           | 
            
             SetDiff1d
            
            <T, U extends Number>
            | 
           
            Computes the difference between two lists of numbers or strings.
            | 
          
          
           | 
            
             SetSize
            
            | 
           
            Number of unique elements along last dimension of input `set`.
            | 
          
          
           | 
            
             Shape
            
            <U extends Number>
            | 
           
            Returns the shape of a tensor.
            | 
          
          
           | 
            
             ShapeN
            
            <U extends Number>
            | 
           
            Returns shape of tensors.
            | 
          
          
           | 
            
             ShardDataset
            
            | 
           
            Creates a `Dataset` that includes only 1/`num_shards` of this dataset.
            | 
          
          
           | 
            
             ShuffleAndRepeatDatasetV2
            
            | 
           
            | 
          
          
           | 
            
             ShuffleDatasetV2
            
            | 
           
            | 
          
          
           | 
            
             ShuffleDatasetV3
            
            | 
           
            | 
          
          
           | 
            
             ShutdownDistributedTPU
            
            | 
           
            Shuts down a running distributed TPU system.
            | 
          
          
           | 
            
             Size
            
            <U extends Number>
            | 
           
            Returns the size of a tensor.
            | 
          
          
           | 
            
             Skipgram
            
            | 
           
            Parses a text file and creates a batch of examples.
            | 
          
          
           | 
            
             SleepDataset
            
            | 
           
            | 
          
          
           | 
            
             Slice
            
            <T>
            | 
           
            Return a slice from 'input'.
            | 
          
          
           | 
            
             SlidingWindowDataset
            
            | 
           
            Creates a dataset that passes a sliding window over `input_dataset`.
            | 
          
          
           | 
            
             Snapshot
            
            <T>
            | 
           
            Returns a copy of the input tensor.
            | 
          
          
           | 
            
             SnapshotDataset
            
            | 
           
            Creates a dataset that will write to / read from a snapshot.
            | 
          
          
           | 
            
             SnapshotDatasetReader
            
            | 
           
            | 
          
          
           | 
            
             SnapshotNestedDatasetReader
            
            | 
           
            | 
          
          
           | 
            
             SobolSample
            
            <T extends Number>
            | 
           
            Generates points from the Sobol sequence.
            | 
          
          
           | 
            
             SpaceToBatchNd
            
            <T>
            | 
           
            SpaceToBatch for N-D tensors of type T.
            | 
          
          
           | 
            
             SparseApplyAdagradV2
            
            <T>
            | 
           
            Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
            | 
          
          
           | 
            
             SparseBincount
            
            <U extends Number>
            | 
           
            Counts the number of occurrences of each value in an integer array.
            | 
          
          
           | 
            
             SparseCountSparseOutput
            
            <U extends Number>
            | 
           
            Performs sparse-output bin counting for a sparse tensor input.
            | 
          
          
           | 
            
             SparseCrossHashed
            
            | 
           
            Generates sparse cross from a list of sparse and dense tensors.
            | 
          
          
           | 
            
             SparseCrossV2
            
            | 
           
            Generates sparse cross from a list of sparse and dense tensors.
            | 
          
          
           | 
            
             SparseMatrixAdd
            
            | 
           
            Sparse addition of two CSR matrices, C = alpha * A + beta * B.
            | 
          
          
           | 
            
             SparseMatrixMatMul
            
            <T>
            | 
           
            Matrix-multiplies a sparse matrix with a dense matrix.
            | 
          
          
           | 
            
             SparseMatrixMul
            
            | 
           
            Element-wise multiplication of a sparse matrix with a dense tensor.
            | 
          
          
           | 
            
             SparseMatrixNNZ
            
            | 
           
            Returns the number of nonzeroes of `sparse_matrix`.
            | 
          
          
           | 
            
             SparseMatrixOrderingAMD
            
            | 
           
            Computes the Approximate Minimum Degree (AMD) ordering of `input`.
            | 
          
          
           | 
            
             SparseMatrixSoftmax
            
            | 
           
            Calculates the softmax of a CSRSparseMatrix.
            | 
          
          
           | 
            
             SparseMatrixSoftmaxGrad
            
            | 
           
            Calculates the gradient of the SparseMatrixSoftmax op.
            | 
          
          
           | 
            
             SparseMatrixSparseCholesky
            
            | 
           
            Computes the sparse Cholesky decomposition of `input`.
            | 
          
          
           | 
            
             SparseMatrixSparseMatMul
            
            | 
           
            Sparse-matrix-multiplies two CSR matrices `a` and `b`.
            | 
          
          
           | 
            
             SparseMatrixTranspose
            
            | 
           
            Transposes the inner (matrix) dimensions of a CSRSparseMatrix.
            | 
          
          
           | 
            
             SparseMatrixZeros
            
            | 
           
            Creates an all-zeros CSRSparseMatrix with shape `dense_shape`.
            | 
          
          
           | 
            
             SparseSegmentSumGrad
            
            <T extends Number>
            | 
           
            Computes gradients for SparseSegmentSum.
            | 
          
          
           | 
            
             SparseTensorToCSRSparseMatrix
            
            | 
           
            Converts a SparseTensor to a (possibly batched) CSRSparseMatrix.
            | 
          
          
           | 
            
             Spence
            
            <T extends Number>
            | 
           
            | 
          
          
           | 
            
             Split
            
            <T>
            | 
           
            Splits a tensor into `num_split` tensors along one dimension.
            | 
          
          
           | 
            
             SplitV
            
            <T>
            | 
           
            Splits a tensor into `num_split` tensors along one dimension.
            | 
          
          
           | 
            
             Squeeze
            
            <T>
            | 
           
            Removes dimensions of size 1 from the shape of a tensor.
            | 
          
          
           | 
            
             Stack
            
            <T>
            | 
           
            Packs a list of `N` rank-`R` tensors into one rank-`(R+1)` tensor.
            | 
          
          
           | 
            
             Stage
            
            | 
           
            Stage values similar to a lightweight Enqueue.
            | 
          
          
           | 
            
             StageClear
            
            | 
           
            Op removes all elements in the underlying container.
            | 
          
          
           | 
            
             StagePeek
            
            | 
           
            Op peeks at the values at the specified index.
            | 
          
          
           | 
            
             StageSize
            
            | 
           
            Op returns the number of elements in the underlying container.
            | 
          
          
           | 
            
             StatefulRandomBinomial
            
            <V extends Number>
            | 
           
            | 
          
          
           | 
            
             StatefulStandardNormal
            
            <U>
            | 
           
            Outputs random values from a normal distribution.
            | 
          
          
           | 
            
             StatefulStandardNormalV2
            
            <U>
            | 
           
            Outputs random values from a normal distribution.
            | 
          
          
           | 
            
             StatefulTruncatedNormal
            
            <U>
            | 
           
            Outputs random values from a truncated normal distribution.
            | 
          
          
           | 
            
             StatefulUniform
            
            <U>
            | 
           
            Outputs random values from a uniform distribution.
            | 
          
          
           | 
            
             StatefulUniformFullInt
            
            <U>
            | 
           
            Outputs random integers from a uniform distribution.
            | 
          
          
           | 
            
             StatefulUniformInt
            
            <U>
            | 
           
            Outputs random integers from a uniform distribution.
            | 
          
          
           | 
            
             StatelessParameterizedTruncatedNormal
            
            <V extends Number>
            | 
           
            | 
          
          
           | 
            
             StatelessRandomBinomial
            
            <W extends Number>
            | 
           
            Outputs deterministic pseudorandom random numbers from a binomial distribution.
            | 
          
          
           | 
            
             StatelessRandomGammaV2
            
            <V extends Number>
            | 
           
            Outputs deterministic pseudorandom random numbers from a gamma distribution.
            | 
          
          
           | 
            
             StatelessRandomGetAlg
            
            | 
           
            Picks the best counter-based RNG algorithm based on device.
            | 
          
          
           | 
            
             StatelessRandomGetKeyCounter
            
            | 
           
            Scrambles seed into key and counter, using the best algorithm based on device.
            | 
          
          
           | 
            
             StatelessRandomGetKeyCounterAlg
            
            | 
           
            Picks the best algorithm based on device, and scrambles seed into key and counter.
            | 
          
          
           | 
            
             StatelessRandomNormalV2
            
            <U extends Number>
            | 
           
            Outputs deterministic pseudorandom values from a normal distribution.
            | 
          
          
           | 
            
             StatelessRandomPoisson
            
            <W extends Number>
            | 
           
            Outputs deterministic pseudorandom random numbers from a Poisson distribution.
            | 
          
          
           | 
            
             StatelessRandomUniformFullInt
            
            <V extends Number>
            | 
           
            Outputs deterministic pseudorandom random integers from a uniform distribution.
            | 
          
          
           | 
            
             StatelessRandomUniformFullIntV2
            
            <U extends Number>
            | 
           
            Outputs deterministic pseudorandom random integers from a uniform distribution.
            | 
          
          
           | 
            
             StatelessRandomUniformIntV2
            
            <U extends Number>
            | 
           
            Outputs deterministic pseudorandom random integers from a uniform distribution.
            | 
          
          
           | 
            
             StatelessRandomUniformV2
            
            <U extends Number>
            | 
           
            Outputs deterministic pseudorandom random values from a uniform distribution.
            | 
          
          
           | 
            
             StatelessSampleDistortedBoundingBox
            
            <T extends Number>
            | 
           
            Generate a randomly distorted bounding box for an image deterministically.
            | 
          
          
           | 
            
             StatelessTruncatedNormalV2
            
            <U extends Number>
            | 
           
            Outputs deterministic pseudorandom values from a truncated normal distribution.
            | 
          
          
           | 
            
             StatsAggregatorHandleV2
            
            | 
           
            | 
          
          
           | 
            
             StatsAggregatorSetSummaryWriter
            
            | 
           
            Set a summary_writer_interface to record statistics using given stats_aggregator.
            | 
          
          
           | 
            
             StopGradient
            
            <T>
            | 
           
            Stops gradient computation.
            | 
          
          
           | 
            
             StridedSlice
            
            <T>
            | 
           
            Return a strided slice from `input`.
            | 
          
          
           | 
            
             StridedSliceAssign
            
            <T>
            | 
           
            Assign `value` to the sliced l-value reference of `ref`.
            | 
          
          
           | 
            
             StridedSliceGrad
            
            <U>
            | 
           
            Returns the gradient of `StridedSlice`.
            | 
          
          
           | 
            
             StringLower
            
            | 
           
            Converts all uppercase characters into their respective lowercase replacements.
            | 
          
          
           | 
            
             StringNGrams
            
            <T extends Number>
            | 
           
            Creates ngrams from ragged string data.
            | 
          
          
           | 
            
             StringUpper
            
            | 
           
            Converts all lowercase characters into their respective uppercase replacements.
            | 
          
          
           | 
            
             Sum
            
            <T>
            | 
           
            Computes the sum of elements across dimensions of a tensor.
            | 
          
          
           | 
            
             SwitchCond
            
            <T>
            | 
           
            Forwards `data` to the output port determined by `pred`.
            | 
          
          
           | 
            
             TPUCompilationResult
            
            | 
           
            Returns the result of a TPU compilation.
            | 
          
          
           | 
            
             TPUCompileSucceededAssert
            
            | 
           
            Asserts that compilation succeeded.
            | 
          
          
           | 
            
             TPUEmbeddingActivations
            
            | 
           
            An op enabling differentiation of TPU Embeddings.
            | 
          
          
           | 
            
             TPUExecute
            
            | 
           
            Op that loads and executes a TPU program on a TPU device.
            | 
          
          
           | 
            
             TPUExecuteAndUpdateVariables
            
            | 
           
            Op that executes a program with optional in-place variable updates.
            | 
          
          
           | 
            
             TPUOrdinalSelector
            
            | 
           
            A TPU core selector Op.
            | 
          
          
           | 
            
             TPUPartitionedInput
            
            <T>
            | 
           
            An op that groups a list of partitioned inputs together.
            | 
          
          
           | 
            
             TPUPartitionedOutput
            
            <T>
            | 
           
            An op that demultiplexes a tensor to be sharded by XLA to a list of partitioned
             
             outputs outside the XLA computation.
             
            | 
          
          
           | 
            
             TPUReplicateMetadata
            
            | 
           
            Metadata indicating how the TPU computation should be replicated.
            | 
          
          
           | 
            
             TPUReplicatedInput
            
            <T>
            | 
           
            Connects N inputs to an N-way replicated TPU computation.
            | 
          
          
           | 
            
             TPUReplicatedOutput
            
            <T>
            | 
           
            Connects N outputs from an N-way replicated TPU computation.
            | 
          
          
           | 
            
             TPUReshardVariables
            
            | 
           
            Op that reshards on-device TPU variables to specified state.
            | 
          
          
           | 
            
             TemporaryVariable
            
            <T>
            | 
           
            Returns a tensor that may be mutated, but only persists within a single step.
            | 
          
          
           | 
            
             TensorArray
            
            | 
           
            An array of Tensors of given size.
            | 
          
          
           | 
            
             TensorArrayClose
            
            | 
           
            Delete the TensorArray from its resource container.
            | 
          
          
           | 
            
             TensorArrayConcat
            
            <T>
            | 
           
            Concat the elements from the TensorArray into value `value`.
            | 
          
          
           | 
            
             TensorArrayGather
            
            <T>
            | 
           
            Gather specific elements from the TensorArray into output `value`.
            | 
          
          
           | 
            
             TensorArrayGrad
            
            | 
           
            Creates a TensorArray for storing the gradients of values in the given handle.
            | 
          
          
           | 
            
             TensorArrayGradWithShape
            
            | 
           
            Creates a TensorArray for storing multiple gradients of values in the given handle.
            | 
          
          
           | 
            
             TensorArrayPack
            
            <T>
            | 
           
            | 
          
          
           | 
            
             TensorArrayRead
            
            <T>
            | 
           
            Read an element from the TensorArray into output `value`.
            | 
          
          
           | 
            
             TensorArrayScatter
            
            | 
           
            Scatter the data from the input value into specific TensorArray elements.
            | 
          
          
           | 
            
             TensorArraySize
            
            | 
           
            Get the current size of the TensorArray.
            | 
          
          
           | 
            
             TensorArraySplit
            
            | 
           
            Split the data from the input value into TensorArray elements.
            | 
          
          
           | 
            
             TensorArrayUnpack
            
            | 
           
            | 
          
          
           | 
            
             TensorArrayWrite
            
            | 
           
            Push an element onto the tensor_array.
            | 
          
          
           | 
            
             TensorListConcat
            
            <T>
            | 
           
            Concats all tensors in the list along the 0th dimension.
            | 
          
          
           | 
            
             TensorListConcatLists
            
            | 
           
            | 
          
          
           | 
            
             TensorListConcatV2
            
            <U>
            | 
           
            Concats all tensors in the list along the 0th dimension.
            | 
          
          
           | 
            
             TensorListElementShape
            
            <T extends Number>
            | 
           
            The shape of the elements of the given list, as a tensor.
            | 
          
          
           | 
            
             TensorListFromTensor
            
            | 
           
            Creates a TensorList which, when stacked, has the value of `tensor`.
            | 
          
          
           | 
            
             TensorListGather
            
            <T>
            | 
           
            Creates a Tensor by indexing into the TensorList.
            | 
          
          
           | 
            
             TensorListGetItem
            
            <T>
            | 
           
            | 
          
          
           | 
            
             TensorListLength
            
            | 
           
            Returns the number of tensors in the input tensor list.
            | 
          
          
           | 
            
             TensorListPopBack
            
            <T>
            | 
           
            Returns the last element of the input list as well as a list with all but that element.
            | 
          
          
           | 
            
             TensorListPushBack
            
            | 
           
            Returns a list which has the passed-in `Tensor` as last element and the other elements of the given list in `input_handle`.
            | 
          
          
           | 
            
             TensorListPushBackBatch
            
            | 
           
            | 
          
          
           | 
            
             TensorListReserve
            
            | 
           
            List of the given size with empty elements.
            | 
          
          
           | 
            
             TensorListResize
            
            | 
           
            Resizes the list.
            | 
          
          
           | 
            
             TensorListScatter
            
            | 
           
            Creates a TensorList by indexing into a Tensor.
            | 
          
          
           | 
            
             TensorListScatterIntoExistingList
            
            | 
           
            Scatters tensor at indices in an input list.
            | 
          
          
           | 
            
             TensorListScatterV2
            
            | 
           
            Creates a TensorList by indexing into a Tensor.
            | 
          
          
           | 
            
             TensorListSetItem
            
            | 
           
            | 
          
          
           | 
            
             TensorListSplit
            
            | 
           
            Splits a tensor into a list.
            | 
          
          
           | 
            
             TensorListStack
            
            <T>
            | 
           
            Stacks all tensors in the list.
            | 
          
          
           | 
            
             TensorMapErase
            
            | 
           
            Returns a tensor map with item from given key erased.
            | 
          
          
           | 
            
             TensorMapHasKey
            
            | 
           
            Returns whether the given key exists in the map.
            | 
          
          
           | 
            
             TensorMapInsert
            
            | 
           
            Returns a map that is the 'input_handle' with the given key-value pair inserted.
            | 
          
          
           | 
            
             TensorMapLookup
            
            <U>
            | 
           
            Returns the value from a given key in a tensor map.
            | 
          
          
           | 
            
             TensorMapSize
            
            | 
           
            Returns the number of tensors in the input tensor map.
            | 
          
          
           | 
            
             TensorMapStackKeys
            
            <T>
            | 
           
            Returns a Tensor stack of all keys in a tensor map.
            | 
          
          
           | 
            
             TensorScatterAdd
            
            <T>
            | 
           
            Adds sparse `updates` to an existing tensor according to `indices`.
            | 
          
          
           | 
            
             TensorScatterMax
            
            <T>
            | 
           
            | 
          
          
           | 
            
             TensorScatterMin
            
            <T>
            | 
           
            | 
          
          
           | 
            
             TensorScatterSub
            
            <T>
            | 
           
            Subtracts sparse `updates` from an existing tensor according to `indices`.
            | 
          
          
           | 
            
             TensorScatterUpdate
            
            <T>
            | 
           
            Scatter `updates` into an existing tensor according to `indices`.
            | 
          
          
           | 
            
             TensorStridedSliceUpdate
            
            <T>
            | 
           
            Assign `value` to the sliced l-value reference of `input`.
            | 
          
          
           | 
            
             ThreadPoolDataset
            
            | 
           
            Creates a dataset that uses a custom thread pool to compute `input_dataset`.
            | 
          
          
           | 
            
             ThreadPoolHandle
            
            | 
           
            Creates a dataset that uses a custom thread pool to compute `input_dataset`.
            | 
          
          
           | 
            
             Tile
            
            <T>
            | 
           
            Constructs a tensor by tiling a given tensor.
            | 
          
          
           | 
            
             Timestamp
            
            | 
           
            Provides the time since epoch in seconds.
            | 
          
          
           | 
            
             ToBool
            
            | 
           
            Converts a tensor to a scalar predicate.
            | 
          
          
           | 
            
             TopKUnique
            
            | 
           
            Returns the TopK unique values in the array in sorted order.
            | 
          
          
           | 
            
             TopKWithUnique
            
            | 
           
            Returns the TopK values in the array in sorted order.
            | 
          
          
           | 
            
             TridiagonalMatMul
            
            <T>
            | 
           
            Calculate product with tridiagonal matrix.
            | 
          
          
           | 
            
             TridiagonalSolve
            
            <T>
            | 
           
            Solves tridiagonal systems of equations.
            | 
          
          
           | 
            
             Unbatch
            
            <T>
            | 
           
            Reverses the operation of Batch for a single output Tensor.
            | 
          
          
           | 
            
             UnbatchGrad
            
            <T>
            | 
           
            Gradient of Unbatch.
            | 
          
          
           | 
            
             UncompressElement
            
            | 
           
            Uncompresses a compressed dataset element.
            | 
          
          
           | 
            
             UnicodeDecode
            
            <T extends Number>
            | 
           
            Decodes each string in `input` into a sequence of Unicode code points.
            | 
          
          
           | 
            
             UnicodeEncode
            
            | 
           
            Encode a tensor of ints into unicode strings.
            | 
          
          
           | 
            
             Unique
            
            <T, V extends Number>
            | 
           
            Finds unique elements along an axis of a tensor.
            | 
          
          
           | 
            
             UniqueDataset
            
            | 
           
            Creates a dataset that contains the unique elements of `input_dataset`.
            | 
          
          
           | 
            
             UniqueWithCounts
            
            <T, V extends Number>
            | 
           
            Finds unique elements along an axis of a tensor.
            | 
          
          
           | 
            
             UnravelIndex
            
            <T extends Number>
            | 
           
            Converts an array of flat indices into a tuple of coordinate arrays.
            | 
          
          
           | 
            
             UnsortedSegmentJoin
            
            | 
           
            Joins the elements of `inputs` based on `segment_ids`.
            | 
          
          
           | 
            
             Unstack
            
            <T>
            | 
           
            Unpacks a given dimension of a rank-`R` tensor into `num` rank-`(R-1)` tensors.
            | 
          
          
           | 
            
             Unstage
            
            | 
           
            Op is similar to a lightweight Dequeue.
            | 
          
          
           | 
            
             UnwrapDatasetVariant
            
            | 
           
            | 
          
          
           | 
            
             UpperBound
            
            <U extends Number>
            | 
           
            Applies upper_bound(sorted_search_values, values) along each row.
            | 
          
          
           | 
            
             VarHandleOp
            
            | 
           
            Creates a handle to a Variable resource.
            | 
          
          
           | 
            
             VarIsInitializedOp
            
            | 
           
            Checks whether a resource handle-based variable has been initialized.
            | 
          
          
           | 
            
             Variable
            
            <T>
            | 
           
            Holds state in the form of a tensor that persists across steps.
            | 
          
          
           | 
            
             VariableShape
            
            <T extends Number>
            | 
           
            Returns the shape of the variable pointed to by `resource`.
            | 
          
          
           | 
            
             Where
            
            | 
           
            Returns locations of nonzero / true values in a tensor.
            | 
          
          
           | 
            
             Where3
            
            <T>
            | 
           
            Selects elements from `x` or `y`, depending on `condition`.
            | 
          
          
           | 
            
             Window
            
            | 
           
            | 
          
          
           | 
            
             WorkerHeartbeat
            
            | 
           
            Worker heartbeat op.
            | 
          
          
           | 
            
             WrapDatasetVariant
            
            | 
           
            | 
          
          
           | 
            
             WriteRawProtoSummary
            
            | 
           
            Writes a serialized proto summary.
            | 
          
          
           | 
            
             XlaRecvFromHost
            
            <T>
            | 
           
            An op to receive a tensor from the host.
            | 
          
          
           | 
            
             XlaSendToHost
            
            | 
           
            An op to send a tensor to the host.
            | 
          
          
           | 
            
             Xlog1py
            
            <T>
            | 
           
            Returns 0 if x == 0, and x * log1p(y) otherwise, elementwise.
            | 
          
          
           | 
            
             ZerosLike
            
            <T>
            | 
           
            Returns a tensor of zeros with the same shape and type as x.
            |