| 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. | 
          
           | 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.
             | 
          
           | 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> | Returns the gradient of `QuantizeAndDequantizeV4`. | 
          
           | 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. | 
          
           | 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`. | 
          
           | 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`. | 
          
           | 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. |