Transformers.js documentation

utils/maths

Transformers.js

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

utils/maths

Helper module for mathematical processing.

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

utils/maths
- static
  - .interpolate_data(input)
  - .permute_data(array, dims, axes) ⇒ *
  - .softmax(arr) ⇒ T
  - .log_softmax(arr) ⇒ T
  - .dot(arr1, arr2) ⇒ number
  - .getTopItems(items, [top_k]) ⇒ *
  - .cos_sim(arr1, arr2) ⇒ number
  - .magnitude(arr) ⇒ number
  - .min(arr) ⇒ Array.<number>
  - .max(arr) ⇒ *
  - .medianFilter(data, windowSize)
  - .round(num, decimals) ⇒ number
  - .bankers_round(x) ⇒ number
- inner
  - ~P2FFT
    - new P2FFT(size)
    - .createComplexArray() ⇒ Float64Array
    - .fromComplexArray(complex, [storage]) ⇒ Array.<number>
    - .toComplexArray(input, [storage]) ⇒ Float64Array
    - .transform(out, data) ⇒ void
    - .realTransform(out, data)
    - .inverseTransform(out, data) ⇒ void
    - ._transform4(out, data, inv) ⇒ void
    - ._singleTransform2(data, out, outOff, off, step) ⇒ void
    - ._singleTransform4(data, out, outOff, off, step, inv) ⇒ void
    - ._realTransform4(out, data, inv)
    - ._singleRealTransform2(data, out, outOff, off, step) ⇒ void
    - ._singleRealTransform4(data, out, outOff, off, step, inv)
  - ~NP2FFT
    - new NP2FFT(fft_length)
  - ~AnyTypedArray : Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array

utils/maths.interpolate_data(input)

Kind: static method of utils/maths

Param	Type
input	`TypedArray`

utils/maths.permute_data(array, dims, axes) ⇒ <code> * </code>

Helper method to permute a AnyTypedArray directly

Kind: static method of utils/maths
Returns: * - The permuted array and the new shape.

Param	Type
array	`T`
dims	`Array.<number>`
axes	`Array.<number>`

utils/maths.softmax(arr) ⇒ <code> T </code>

Compute the softmax of an array of numbers.

Kind: static method of utils/maths
Returns: T - The softmax array.

Param	Type	Description
arr	`T`	The array of numbers to compute the softmax of.

utils/maths.log_softmax(arr) ⇒ <code> T </code>

Calculates the logarithm of the softmax function for the input array.

Kind: static method of utils/maths
Returns: T - The resulting log_softmax array.

Param	Type	Description
arr	`T`	The input array to calculate the log_softmax function for.

utils/maths.dot(arr1, arr2) ⇒ <code> number </code>

Calculates the dot product of two arrays.

Kind: static method of utils/maths
Returns: number - The dot product of arr1 and arr2.

Param	Type	Description
arr1	`Array.<number>`	The first array.
arr2	`Array.<number>`	The second array.

utils/maths.getTopItems(items, [top_k]) ⇒ <code> * </code>

Get the top k items from an iterable, sorted by descending order

Kind: static method of utils/maths
Returns: * - The top k items, sorted by descending order

Param	Type	Default	Description
items	`Array<any>` \| `TypedArray`		The items to be sorted
[top_k]	`number` \| `null`	`0`	The number of top items to return (default: 0 = return all)

utils/maths.cos_sim(arr1, arr2) ⇒ <code> number </code>

Computes the cosine similarity between two arrays.

Kind: static method of utils/maths
Returns: number - The cosine similarity between the two arrays.

Param	Type	Description
arr1	`Array.<number>`	The first array.
arr2	`Array.<number>`	The second array.

utils/maths.magnitude(arr) ⇒ <code> number </code>

Calculates the magnitude of a given array.

Kind: static method of utils/maths
Returns: number - The magnitude of the array.

Param	Type	Description
arr	`Array.<number>`	The array to calculate the magnitude of.

utils/maths.min(arr) ⇒ <code> Array. < number > </code>

Returns the value and index of the minimum element in an array.

Kind: static method of utils/maths
Returns: Array.<number> - the value and index of the minimum element, of the form: [valueOfMin, indexOfMin]
Throws:

Error If array is empty.

Param	Type	Description
arr	`Array<number>` \| `TypedArray`	array of numbers.

utils/maths.max(arr) ⇒ <code> * </code>

Returns the value and index of the maximum element in an array.

Kind: static method of utils/maths
Returns: * - the value and index of the maximum element, of the form: [valueOfMax, indexOfMax]
Throws:

Error If array is empty.

Param	Type	Description
arr	`Array<number>` \| `AnyTypedArray`	array of numbers.

utils/maths.medianFilter(data, windowSize)

Performs median filter on the provided data. Padding is done by mirroring the data.

Kind: static method of utils/maths

Param	Type	Description
data	`AnyTypedArray`	The input array
windowSize	`number`	The window size

utils/maths.round(num, decimals) ⇒ <code> number </code>

Helper function to round a number to a given number of decimals

Kind: static method of utils/maths
Returns: number - The rounded number

Param	Type	Description
num	`number`	The number to round
decimals	`number`	The number of decimals

utils/maths.bankers_round(x) ⇒ <code> number </code>

Helper function to round a number to the nearest integer, with ties rounded to the nearest even number. Also known as “bankers’ rounding”. This is the default rounding mode in python. For example: 1.5 rounds to 2 and 2.5 rounds to 2.

Kind: static method of utils/maths
Returns: number - The rounded number

Param	Type	Description
x	`number`	The number to round

utils/maths~P2FFT

Implementation of Radix-4 FFT.

P2FFT class provides functionality for performing Fast Fourier Transform on arrays which are a power of two in length. Code adapted from https://www.npmjs.com/package/fft.js

Kind: inner class of utils/maths

~P2FFT
- new P2FFT(size)
- .createComplexArray() ⇒ Float64Array
- .fromComplexArray(complex, [storage]) ⇒ Array.<number>
- .toComplexArray(input, [storage]) ⇒ Float64Array
- .transform(out, data) ⇒ void
- .realTransform(out, data)
- .inverseTransform(out, data) ⇒ void
- ._transform4(out, data, inv) ⇒ void
- ._singleTransform2(data, out, outOff, off, step) ⇒ void
- ._singleTransform4(data, out, outOff, off, step, inv) ⇒ void
- ._realTransform4(out, data, inv)
- ._singleRealTransform2(data, out, outOff, off, step) ⇒ void
- ._singleRealTransform4(data, out, outOff, off, step, inv)

new P2FFT(size)

Throws:

Error FFT size must be a power of two larger than 1.

Param	Type	Description
size	`number`	The size of the input array. Must be a power of two larger than 1.

p2FFT.createComplexArray() ⇒ <code> Float64Array </code>

Create a complex number array with size 2 * size

Kind: instance method of P2FFT
Returns: Float64Array - A complex number array with size 2 * size

p2FFT.fromComplexArray(complex, [storage]) ⇒ <code> Array. < number > </code>

Converts a complex number representation stored in a Float64Array to an array of real numbers.

Kind: instance method of P2FFT
Returns: Array.<number> - An array of real numbers representing the input complex number representation.

Param	Type	Description
complex	`Float64Array`	The complex number representation to be converted.
[storage]	`Array.<number>`	An optional array to store the result in.

p2FFT.toComplexArray(input, [storage]) ⇒ <code> Float64Array </code>

Convert a real-valued input array to a complex-valued output array.

Kind: instance method of P2FFT
Returns: Float64Array - The complex-valued output array.

Param	Type	Description
input	`Float64Array`	The real-valued input array.
[storage]	`Float64Array`	Optional buffer to store the output array.

p2FFT.transform(out, data) ⇒ <code> void </code>

Performs a Fast Fourier Transform (FFT) on the given input data and stores the result in the output buffer.

Kind: instance method of P2FFT
Throws:

Error Input and output buffers must be different.

Param	Type	Description
out	`Float64Array`	The output buffer to store the result.
data	`Float64Array`	The input data to transform.

p2FFT.realTransform(out, data)

Performs a real-valued forward FFT on the given input buffer and stores the result in the given output buffer. The input buffer must contain real values only, while the output buffer will contain complex values. The input and output buffers must be different.

Kind: instance method of P2FFT
Throws:

Error If the input and output buffers are the same.

Param	Type	Description
out	`Float64Array`	The output buffer.
data	`Float64Array`	The input buffer containing real values.

p2FFT.inverseTransform(out, data) ⇒ <code> void </code>

Performs an inverse FFT transformation on the given data array, and stores the result in out. The out array must be a different buffer than the data array. The out array will contain the result of the transformation. The data array will not be modified.

Kind: instance method of P2FFT
Throws:

Error If `out` and `data` refer to the same buffer.

Param	Type	Description
out	`Float64Array`	The output buffer for the transformed data.
data	`Float64Array`	The input data to transform.