| 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.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | 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.  | 
          
        
              | 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.  |