| 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.  | 
| AnonymousHashTable | 
Creates a uninitialized anonymous hash table.  | 
| AnonymousIteratorV2 | 
A container for an iterator resource.  | 
| AnonymousIteratorV3 | 
A container for an iterator resource.  | 
| AnonymousMemoryCache | 
  | 
| AnonymousMultiDeviceIterator | 
A container for a multi device iterator resource.  | 
| AnonymousMultiDeviceIteratorV3 | 
A container for a multi device iterator resource.  | 
| AnonymousMutableDenseHashTable | 
Creates an empty anonymous mutable hash table that uses tensors as the backing store.  | 
| AnonymousMutableHashTable | 
Creates an empty anonymous mutable hash table.  | 
| AnonymousMutableHashTableOfTensors | 
Creates an empty anonymous mutable hash table of vector values.  | 
| AnonymousRandomSeedGenerator | 
  | 
| AnonymousSeedGenerator | 
  | 
| Any | 
Computes the "logical or" of elements across dimensions of a tensor.  | 
| ApplyAdagradV2<T> | 
Update '*var' according to the adagrad scheme.  | 
| ApproxTopK<T extends Number> | 
Returns min/max k values and their indices of the input operand in an approximate manner.  | 
| AssertCardinalityDataset | 
  | 
| AssertNextDataset | 
A transformation that asserts which transformations happen next.  | 
| AssertPrevDataset | 
A transformation that asserts which transformations happened previously.  | 
| 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.  | 
| AssignVariableXlaConcatND | 
Concats input tensor across all dimensions.  | 
| 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.  | 
| CollateTPUEmbeddingMemory | 
An op that merges the string-encoded memory config protos from all hosts.  | 
| CollectiveAllToAllV2<T extends Number> | 
Mutually exchanges multiple tensors of identical type and shape.  | 
| CollectiveAllToAllV3<T extends Number> | 
Mutually exchanges multiple tensors of identical type and shape.  | 
| CollectiveAssignGroupV2 | 
Assign group keys based on group assignment.  | 
| 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.  | 
| CollectiveInitializeCommunicator | 
Initializes a group for collective operations.  | 
| CollectivePermute<T> | 
An Op to permute tensors across replicated TPU instances.  | 
| CollectiveReduceScatterV2<T extends Number> | 
Mutually reduces multiple tensors of identical type and shape and scatters the result.  | 
| CollectiveReduceV2<T extends Number> | 
Mutually reduces multiple tensors of identical type and shape.  | 
| CollectiveReduceV3<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.  | 
| ComputeDedupDataTupleMask | 
An op computes tuple mask of deduplication data from embedding core.  | 
| Concat<T> | 
Concatenates tensors along one dimension.  | 
| ConfigureAndInitializeGlobalTPU | 
An op that sets up the centralized structures for a distributed TPU system.  | 
| ConfigureDistributedTPU | 
Sets up the centralized structures for a distributed TPU system.  | 
| ConfigureTPUEmbedding | 
Sets up TPUEmbedding in a distributed TPU system.  | 
| ConfigureTPUEmbeddingHost | 
An op that configures the TPUEmbedding software on a host.  | 
| ConfigureTPUEmbeddingMemory | 
An op that configures the TPUEmbedding software on a host.  | 
| ConnectTPUEmbeddingHosts | 
An op that sets up communication between TPUEmbedding host software instances
  
 after ConfigureTPUEmbeddingHost has been called on each host.   | 
| Constant<T> | 
An operator producing a constant value.  | 
| ConsumeMutexLock | 
This op consumes a lock created by `MutexLock`.  | 
| ControlTrigger | 
Does nothing.  | 
| Conv2DBackpropFilterV2<T extends Number> | 
Computes the gradients of convolution with respect to the filter.  | 
| Conv2DBackpropInputV2<T extends Number> | 
Computes the gradients of convolution with respect to the input.  | 
| Copy<T> | 
Copy a tensor from CPU-to-CPU or GPU-to-GPU.  | 
| CopyHost<T> | 
Copy a tensor to host.  | 
| CopyToMesh<T> | 
  | 
| CopyToMeshGrad<T> | 
  | 
| 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`.  | 
| DTensorRestoreV2 | 
  | 
| DTensorSetGlobalTPUArray | 
An op that informs a host of the global ids of all the of TPUs in the system.  | 
| 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.  | 
| DisableCopyOnRead | 
Turns off the copy-on-read mode.  | 
| DistributedSave | 
  | 
| DrawBoundingBoxesV2<T extends Number> | 
Draw bounding boxes on a batch of images.  | 
| DummyIterationCounter | 
  | 
| DummyMemoryCache | 
  | 
| DummySeedGenerator | 
  | 
| DynamicEnqueueTPUEmbeddingArbitraryTensorBatch | 
Eases the porting of code that uses tf.nn.embedding_lookup_sparse().  | 
| 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.  | 
| EnqueueTPUEmbeddingArbitraryTensorBatch | 
Eases the porting of code that uses tf.nn.embedding_lookup_sparse().  | 
| EnqueueTPUEmbeddingBatch | 
An op that enqueues a list of input batch tensors to TPUEmbedding.  | 
| 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.  | 
| ExecuteTPUEmbeddingPartitioner | 
An op that executes the TPUEmbedding partitioner on the central configuration
  
 device and computes the HBM size (in bytes) required for TPUEmbedding operation.   | 
| 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.  | 
| FileSystemSetConfiguration | 
Set configuration of the file system.  | 
| Fill<U> | 
Creates a tensor filled with a scalar value.  | 
| FinalizeDataset | 
Creates a dataset by applying tf.data.Options to `input_dataset`.  | 
| FinalizeTPUEmbedding | 
An op that finalizes the TPUEmbedding configuration.  | 
| 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`.   | 
| GetElementAtIndex | 
Gets the element at the specified index in a dataset.  | 
| 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.  | 
| Gradients | 
Adds operations to compute the partial derivatives of sum of ys w.r.t xs,
 i.e., d(y_1 + y_2 + ...)/dx_1, d(y_1 + y_2 + ...)/dx_2...
 
 If Options.dx() values are set, they are as the initial symbolic partial derivatives of some loss 
 function L w.r.t.   | 
| 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.  | 
| IsTPUEmbeddingInitialized | 
Whether TPU Embedding is initialized in a distributed TPU system.  | 
| 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.  | 
| ListDataset | 
Creates a dataset that emits each of `tensors` once.  | 
| LoadAllTPUEmbeddingParameters | 
An op that loads optimization parameters into embedding memory.  | 
| LoadTPUEmbeddingADAMParameters | 
Load ADAM embedding parameters.  | 
| LoadTPUEmbeddingAdadeltaParameters | 
Load Adadelta embedding parameters.  | 
| LoadTPUEmbeddingAdagradMomentumParameters | 
Load Adagrad Momentum embedding parameters.  | 
| LoadTPUEmbeddingAdagradParameters | 
Load Adagrad embedding parameters.  | 
| LoadTPUEmbeddingCenteredRMSPropParameters | 
Load centered RMSProp embedding parameters.  | 
| LoadTPUEmbeddingFTRLParameters | 
Load FTRL embedding parameters.  | 
| LoadTPUEmbeddingFrequencyEstimatorParameters | 
Load frequency estimator embedding parameters.  | 
| LoadTPUEmbeddingMDLAdagradLightParameters | 
Load MDL Adagrad Light embedding parameters.  | 
| LoadTPUEmbeddingMomentumParameters | 
Load Momentum embedding parameters.  | 
| LoadTPUEmbeddingProximalAdagradParameters | 
Load proximal Adagrad embedding parameters.  | 
| LoadTPUEmbeddingProximalYogiParameters | 
  | 
| LoadTPUEmbeddingRMSPropParameters | 
Load RMSProp embedding parameters.  | 
| LoadTPUEmbeddingStochasticGradientDescentParameters | 
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`.  | 
| MergeDedupData | 
An op merges elements of integer and float tensors into deduplication data as
 XLA tuple.  | 
| 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.  | 
| PrimitiveOp | 
A base class for Op implementations that are backed by a single Operation.  | 
| 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.  | 
| RaggedFillEmptyRows<T> | 
  | 
| RaggedFillEmptyRowsGrad<T> | 
  | 
| 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`.  | 
| RandomDatasetV2 | 
Creates a Dataset that returns pseudorandom numbers.  | 
| RandomIndexShuffle<T extends Number> | 
Outputs the position of `value` in a permutation of [0, ..., max_index].  | 
| Range<T extends Number> | 
Creates a sequence of numbers.  | 
| Rank | 
Returns the rank of a tensor.  | 
| ReadVariableOp<T> | 
Reads the value of a variable.  | 
| ReadVariableXlaSplitND<T> | 
Splits resource variable input tensor across all dimensions.  | 
| 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.  | 
| RegisterDatasetV2 | 
Registers a dataset with the tf.data service.  | 
| Relayout<T> | 
  | 
| RelayoutGrad<T> | 
  | 
| 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`.  | 
| RetrieveAllTPUEmbeddingParameters | 
An op that retrieves optimization parameters from embedding to host memory.  | 
| RetrieveTPUEmbeddingADAMParameters | 
Retrieve ADAM embedding parameters.  | 
| RetrieveTPUEmbeddingAdadeltaParameters | 
Retrieve Adadelta embedding parameters.  | 
| RetrieveTPUEmbeddingAdagradMomentumParameters | 
Retrieve Adagrad Momentum embedding parameters.  | 
| RetrieveTPUEmbeddingAdagradParameters | 
Retrieve Adagrad embedding parameters.  | 
| RetrieveTPUEmbeddingCenteredRMSPropParameters | 
Retrieve centered RMSProp embedding parameters.  | 
| RetrieveTPUEmbeddingFTRLParameters | 
Retrieve FTRL embedding parameters.  | 
| RetrieveTPUEmbeddingFrequencyEstimatorParameters | 
Retrieve frequency estimator embedding parameters.  | 
| RetrieveTPUEmbeddingMDLAdagradLightParameters | 
Retrieve MDL Adagrad Light embedding parameters.  | 
| RetrieveTPUEmbeddingMomentumParameters | 
Retrieve Momentum embedding parameters.  | 
| RetrieveTPUEmbeddingProximalAdagradParameters | 
Retrieve proximal Adagrad embedding parameters.  | 
| RetrieveTPUEmbeddingProximalYogiParameters | 
  | 
| RetrieveTPUEmbeddingRMSPropParameters | 
Retrieve RMSProp embedding parameters.  | 
| RetrieveTPUEmbeddingStochasticGradientDescentParameters | 
Retrieve SGD embedding parameters.  | 
| Reverse<T> | 
Reverses specific dimensions of a tensor.  | 
| ReverseSequence<T> | 
Reverses variable length slices.  | 
| RewriteDataset | 
  | 
| 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> | 
Scatters `updates` into a tensor of shape `shape` 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.  | 
| SegmentMaxV2<T extends Number> | 
Computes the maximum along segments of a tensor.  | 
| SegmentMinV2<T extends Number> | 
Computes the minimum along segments of a tensor.  | 
| SegmentProdV2<T> | 
Computes the product along segments of a tensor.  | 
| SegmentSumV2<T> | 
Computes the sum along segments of a tensor.  | 
| 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.  | 
| ShutdownTPUSystem | 
An op that shuts down the 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.  | 
| SplitDedupData<T extends Number, U extends Number> | 
An op splits input deduplication data XLA tuple into integer and floating point
 tensors.  | 
| 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.  | 
| StatelessRandomGammaV3<U 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.  | 
| StatelessShuffle<T> | 
Randomly and deterministically shuffles a tensor along its first dimension.  | 
| 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`.  | 
| SyncDevice | 
Synchronizes the device this op is run on.  | 
| 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.  | 
| TPUPartitionedInputV2<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.   | 
| TPUPartitionedOutputV2<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.  | 
| TPURoundRobin | 
Round-robin load balancing on TPU cores.  | 
| 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> | 
Apply a sparse update to a tensor taking the element-wise maximum.  | 
| 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.  | 
| TpuHandleToProtoKey | 
Converts XRT's uid handles to TensorFlow-friendly input format.  | 
| 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.  | 
| UniformDequantize<U extends Number> | 
Perform dequantization on the quantized Tensor `input`.  | 
| UniformQuantize<U> | 
Perform quantization on Tensor `input`.  | 
| UniformQuantizedAdd<T> | 
Perform quantized add of quantized Tensor `lhs` and quantized Tensor `rhs` to make quantized `output`.  | 
| UniformQuantizedClipByValue<T> | 
Perform clip by value on the quantized Tensor `operand`.  | 
| UniformQuantizedConvolution<U> | 
Perform quantized convolution of quantized Tensor `lhs` and quantized Tensor `rhs`.  | 
| UniformQuantizedConvolutionHybrid<V extends Number> | 
Perform hybrid quantized convolution of float Tensor `lhs` and quantized Tensor `rhs`.  | 
| UniformQuantizedDot<U> | 
Perform quantized dot of quantized Tensor `lhs` and quantized Tensor `rhs` to make quantized `output`.  | 
| UniformQuantizedDotHybrid<V extends Number> | 
Perform hybrid quantized dot of float Tensor `lhs` and quantized Tensor `rhs`.  | 
| UniformRequantize<U> | 
Given quantized tensor `input`, requantize it with new quantization parameters.  | 
| 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 | 
  | 
| 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`.  | 
| WindowOp | 
  | 
| WorkerHeartbeat | 
Worker heartbeat op.  | 
| WrapDatasetVariant | 
  | 
| WriteRawProtoSummary | 
Writes a serialized proto summary.  | 
| XlaConcatND<T> | 
Concats input tensor across all dimensions.  | 
| XlaRecvFromHost<T> | 
An op to receive a tensor from the host.  | 
| XlaRecvTPUEmbeddingActivations | 
An op that receives embedding activations on the TPU.  | 
| XlaRecvTPUEmbeddingDeduplicationData | 
Receives deduplication data (indices and weights) from the embedding core.  | 
| XlaSendTPUEmbeddingGradients | 
An op that performs gradient updates of embedding tables.  | 
| XlaSendToHost | 
An op to send a tensor to the host.  | 
| XlaSplitND<T> | 
Splits input tensor across all dimensions.  | 
| Xlog1py<T> | 
Returns 0 if x == 0, and x * log1p(y) otherwise, elementwise.  | 
| Zeros<T> | 
An operator creating a constant initialized with zeros of the shape given by `dims`.  | 
| ZerosLike<T> | 
Returns a tensor of zeros with the same shape and type as x.  |