#
utils/tensor

Helper module for `Tensor` processing.

These functions and classes are only used internally, meaning an end-user shouldn’t need to access anything here.

- utils/tensor
  - static
    - .Tensor
      - `new Tensor(...args)`
      - `.Symbol.iterator()` ⇒ `Iterator`
      - `._getitem(index)` ⇒ `Tensor`
      - `.indexOf(item)` ⇒ `number`
      - `._subarray(index, iterSize, iterDims)` ⇒ `Tensor`
      - `.item()` ⇒ `number`
      - `.tolist()` ⇒ `Array`
      - `.sigmoid()` ⇒ `Tensor`
      - `.sigmoid_()` ⇒ `Tensor`
      - `.transpose(...dims)` ⇒ `Tensor`
      - `.sum([dim], keepdim)` ⇒
      - `.norm([p], [dim], [keepdim])` ⇒ `Tensor`
      - `.normalize_([p], [dim])` ⇒ `Tensor`
      - `.normalize([p], [dim])` ⇒ `Tensor`
      - `.stride()` ⇒ `Array.<number>`
      - `.squeeze([dim])` ⇒
      - `.squeeze_()`
      - `.unsqueeze(dim)` ⇒
      - `.unsqueeze_()`
      - `.flatten_()`
      - `.flatten(start_dim, end_dim)` ⇒
      - `.view(...dims)` ⇒ `Tensor`
    - `.transpose(tensor, axes)` ⇒ `Tensor`
    - `.interpolate(input, size, mode, align_corners)` ⇒ `Tensor`
    - `.mean_pooling(last_hidden_state, attention_mask)` ⇒ `Tensor`
    - `.cat(tensors, dim)` ⇒ `Tensor`
    - `.stack(tensors, dim)` ⇒ `Tensor`
    - `.std_mean(input, dim, correction, keepdim)` ⇒ `Array.<Tensor>`
    - `.mean(input, dim, keepdim)` ⇒
    - `.dynamicTimeWarping(matrix)` ⇒ `Array.<Array<number>>`
  - inner
    - `~ONNXTensor` : `Object`
    - `~reshape(data, dimensions)` ⇒ `*`
      - `~reshapedArray` : `any`
    - `~AnyTypedArray` : `*`
    - `~NestArray` : `*`

##
utils/tensor.Tensor

Kind: static class of `utils/tensor`

- .Tensor
  - `new Tensor(...args)`
  - `.Symbol.iterator()` ⇒ `Iterator`
  - `._getitem(index)` ⇒ `Tensor`
  - `.indexOf(item)` ⇒ `number`
  - `._subarray(index, iterSize, iterDims)` ⇒ `Tensor`
  - `.item()` ⇒ `number`
  - `.tolist()` ⇒ `Array`
  - `.sigmoid()` ⇒ `Tensor`
  - `.sigmoid_()` ⇒ `Tensor`
  - `.transpose(...dims)` ⇒ `Tensor`
  - `.sum([dim], keepdim)` ⇒
  - `.norm([p], [dim], [keepdim])` ⇒ `Tensor`
  - `.normalize_([p], [dim])` ⇒ `Tensor`
  - `.normalize([p], [dim])` ⇒ `Tensor`
  - `.stride()` ⇒ `Array.<number>`
  - `.squeeze([dim])` ⇒
  - `.squeeze_()`
  - `.unsqueeze(dim)` ⇒
  - `.unsqueeze_()`
  - `.flatten_()`
  - `.flatten(start_dim, end_dim)` ⇒
  - `.view(...dims)` ⇒ `Tensor`

###
`new Tensor(...args)`

Create a new Tensor or copy an existing Tensor.

Param | Type
--- | ---
...args | `*`

###
`tensor.Symbol.iterator()` ⇒ `Iterator`

Returns an iterator object for iterating over the tensor data in row-major order. If the tensor has more than one dimension, the iterator will yield subarrays.

Kind: instance method of `Tensor`
Returns: `Iterator` - An iterator object for iterating over the tensor data in row-major order.

###
`tensor._getitem(index)` ⇒ `Tensor`

Index into a Tensor object.

Kind: instance method of `Tensor`
Returns: `Tensor` - The data at the specified index.

Param | Type | Description
--- | --- | ---
index | `number` | The index to access.

###
`tensor.indexOf(item)` ⇒ `number`

Kind: instance method of `Tensor`
Returns: `number` - The index of the first occurrence of item in the tensor data.

Param | Type | Description
--- | --- | ---
item | `number` | `bigint` | The item to search for in the tensor

###
`tensor._subarray(index, iterSize, iterDims)` ⇒ `Tensor`

Kind: instance method of `Tensor`

Param | Type
--- | ---
index | `number`
iterSize | `number`
iterDims | `any`

###
`tensor.item()` ⇒ `number`

Returns the value of this tensor as a standard JavaScript Number. This only works for tensors with one element. For other cases, see `Tensor.tolist()`.

Kind: instance method of `Tensor`
Returns: `number` - The value of this tensor as a standard JavaScript Number.
Throws:

- `Error` If the tensor has more than one element.

###
`tensor.tolist()` ⇒ `Array`

Convert tensor data to a n-dimensional JS list

Kind: instance method of `Tensor`

###
`tensor.sigmoid()` ⇒ `Tensor`

Return a new Tensor with the sigmoid function applied to each element.

Kind: instance method of `Tensor`
Returns: `Tensor` - The tensor with the sigmoid function applied.

###
`tensor.sigmoid_()` ⇒ `Tensor`

Applies the sigmoid function to the tensor in place.

Kind: instance method of `Tensor`
Returns: `Tensor` - Returns `this`.

###
`tensor.transpose(...dims)` ⇒ `Tensor`

Return a transposed version of this Tensor, according to the provided dimensions.

Kind: instance method of `Tensor`
Returns: `Tensor` - The transposed tensor.

Param | Type | Description
--- | --- | ---
...dims | `number` | Dimensions to transpose.

###
`tensor.sum([dim], keepdim)` ⇒

Returns the sum of each row of the input tensor in the given dimension dim.

Kind: instance method of `Tensor`
Returns: The summed tensor

Param | Type | Default | Description
--- | --- | --- | ---
[dim] | `number` | `` | The dimension or dimensions to reduce. If `null`, all dimensions are reduced.
keepdim | `boolean` | `false` | Whether the output tensor has `dim` retained or not.

###
`tensor.norm([p], [dim], [keepdim])` ⇒ `Tensor`

Returns the matrix norm or vector norm of a given tensor.

Kind: instance method of `Tensor`
Returns: `Tensor` - The norm of the tensor.

Param | Type | Default | Description
--- | --- | --- | ---
[p] | `number` | `string` | `'fro'` | The order of norm
[dim] | `number` | `` | Specifies which dimension of the tensor to calculate the norm across. If dim is None, the norm will be calculated across all dimensions of input.
[keepdim] | `boolean` | `false` | Whether the output tensors have dim retained or not.

###
`tensor.normalize_([p], [dim])` ⇒ `Tensor`

Performs `L_p` normalization of inputs over specified dimension. Operates in place.

Kind: instance method of `Tensor`
Returns: `Tensor` - `this` for operation chaining.

Param | Type | Default | Description
--- | --- | --- | ---
[p] | `number` | `2` | The exponent value in the norm formulation
[dim] | `number` | `1` | The dimension to reduce

###
`tensor.normalize([p], [dim])` ⇒ `Tensor`

Performs `L_p` normalization of inputs over specified dimension.

Kind: instance method of `Tensor`
Returns: `Tensor` - The normalized tensor.

Param | Type | Default | Description
--- | --- | --- | ---
[p] | `number` | `2` | The exponent value in the norm formulation
[dim] | `number` | `1` | The dimension to reduce

###
`tensor.stride()` ⇒ `Array.<number>`

Compute and return the stride of this tensor. Stride is the jump necessary to go from one element to the next one in the specified dimension dim.

Kind: instance method of `Tensor`
Returns: `Array.<number>` - The stride of this tensor.

###
`tensor.squeeze([dim])` ⇒

Returns a tensor with all specified dimensions of input of size 1 removed.

NOTE: The returned tensor shares the storage with the input tensor, so changing the contents of one will change the contents of the other. If you would like a copy, use `tensor.clone()` before squeezing.

Kind: instance method of `Tensor`
Returns: The squeezed tensor

Param | Type | Default | Description
--- | --- | --- | ---
[dim] | `number` | `` | If given, the input will be squeezed only in the specified dimensions.

###
`tensor.squeeze_()`

In-place version of @see Tensor.squeeze

Kind: instance method of `Tensor`

###
`tensor.unsqueeze(dim)` ⇒

Returns a new tensor with a dimension of size one inserted at the specified position.

NOTE: The returned tensor shares the same underlying data with this tensor.

Kind: instance method of `Tensor`
Returns: The unsqueezed tensor

Param | Type | Default | Description
--- | --- | --- | ---
dim | `number` | `` | The index at which to insert the singleton dimension

###
`tensor.unsqueeze_()`

In-place version of @see Tensor.unsqueeze

Kind: instance method of `Tensor`

###
`tensor.flatten_()`

In-place version of @see Tensor.flatten

Kind: instance method of `Tensor`

###
`tensor.flatten(start_dim, end_dim)` ⇒

Flattens input by reshaping it into a one-dimensional tensor. If `start_dim` or `end_dim` are passed, only dimensions starting with `start_dim` and ending with `end_dim` are flattened. The order of elements in input is unchanged.

Kind: instance method of `Tensor`
Returns: The flattened tensor.

Param | Type | Default | Description
--- | --- | --- | ---
start_dim | `number` | `0` | the first dim to flatten
end_dim | `number` |  | the last dim to flatten

###
`tensor.view(...dims)` ⇒ `Tensor`

Returns a new tensor with the same data as the `self` tensor but of a different `shape`.

Kind: instance method of `Tensor`
Returns: `Tensor` - The tensor with the same data but different shape

Param | Type | Description
--- | --- | ---
...dims | `number` | the desired size

##
`utils/tensor.transpose(tensor, axes)` ⇒ `Tensor`

Transposes a tensor according to the provided axes.

Kind: static method of `utils/tensor`
Returns: `Tensor` - The transposed tensor.

Param | Type | Description
--- | --- | ---
tensor | `any` | The input tensor to transpose.
axes | `Array` | The axes to transpose the tensor along.

##
`utils/tensor.interpolate(input, size, mode, align_corners)` ⇒ `Tensor`

Interpolates an Tensor to the given size.

Kind: static method of `utils/tensor`
Returns: `Tensor` - The interpolated tensor.

Param | Type | Description
--- | --- | ---
input | `Tensor` | The input tensor to interpolate. Data must be channel-first (i.e., [c, h, w])
size | `Array.<number>` | The output size of the image
mode | `string` | The interpolation mode
align_corners | `boolean` | Whether to align corners.

##
`utils/tensor.mean_pooling(last_hidden_state, attention_mask)` ⇒ `Tensor`

Perform mean pooling of the last hidden state followed by a normalization step.

Kind: static method of `utils/tensor`
Returns: `Tensor` - Returns a new Tensor of shape [batchSize, embedDim].

Param | Type | Description
--- | --- | ---
last_hidden_state | `Tensor` | Tensor of shape [batchSize, seqLength, embedDim]
attention_mask | `Tensor` | Tensor of shape [batchSize, seqLength]

##
`utils/tensor.cat(tensors, dim)` ⇒ `Tensor`

Concatenates an array of tensors along a specified dimension.

Kind: static method of `utils/tensor`
Returns: `Tensor` - The concatenated tensor.

Param | Type | Description
--- | --- | ---
tensors | `Array.<Tensor>` | The array of tensors to concatenate.
dim | `number` | The dimension to concatenate along.

##
`utils/tensor.stack(tensors, dim)` ⇒ `Tensor`

Stack an array of tensors along a specified dimension.

Kind: static method of `utils/tensor`
Returns: `Tensor` - The stacked tensor.

Param | Type | Description
--- | --- | ---
tensors | `Array.<Tensor>` | The array of tensors to stack.
dim | `number` | The dimension to stack along.

##
`utils/tensor.std_mean(input, dim, correction, keepdim)` ⇒ `Array.<Tensor>`

Calculates the standard deviation and mean over the dimensions specified by dim. dim can be a single dimension or `null` to reduce over all dimensions.

Kind: static method of `utils/tensor`
Returns: `Array.<Tensor>` - A tuple of (std, mean) tensors.

Param | Type | Description
--- | --- | ---
input | `Tensor` | the input tenso
dim | `number` | `null` | the dimension to reduce. If None, all dimensions are reduced.
correction | `number` | difference between the sample size and sample degrees of freedom. Defaults to Bessel's correction, correction=1.
keepdim | `boolean` | whether the output tensor has dim retained or not.

##
`utils/tensor.mean(input, dim, keepdim)` ⇒

Returns the mean value of each row of the input tensor in the given dimension dim.

Kind: static method of `utils/tensor`
Returns: A new tensor with means taken along the specified dimension.

Param | Type | Description
--- | --- | ---
input | `Tensor` | the input tensor.
dim | `number` | `null` | the dimension to reduce.
keepdim | `boolean` | whether the output tensor has dim retained or not.

##
`utils/tensor.dynamicTimeWarping(matrix)` ⇒ `Array.<Array<number>>`

Measures similarity between two temporal sequences (e.g., input audio and output tokens to generate token-level timestamps).

Kind: static method of `utils/tensor`

Param | Type
--- | ---
matrix | `Tensor`

##
`utils/tensor~ONNXTensor` : `Object`

Kind: inner constant of `utils/tensor`

##
`utils/tensor~reshape(data, dimensions)` ⇒ `*`

Reshapes a 1-dimensional array into an n-dimensional array, according to the provided dimensions.

Kind: inner method of `utils/tensor`
Returns: `*` - The reshaped array.

Param | Type | Description
--- | --- | ---
data | `Array.<T>` | The input array to reshape.
dimensions | `DIM` | The target shape/dimensions.

Example

    reshape([10                    ], [1      ]); // Type: number[]      Value: [10]
      reshape([1, 2, 3, 4            ], [2, 2   ]); // Type: number[][]    Value: [[1, 2], [3, 4]]
      reshape([1, 2, 3, 4, 5, 6, 7, 8], [2, 2, 2]); // Type: number[][][]  Value: [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
      reshape([1, 2, 3, 4, 5, 6, 7, 8], [4, 2   ]); // Type: number[][]    Value: [[1, 2], [3, 4], [5, 6], [7, 8]]

###
`reshape~reshapedArray` : `any`

Kind: inner property of `reshape`

##
`utils/tensor~AnyTypedArray` : `*`

Kind: inner typedef of `utils/tensor`

##
`utils/tensor~NestArray` : `*`

This creates a nested array of a given type and depth (see examples).

Kind: inner typedef of `utils/tensor`
Example

    NestArray<string, 1>; // string[]

Example

    NestArray<number, 2>; // number[][]

Example

    NestArray<string, 3>; // string[][][] etc.