* Extracts a slice from a `tf.Tensor` starting at coordinates `begin` * and is of size `size`. * * Also available are stricter rank-specific method

* Computes the softmax cross entropy loss between two tensors. * * If labelSmoothing is nonzero, smooth the labels towards 1/2: * * newOnehotLab

* Computes the softmax normalized vector given the logits. * * ```js * const a = tf.tensor1d([1, 2, 3]); * * a.softmax().print(); // or tf.softm

* Computes softplus of the input `tf.Tensor` element-wise: `log(exp(x) + 1)` * * ```js * const x = tf.tensor1d([0, 1, -1, .7]); * * x.softplus().

* This operation divides "spatial" dimensions `[1, ..., M]` of the input into * a grid of blocks of shape `blockShape`, and interleaves these blocks

* The input SparseTensor is represented via the map of inputs {`indices`, * `values`, `denseShape`}. The output SparseTensor has the same `denseShape

* This operation has the same semantics as reshape on the represented dense * tensor. The `inputIndices` are recomputed based on the requested `newSh

* Computes the mean along sparse segments of a tensor. * * ```js * const c = tf.tensor2d([[1,2,3,4], [-1,-2,-3,-4], [6,7,8,9]]); * // Select two r

* Computes the sum along sparse segments of a tensor. * * ```js * const c = tf.tensor2d([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]]); * // Select two ro

* Converts a sparse representation into a dense tensor. * * Builds an array dense with shape outputShape such that: * * // If sparseIndices is sca

* Splits a string stream on a given separator. * * It is assumed that the incoming chunk boundaries have no semantic meaning, * so conceptual

* Split the values of a Tensor into the TensorArray. * @param length number[] with the lengths to use when splitting value along * its first

* Splits a `tf.Tensor` into sub tensors. * * If `numOrSizeSplits` is a number, splits `x` along dimension `axis` * into `numOrSizeSplits` smaller t

* Computes square root of the input `tf.Tensor` element-wise: `y = sqrt(x)` * * ```js * const x = tf.tensor1d([1, 2, 4, -1]); * * x.sqrt().print(

* Computes square of `x` element-wise: `x ^ 2` * * ```js * const x = tf.tensor1d([1, 2, Math.sqrt(2), -1]); * * x.square().print(); // or tf.squ

* Returns (a - b) * (a - b) element-wise. * Supports broadcasting. * * ```js * const a = tf.tensor1d([1, 4, 3, 16]); * const b = tf.tensor1d([1,

* Removes dimensions of size 1 from the shape of a `tf.Tensor`. * * ```js * const x = tf.tensor([1, 2, 3, 4], [1, 1, 4]); * x.squeeze().print();

* Return a tensor that stacks a list of rank-R tf.Tensors into one rank-(R+1) * tf.Tensor. * @param elementShape shape of each tensor * @para

* Stacks a list of rank-`R` `tf.Tensor`s into one rank-`(R+1)` `tf.Tensor`. * * ```js * const a = tf.tensor1d([1, 2]); * const b = tf.tensor1d([3,

* Determine whether the container is stateful. * * Porting Note: this is the equivalent of the stateful @property of * the Container class

* Get the current state tensors of the RNN. * * If the state hasn't been set, return an array of `null`s of the correct * length.

* Replace the match of a `pattern` in `input` with `rewrite`. * * ```js * const result = tf.string.staticRegexReplace( * ['format this

* Computes step of the input `tf.Tensor` element-wise: `x > 0 ? 1 : alpha` * * ```js * const x = tf.tensor1d([0, 2, -1, -3]); * * x.step(.5).prin

* Computes the Short-time Fourier Transform of signals * See: https://en.wikipedia.org/wiki/Short-time_Fourier_transform * * ```js * const input =

* Setter used for force stopping of LayersModel.fit() (i.e., training). * * Example: * * ```js * const model = tf.sequential(); * mo

* Setter used for force stopping of LayersModel.fit() (i.e., training). * * Example: * * ```js * const input = tf.input({shape: [10]});

* Extracts a strided slice of a tensor. * * Roughly speaking, this op extracts a slice of size (end-begin)/stride from * the given input tensor (x)

* Creates ngrams from ragged string data. * * This op accepts a ragged tensor with 1 ragged dimension containing only * strings and outputs a ragge

* Split elements of `input` based on `delimiter` into a SparseTensor . * * Let N be the size of source (typically N will be the batch size). Split e

* Converts each string in the input Tensor to its hash mod by a number of * buckets. * * The hash function is deterministic on the content of the s

* Subtracts two `tf.Tensor`s element-wise, A - B. Supports broadcasting. * * ```js * const a = tf.tensor1d([10, 20, 30, 40]); * const b = tf.tenso

* Computes the sum of elements across dimensions of a `tf.Tensor`. * * Reduces the input along the dimensions given in `axes`. Unless `keepDims` *