| All | Computes the "logical and" of elements across dimensions of a tensor. | 
        
              | AllToAll<T> | An Op to exchange data across TPU replicas. | 
        
              | 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. | 
        
              | Assign<T> | Update 'ref' by assigning 'value' to it. | 
        
              | AssignAdd<T> | Update 'ref' by adding 'value' to it. | 
        
              | AssignSub<T> | Update 'ref' by subtracting 'value' from it. | 
        
              | AutoShardDataset | Creates a dataset that shards the input dataset. | 
        
              | BandedTriangularSolve<T> |  | 
        
              | Barrier | Defines a barrier that persists across different graph executions. | 
        
              | BarrierIncompleteSize | Computes the number of incomplete elements in the given barrier. | 
        
              | BarrierReadySize | Computes the number of complete elements in the given barrier. | 
        
              | 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. | 
        
              | BoostedTreesAggregateStats | Aggregates the summary of accumulated stats for the batch. | 
        
              | BoostedTreesCenterBias | Calculates the prior from the training data (the bias) and fills in the first node with the logits' prior. | 
        
              | BoostedTreesEnsembleResourceHandleOp | Creates a handle to a BoostedTreesEnsembleResource | 
        
              | BoostedTreesExampleDebugOutputs | Debugging/model interpretability outputs for each example. | 
        
              | BoostedTreesMakeStatsSummary | Makes the summary of accumulated stats for the batch. | 
        
              | BoostedTreesPredict | Runs multiple additive regression ensemble predictors on input instances and 
 computes the logits.  | 
        
              | BoostedTreesQuantileStreamResourceHandleOp | Creates a handle to a BoostedTreesQuantileStreamResource. | 
        
              | BroadcastDynamicShape<T extends Number> | Return the shape of s0 op s1 with broadcast. | 
        
              | BroadcastTo<T> | Broadcast an array for a compatible shape. | 
        
              | Bucketize | Bucketizes 'input' based on 'boundaries'. | 
        
              | CSRSparseMatrixToDense<T> | Convert a (possibly batched) CSRSparseMatrix to dense. | 
        
              | CSVDataset |  | 
        
              | CSVDatasetV2 |  | 
        
              | 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. | 
        
              | CollectiveGatherV2<T extends Number> | Mutually accumulates multiple tensors of identical type and shape. | 
        
              | CollectivePermute<T> | An Op to permute tensors across replicated TPU instances. | 
        
              | CollectiveReduceV2<T extends Number> | Mutually reduces multiple tensors of identical type and shape. | 
        
              | 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. | 
        
              | Constant<T> | An operator producing a constant value. | 
        
              | 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. | 
        
              | CudnnRNNCanonicalToParamsV2<T extends Number> | Converts CudnnRNN params from canonical form to usable form. | 
        
              | 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. | 
        
              | DeepCopy<T> | Makes a copy of `x`. | 
        
              | DenseBincount<U extends Number> | Counts the number of occurrences of each value in an integer array. | 
        
              | DenseToCSRSparseMatrix | Converts a dense tensor to a (possibly batched) CSRSparseMatrix. | 
        
              | 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 |  | 
        
              | DynamicStitch<T> | Interleave the values from the `data` tensors into a single tensor. | 
        
              | EditDistance | Computes the (possibly normalized) Levenshtein Edit Distance. | 
        
              | 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. | 
        
              | 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`. | 
        
              | 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> |  | 
        
              | 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`. | 
        
              | 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. | 
        
              | 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. | 
        
              | 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. | 
        
              | 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. | 
        
              | LinSpace<T extends Number> | Generates values in an interval. | 
        
              | LookupTableFind<U> | Looks up keys in a table, outputs the corresponding values. | 
        
              | 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. | 
        
              | MakeUnique | Make all elements in the non-Batch dimension unique, but \"close\" to 
 their initial value.  | 
        
              | MapIncompleteSize | Op returns the number of incomplete elements in the underlying container. | 
        
              | MapSize | Op returns the number of elements in 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. | 
        
              | 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. | 
        
              | 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> |  | 
        
              | 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. | 
        
              | NonDeterministicInts<U> | Non-deterministically generates some integers. | 
        
              | 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`. | 
        
              | OrderedMapIncompleteSize | Op returns the number of incomplete elements in the underlying container. | 
        
              | OrderedMapSize | Op returns the number of elements in the underlying container. | 
        
              | OutfeedDequeue<T> | Retrieves a single tensor from the computation outfeed. | 
        
              | OutfeedDequeueV2<T> | Retrieves a single tensor from the computation outfeed. | 
        
              | Output<T> | A symbolic handle to a tensor produced by an Operation. | 
        
              | 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. | 
        
              | 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. | 
        
              | PrivateThreadPoolDataset | Creates a dataset that uses a custom thread pool to compute `input_dataset`. | 
        
              | Prod<T> | Computes the product of elements across dimensions of a tensor. | 
        
              | QuantizeAndDequantizeV4<T extends Number> | Returns the gradient of `QuantizeAndDequantizeV4`. | 
        
              | QuantizedMatMulWithBiasAndDequantize<W extends Number> |  | 
        
              | RaggedBincount<U extends Number> | Counts the number of occurrences of each value in an integer array. | 
        
              | RaggedTensorToTensor<U> | Create a dense tensor from a ragged tensor, possibly altering its shape. | 
        
              | RaggedTensorToVariant | Encodes a `RaggedTensor` into a `variant` Tensor. | 
        
              | RaggedTensorToVariantGradient<U> | Helper used to compute the gradient for `RaggedTensorToVariant`. | 
        
              | Range<T extends Number> | Creates a sequence of numbers. | 
        
              | Rank | Returns the rank of a tensor. | 
        
              | ReadVariableOp<T> | Reads the value of a variable. | 
        
              | RebatchDataset | Creates a dataset that changes the batch size. | 
        
              | RebatchDatasetV2 | Creates a dataset that changes the batch size. | 
        
              | Recv<T> | Receives the named tensor from send_device on recv_device. | 
        
              | 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. | 
        
              | RefNextIteration<T> | Makes its input available to the next iteration. | 
        
              | RefSelect<T> | Forwards the `index`th element of `inputs` to `output`. | 
        
              | RegisterDataset | Registers a dataset with the tf.data service. | 
        
              | Reshape<T> | Reshapes a tensor. | 
        
              | ResourceAccumulatorNumAccumulated | Returns the number of gradients aggregated in the given accumulators. | 
        
              | ResourceAccumulatorTakeGradient<T> | Extracts the average gradient in the given ConditionalAccumulator. | 
        
              | 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> |  | 
        
              | RetrieveTPUEmbeddingStochasticGradientDescentParameters | Retrieve SGD embedding parameters. | 
        
              | Reverse<T> | Reverses specific dimensions of a tensor. | 
        
              | ReverseSequence<T> | Reverses variable length slices. | 
        
              | RngReadAndSkip | 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> |  | 
        
              | SetSize | Number of unique elements along last dimension of input `set`. | 
        
              | Shape<U extends Number> | Returns the shape of a tensor. | 
        
              | ShardDataset | Creates a `Dataset` that includes only 1/`num_shards` of this dataset. | 
        
              | ShuffleAndRepeatDatasetV2 |  | 
        
              | ShuffleDatasetV2 |  | 
        
              | ShuffleDatasetV3 |  | 
        
              | Size<U extends Number> | Returns the size of a tensor. | 
        
              | 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. | 
        
              | 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> |  | 
        
              | 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. | 
        
              | 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. | 
        
              | 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. | 
        
              | StatelessTruncatedNormalV2<U extends Number> | Outputs deterministic pseudorandom values from a truncated normal distribution. | 
        
              | StatsAggregatorHandleV2 |  | 
        
              | 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. | 
        
              | StringUpper | Converts all lowercase characters into their respective uppercase replacements. | 
        
              | Sum<T> | Computes the sum of elements across dimensions of a tensor. | 
        
              | TPUCompilationResult | Returns the result of a TPU compilation. | 
        
              | TPUEmbeddingActivations | An op enabling differentiation of TPU Embeddings. | 
        
              | TPUOrdinalSelector | A TPU core selector Op. | 
        
              | TPUPartitionedInput<T> | An op that groups a list of partitioned inputs together. | 
        
              | TPUReplicatedInput<T> | Connects N inputs to an N-way replicated TPU computation. | 
        
              | TemporaryVariable<T> | Returns a tensor that may be mutated, but only persists within a single step. | 
        
              | TensorArrayGather<T> | Gather specific elements from the TensorArray into output `value`. | 
        
              | 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. | 
        
              | 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 | 
        
              | TensorListConcatLists |  | 
        
              | 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. | 
        
              | TensorListPushBack | Returns a list which has the passed-in `Tensor` as last element and the other elements of the given list in `input_handle`. | 
        
              | TensorListPushBackBatch |  | 
        
              | TensorListReserve | List of the given size with empty elements. | 
        
              | TensorListResize | Resizes the list. | 
        
              | TensorListScatter | Creates a TensorList by indexing into a Tensor. | 
        
              | TensorListScatterIntoExistingList | Scatters tensor at indices in an input list. | 
        
              | TensorListScatterV2 | Creates a TensorList by indexing into a Tensor. | 
        
              | TensorListSetItem |  | 
        
              | TensorListSplit | Splits a tensor into a list. | 
        
              | TensorListStack<T> | Stacks all tensors in the list. | 
        
              | TensorMapErase | Returns a tensor map with item from given key erased. | 
        
              | TensorMapHasKey | Returns whether the given key exists in the map. | 
        
              | TensorMapInsert | Returns a map that is the 'input_handle' with the given key-value pair inserted. | 
        
              | TensorMapLookup<U> | Returns the value from a given key in a tensor map. | 
        
              | TensorMapSize | Returns the number of tensors in the input tensor map. | 
        
              | TensorMapStackKeys<T> | Returns a Tensor stack of all keys in a tensor map. | 
        
              | TensorScatterAdd<T> | Adds sparse `updates` to an existing tensor according to `indices`. | 
        
              | TensorScatterMax<T> |  | 
        
              | TensorScatterMin<T> |  | 
        
              | TensorScatterSub<T> | Subtracts sparse `updates` from an existing tensor according to `indices`. | 
        
              | TensorScatterUpdate<T> | Scatter `updates` into an existing tensor according to `indices`. | 
        
              | TensorStridedSliceUpdate<T> | Assign `value` to the sliced l-value reference of `input`. | 
        
              | ThreadPoolDataset | Creates a dataset that uses a custom thread pool to compute `input_dataset`. | 
        
              | ThreadPoolHandle | Creates a dataset that uses a custom thread pool to compute `input_dataset`. | 
        
              | Tile<T> | Constructs a tensor by tiling a given tensor. | 
        
              | Timestamp | Provides the time since epoch in seconds. | 
        
              | ToBool | Converts a tensor to a scalar predicate. | 
        
              | 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. | 
        
              | UnicodeEncode | Encode a tensor of ints into unicode strings. | 
        
              | UniqueDataset | Creates a dataset that contains the unique elements of `input_dataset`. | 
        
              | 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`. | 
        
              | 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 |  | 
        
              | XlaRecvFromHost<T> | An op to receive a tensor from the host. | 
        
              | 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. |