| 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.  | 
          
        
              | CollectiveGather<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 | 
                | 
          
        
              | 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.  | 
          
        
              | 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`.   | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | 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`.  | 
          
        
              | 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.  | 
          
        
              | OutfeedEnqueue | 
              Enqueue a Tensor on the computation outfeed.  | 
          
        
              | OutfeedEnqueueTuple | 
              Enqueue multiple Tensor values on the computation outfeed.  | 
          
        
              | Pad<T> | 
              Pads a tensor.  | 
          
        
              | 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.  | 
          
        
              | QuantizedConcat<T> | 
              Concatenates quantized tensors along one dimension.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | RemoteFusedGraphExecute | 
              Execute a sub graph on a remote processor.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | RngSkip | 
              Advance the counter of a counter-based RNG.  | 
          
        
              | Roll<T> | 
              Rolls the elements of a tensor along an axis.  | 
          
        
              | Rpc | 
              Perform batches of RPC requests.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | StatelessSampleDistortedBoundingBox<T extends Number> | 
              Generate a randomly distorted bounding box for an image deterministically.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | TensorForestCreateTreeVariable | 
              Creates a tree resource and returns a handle to it.  | 
          
        
              | TensorForestTreeDeserialize | 
              Deserializes a proto into the tree handle
  | 
          
        
              | TensorForestTreeIsInitializedOp | 
              Checks whether a tree has been initialized.  | 
          
        
              | TensorForestTreePredict | 
              Output the logits for the given input data
  | 
          
        
              | TensorForestTreeResourceHandleOp | 
              Creates a handle to a TensorForestTreeResource
  | 
          
        
              | TensorForestTreeSerialize | 
              Serializes the tree handle to a proto
  | 
          
        
              | TensorForestTreeSize | 
              Get the number of nodes in a tree
  | 
          
        
              | 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<U> | 
              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.  | 
          
        
              | 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.  | 
          
        
              | TryRpc | 
              Perform batches of RPC requests.  | 
          
        
              | 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.  |