@huggingface/transformers 3.0.0-alpha.0

package/types/utils/tensor.d.ts

@@ -0,0 +1,392 @@
+/**
+ * Permutes a tensor according to the provided axes.
+ * @param {any} tensor The input tensor to permute.
+ * @param {Array} axes The axes to permute the tensor along.
+ * @returns {Tensor} The permuted tensor.
+ */
+export function permute(tensor: any, axes: any[]): Tensor;
+/**
+ * Interpolates an Tensor to the given size.
+ * @param {Tensor} input The input tensor to interpolate. Data must be channel-first (i.e., [c, h, w])
+ * @param {number[]} size The output size of the image
+ * @param {string} mode The interpolation mode
+ * @param {boolean} align_corners Whether to align corners.
+ * @returns {Tensor} The interpolated tensor.
+ */
+export function interpolate(input: Tensor, [out_height, out_width]: number[], mode?: string, align_corners?: boolean): Tensor;
+/**
+ * Down/up samples the input.
+ * Inspired by https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html.
+ * @param {Tensor} input the input tensor
+ * @param {Object} options the options for the interpolation
+ * @param {[number, number]|[number, number, number]|[number, number, number, number]} [options.size=null] output spatial size.
+ * @param {"bilinear"|"bicubic"} [options.mode='bilinear'] algorithm used for upsampling
+ * @returns {Promise<Tensor>} The interpolated tensor.
+ */
+export function interpolate_4d(input: Tensor, { size, mode, }?: {
+    size?: [number, number] | [number, number, number] | [number, number, number, number];
+    mode?: "bilinear" | "bicubic";
+}): Promise<Tensor>;
+/**
+ * Matrix product of two tensors.
+ * Inspired by https://pytorch.org/docs/stable/generated/torch.matmul.html
+ * @param {Tensor} a the first tensor to be multiplied
+ * @param {Tensor} b the second tensor to be multiplied
+ * @returns {Promise<Tensor>} The matrix product of the two tensors.
+ */
+export function matmul(a: Tensor, b: Tensor): Promise<Tensor>;
+/**
+ * Computes the one dimensional Fourier transform of real-valued input.
+ * Inspired by https://pytorch.org/docs/stable/generated/torch.fft.rfft.html
+ * @param {Tensor} x the real input tensor
+ * @param {Tensor} a The dimension along which to take the one dimensional real FFT.
+ * @returns {Promise<Tensor>} the output tensor.
+ */
+export function rfft(x: Tensor, a: Tensor): Promise<Tensor>;
+/**
+ * Returns the k largest elements of the given input tensor.
+ * Inspired by https://pytorch.org/docs/stable/generated/torch.topk.html
+ * @param {Tensor} x the input tensor
+ * @param {number} k the k in "top-k"
+ * @returns {Promise<[Tensor, Tensor]>} the output tuple of (Tensor, LongTensor) of top-k elements and their indices.
+ */
+export function topk(x: Tensor, k: number): Promise<[Tensor, Tensor]>;
+/**
+ * Perform mean pooling of the last hidden state followed by a normalization step.
+ * @param {Tensor} last_hidden_state Tensor of shape [batchSize, seqLength, embedDim]
+ * @param {Tensor} attention_mask Tensor of shape [batchSize, seqLength]
+ * @returns {Tensor} Returns a new Tensor of shape [batchSize, embedDim].
+ */
+export function mean_pooling(last_hidden_state: Tensor, attention_mask: Tensor): Tensor;
+/**
+ * Apply Layer Normalization for last certain number of dimensions.
+ * @param {Tensor} input The input tensor
+ * @param {number[]} normalized_shape input shape from an expected input of size
+ * @param {Object} options The options for the layer normalization
+ * @param {number} [options.eps=1e-5] A value added to the denominator for numerical stability.
+ * @returns {Tensor} The normalized tensor.
+ */
+export function layer_norm(input: Tensor, normalized_shape: number[], { eps, }?: {
+    eps?: number;
+}): Tensor;
+/**
+ * Concatenates an array of tensors along a specified dimension.
+ * @param {Tensor[]} tensors The array of tensors to concatenate.
+ * @param {number} dim The dimension to concatenate along.
+ * @returns {Tensor} The concatenated tensor.
+ */
+export function cat(tensors: Tensor[], dim?: number): Tensor;
+/**
+ * Stack an array of tensors along a specified dimension.
+ * @param {Tensor[]} tensors The array of tensors to stack.
+ * @param {number} dim The dimension to stack along.
+ * @returns {Tensor} The stacked tensor.
+ */
+export function stack(tensors: Tensor[], dim?: number): 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.
+ * @param {Tensor} input the input tenso
+ * @param {number|null} dim the dimension to reduce. If None, all dimensions are reduced.
+ * @param {number} correction difference between the sample size and sample degrees of freedom. Defaults to Bessel's correction, correction=1.
+ * @param {boolean} keepdim whether the output tensor has dim retained or not.
+ * @returns {Tensor[]} A tuple of (std, mean) tensors.
+ */
+export function std_mean(input: Tensor, dim?: number | null, correction?: number, keepdim?: boolean): Tensor[];
+/**
+ * Returns the mean value of each row of the input tensor in the given dimension dim.
+ * @param {Tensor} input the input tensor.
+ * @param {number|null} dim the dimension to reduce.
+ * @param {boolean} keepdim whether the output tensor has dim retained or not.
+ * @returns {Tensor} A new tensor with means taken along the specified dimension.
+ */
+export function mean(input: Tensor, dim?: number | null, keepdim?: boolean): Tensor;
+/**
+ * Creates a tensor of size size filled with fill_value. The tensor's dtype is inferred from fill_value.
+ * @param {number[]} size A sequence of integers defining the shape of the output tensor.
+ * @param {number|bigint} fill_value The value to fill the output tensor with.
+ * @returns {Tensor} The filled tensor.
+ */
+export function full(size: number[], fill_value: number | bigint): Tensor;
+export function full_like(tensor: any, fill_value: any): Tensor;
+/**
+ * Returns a tensor filled with the scalar value 1, with the shape defined by the variable argument size.
+ * @param {number[]} size A sequence of integers defining the shape of the output tensor.
+ * @returns {Tensor} The ones tensor.
+ */
+export function ones(size: number[]): Tensor;
+/**
+ * Returns a tensor filled with the scalar value 1, with the same size as input.
+ * @param {Tensor} tensor The size of input will determine size of the output tensor.
+ * @returns {Tensor} The ones tensor.
+ */
+export function ones_like(tensor: Tensor): Tensor;
+/**
+ * Returns a tensor filled with the scalar value 0, with the shape defined by the variable argument size.
+ * @param {number[]} size A sequence of integers defining the shape of the output tensor.
+ * @returns {Tensor} The zeros tensor.
+ */
+export function zeros(size: number[]): Tensor;
+/**
+ * Returns a tensor filled with the scalar value 0, with the same size as input.
+ * @param {Tensor} tensor The size of input will determine size of the output tensor.
+ * @returns {Tensor} The zeros tensor.
+ */
+export function zeros_like(tensor: Tensor): Tensor;
+/**
+ * Quantizes the embeddings tensor to binary or unsigned binary precision.
+ * @param {Tensor} tensor The tensor to quantize.
+ * @param {'binary'|'ubinary'} precision The precision to use for quantization.
+ * @returns {Tensor} The quantized tensor.
+ */
+export function quantize_embeddings(tensor: Tensor, precision: 'binary' | 'ubinary'): Tensor;
+/**
+ * @typedef {keyof typeof DataTypeMap} DataType
+ * @typedef {import('./maths.js').AnyTypedArray | any[]} DataArray
+ */
+export class Tensor {
+    /**
+     * Create a new Tensor or copy an existing Tensor.
+     * @param {[DataType, DataArray, number[]]|[ONNXTensor]} args
+     */
+    constructor(...args: [DataType, DataArray, number[]] | [ONNXTensor]);
+    set dims(arg: number[]);
+    /** @type {number[]} Dimensions of the tensor. */
+    get dims(): number[];
+    /** @type {DataType} Type of the tensor. */
+    get type(): "string" | "int8" | "uint8" | "float32" | "uint16" | "int16" | "int32" | "int64" | "bool" | "float16" | "float64" | "uint32" | "uint64";
+    /** @type {DataArray} The data stored in the tensor. */
+    get data(): DataArray;
+    /** @type {number} The number of elements in the tensor. */
+    get size(): number;
+    /** @type {string} The location of the tensor data. */
+    get location(): string;
+    ort_tensor: ONNXTensor;
+    dispose(): void;
+    /**
+     * Index into a Tensor object.
+     * @param {number} index The index to access.
+     * @returns {Tensor} The data at the specified index.
+     */
+    _getitem(index: number): Tensor;
+    /**
+     * @param {number|bigint} item The item to search for in the tensor
+     * @returns {number} The index of the first occurrence of item in the tensor data.
+     */
+    indexOf(item: number | bigint): number;
+    /**
+     * @param {number} index
+     * @param {number} iterSize
+     * @param {any} iterDims
+     * @returns {Tensor}
+     */
+    _subarray(index: number, iterSize: number, iterDims: any): Tensor;
+    /**
+     * 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()`.
+     * @returns {number|bigint} The value of this tensor as a standard JavaScript Number.
+     * @throws {Error} If the tensor has more than one element.
+     */
+    item(): number | bigint;
+    /**
+     * Convert tensor data to a n-dimensional JS list
+     * @returns {Array}
+     */
+    tolist(): any[];
+    /**
+     * Return a new Tensor with the sigmoid function applied to each element.
+     * @returns {Tensor} The tensor with the sigmoid function applied.
+     */
+    sigmoid(): Tensor;
+    /**
+     * Applies the sigmoid function to the tensor in place.
+     * @returns {Tensor} Returns `this`.
+     */
+    sigmoid_(): Tensor;
+    /**
+     * Return a new Tensor with every element multiplied by a constant.
+     * @param {number} val The value to multiply by.
+     * @returns {Tensor} The new tensor.
+     */
+    mul(val: number): Tensor;
+    /**
+     * Multiply the tensor by a constant in place.
+     * @param {number} val The value to multiply by.
+     * @returns {Tensor} Returns `this`.
+     */
+    mul_(val: number): Tensor;
+    /**
+     * Return a new Tensor with every element divided by a constant.
+     * @param {number} val The value to divide by.
+     * @returns {Tensor} The new tensor.
+     */
+    div(val: number): Tensor;
+    /**
+     * Divide the tensor by a constant in place.
+     * @param {number} val The value to divide by.
+     * @returns {Tensor} Returns `this`.
+     */
+    div_(val: number): Tensor;
+    /**
+     * Return a new Tensor with every element added by a constant.
+     * @param {number} val The value to add by.
+     * @returns {Tensor} The new tensor.
+     */
+    add(val: number): Tensor;
+    /**
+     * Add the tensor by a constant in place.
+     * @param {number} val The value to add by.
+     * @returns {Tensor} Returns `this`.
+     */
+    add_(val: number): Tensor;
+    clone(): Tensor;
+    slice(...slices: any[]): Tensor;
+    /**
+     * Return a permuted version of this Tensor, according to the provided dimensions.
+     * @param  {...number} dims Dimensions to permute.
+     * @returns {Tensor} The permuted tensor.
+     */
+    permute(...dims: number[]): Tensor;
+    transpose(...dims: any[]): Tensor;
+    /**
+     * Returns the sum of each row of the input tensor in the given dimension dim.
+     *
+     * @param {number} [dim=null] The dimension or dimensions to reduce. If `null`, all dimensions are reduced.
+     * @param {boolean} keepdim Whether the output tensor has `dim` retained or not.
+     * @returns The summed tensor
+     */
+    sum(dim?: number, keepdim?: boolean): Tensor;
+    /**
+     * Returns the matrix norm or vector norm of a given tensor.
+     * @param {number|string} [p='fro'] The order of norm
+     * @param {number} [dim=null] 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.
+     * @param {boolean} [keepdim=false] Whether the output tensors have dim retained or not.
+     * @returns {Tensor} The norm of the tensor.
+     */
+    norm(p?: number | string, dim?: number, keepdim?: boolean): Tensor;
+    /**
+     * Performs `L_p` normalization of inputs over specified dimension. Operates in place.
+     * @param {number} [p=2] The exponent value in the norm formulation
+     * @param {number} [dim=1] The dimension to reduce
+     * @returns {Tensor} `this` for operation chaining.
+     */
+    normalize_(p?: number, dim?: number): Tensor;
+    /**
+     * Performs `L_p` normalization of inputs over specified dimension.
+     * @param {number} [p=2] The exponent value in the norm formulation
+     * @param {number} [dim=1] The dimension to reduce
+     * @returns {Tensor} The normalized tensor.
+     */
+    normalize(p?: number, dim?: number): Tensor;
+    /**
+     * 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.
+     * @returns {number[]} The stride of this tensor.
+     */
+    stride(): number[];
+    /**
+     * 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.
+     *
+     * @param {number} [dim=null] If given, the input will be squeezed only in the specified dimensions.
+     * @returns {Tensor} The squeezed tensor
+     */
+    squeeze(dim?: number): Tensor;
+    /**
+     * In-place version of @see {@link Tensor.squeeze}
+     */
+    squeeze_(dim?: any): this;
+    /**
+     * 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.
+     *
+     * @param {number} dim The index at which to insert the singleton dimension
+     * @returns {Tensor} The unsqueezed tensor
+     */
+    unsqueeze(dim?: number): Tensor;
+    /**
+     * In-place version of @see {@link Tensor.unsqueeze}
+     */
+    unsqueeze_(dim?: any): this;
+    /**
+     * In-place version of @see {@link Tensor.flatten}
+     */
+    flatten_(start_dim?: number, end_dim?: number): this;
+    /**
+     * 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.
+     * @param {number} start_dim the first dim to flatten
+     * @param {number} end_dim the last dim to flatten
+     * @returns {Tensor} The flattened tensor.
+     */
+    flatten(start_dim?: number, end_dim?: number): Tensor;
+    /**
+     * Returns a new tensor with the same data as the `self` tensor but of a different `shape`.
+     * @param  {...number} dims the desired size
+     * @returns {Tensor} The tensor with the same data but different shape
+     */
+    view(...dims: number[]): Tensor;
+    neg_(): this;
+    neg(): Tensor;
+    /**
+     * In-place version of @see {@link Tensor.clamp}
+     */
+    clamp_(min: any, max: any): this;
+    /**
+     * Clamps all elements in input into the range [ min, max ]
+     * @param {number} min lower-bound of the range to be clamped to
+     * @param {number} max upper-bound of the range to be clamped to
+     * @returns {Tensor} the output tensor.
+     */
+    clamp(min: number, max: number): Tensor;
+    /**
+     * In-place version of @see {@link Tensor.round}
+     */
+    round_(): this;
+    /**
+     * Rounds elements of input to the nearest integer.
+     * @returns {Tensor} the output tensor.
+     */
+    round(): Tensor;
+    mean(dim?: any, keepdim?: boolean): Tensor;
+    /**
+     * Performs Tensor dtype conversion.
+     * @param {DataType} type The desired data type.
+     * @returns {Tensor} The converted tensor.
+     */
+    to(type: DataType): Tensor;
+    /**
+     * 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.
+     * @returns {Iterator} An iterator object for iterating over the tensor data in row-major order.
+     */
+    [Symbol.iterator](): Iterator<any, any, undefined>;
+}
+/**
+ * This creates a nested array of a given type and depth (see examples).
+ */
+export type NestArray<T, Depth extends number, Acc extends never[] = []> = Acc['length'] extends Depth ? T : NestArray<T[], Depth, [...Acc, never]>;
+export type DataType = keyof typeof DataTypeMap;
+export type DataArray = import('./maths.js').AnyTypedArray | any[];
+import { Tensor as ONNXTensor } from '../backends/onnx.js';
+declare const DataTypeMap: Readonly<{
+    float32: Float32ArrayConstructor;
+    float16: Uint16ArrayConstructor;
+    float64: Float64ArrayConstructor;
+    string: ArrayConstructor;
+    int8: Int8ArrayConstructor;
+    uint8: Uint8ArrayConstructor;
+    int16: Int16ArrayConstructor;
+    uint16: Uint16ArrayConstructor;
+    int32: Int32ArrayConstructor;
+    uint32: Uint32ArrayConstructor;
+    int64: BigInt64ArrayConstructor;
+    uint64: BigUint64ArrayConstructor;
+    bool: Uint8ArrayConstructor;
+}>;
+export {};
+//# sourceMappingURL=tensor.d.ts.map

package/types/utils/tensor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tensor.d.ts","sourceRoot":"","sources":["../../src/utils/tensor.js"],"names":[],"mappings":"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"}