@min-pack/tfjs-node 2.17.1 → 3.8.1-patch.0

package/tfjs-types/transformers.d.ts

@@ -0,0 +1,27 @@
+export { env } from "./env.js";
+export * from "./pipelines.js";
+export * from "./models.js";
+export * from "./tokenizers.js";
+export * from "./configs.js";
+export * from "./utils/audio.js";
+export * from "./utils/image.js";
+export * from "./utils/video.js";
+export * from "./utils/tensor.js";
+export * from "./utils/maths.js";
+export * from "./models/feature_extractors.js";
+export * from "./models/auto/feature_extraction_auto.js";
+export * from "./models/image_processors.js";
+export * from "./models/auto/image_processing_auto.js";
+export * from "./models/processors.js";
+export * from "./models/auto/processing_auto.js";
+export * from "./generation/streamers.js";
+export * from "./generation/stopping_criteria.js";
+export * from "./generation/logits_process.js";
+export { FeatureExtractor } from "./base/feature_extraction_utils.js";
+export { ImageProcessor } from "./base/image_processors_utils.js";
+export { Processor } from "./base/processing_utils.js";
+export type PretrainedModelOptions = import("./utils/hub.js").PretrainedModelOptions;
+export type PretrainedProcessorOptions = import("./base/processing_utils.js").PretrainedProcessorOptions;
+export type DataType = import("./utils/dtypes.js").DataType;
+export type DeviceType = import("./utils/devices.js").DeviceType;
+//# sourceMappingURL=transformers.d.ts.map

package/tfjs-types/utils/audio.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Helper function to read audio from a path/URL.
+ * @param {string|URL} url The path/URL to load the audio from.
+ * @param {number} sampling_rate The sampling rate to use when decoding the audio.
+ * @returns {Promise<Float32Array>} The decoded audio as a `Float32Array`.
+ */
+export function read_audio(url: string | URL, sampling_rate: number): Promise<Float32Array>;
+/**
+ * Generates a Hanning window of length M.
+ * See https://numpy.org/doc/stable/reference/generated/numpy.hanning.html for more information.
+ *
+ * @param {number} M The length of the Hanning window to generate.
+ * @returns {Float64Array} The generated Hanning window.
+ */
+export function hanning(M: number): Float64Array;
+/**
+ * Generates a Hamming window of length M.
+ * See https://numpy.org/doc/stable/reference/generated/numpy.hamming.html for more information.
+ *
+ * @param {number} M The length of the Hamming window to generate.
+ * @returns {Float64Array} The generated Hamming window.
+ */
+export function hamming(M: number): Float64Array;
+/**
+ * Creates a frequency bin conversion matrix used to obtain a mel spectrogram. This is called a *mel filter bank*, and
+ * various implementation exist, which differ in the number of filters, the shape of the filters, the way the filters
+ * are spaced, the bandwidth of the filters, and the manner in which the spectrum is warped. The goal of these
+ * features is to approximate the non-linear human perception of the variation in pitch with respect to the frequency.
+ * @param {number} num_frequency_bins Number of frequency bins (should be the same as `n_fft // 2 + 1`
+ * where `n_fft` is the size of the Fourier Transform used to compute the spectrogram).
+ * @param {number} num_mel_filters Number of mel filters to generate.
+ * @param {number} min_frequency Lowest frequency of interest in Hz.
+ * @param {number} max_frequency Highest frequency of interest in Hz. This should not exceed `sampling_rate / 2`.
+ * @param {number} sampling_rate Sample rate of the audio waveform.
+ * @param {string} [norm] If `"slaney"`, divide the triangular mel weights by the width of the mel band (area normalization).
+ * @param {string} [mel_scale] The mel frequency scale to use, `"htk"` or `"slaney"`.
+ * @param {boolean} [triangularize_in_mel_space] If this option is enabled, the triangular filter is applied in mel space rather than frequency space.
+ * This should be set to `true` in order to get the same results as `torchaudio` when computing mel filters.
+ * @returns {number[][]} Triangular filter bank matrix, which is a 2D array of shape (`num_frequency_bins`, `num_mel_filters`).
+ * This is a projection matrix to go from a spectrogram to a mel spectrogram.
+ */
+export function mel_filter_bank(num_frequency_bins: number, num_mel_filters: number, min_frequency: number, max_frequency: number, sampling_rate: number, norm?: string, mel_scale?: string, triangularize_in_mel_space?: boolean): number[][];
+/**
+ * Calculates a spectrogram over one waveform using the Short-Time Fourier Transform.
+ *
+ * This function can create the following kinds of spectrograms:
+ *   - amplitude spectrogram (`power = 1.0`)
+ *   - power spectrogram (`power = 2.0`)
+ *   - complex-valued spectrogram (`power = None`)
+ *   - log spectrogram (use `log_mel` argument)
+ *   - mel spectrogram (provide `mel_filters`)
+ *   - log-mel spectrogram (provide `mel_filters` and `log_mel`)
+ *
+ * In this implementation, the window is assumed to be zero-padded to have the same size as the analysis frame.
+ * A padded window can be obtained from `window_function()`. The FFT input buffer may be larger than the analysis frame,
+ * typically the next power of two.
+ *
+ * @param {Float32Array|Float64Array} waveform The input waveform of shape `(length,)`. This must be a single real-valued, mono waveform.
+ * @param {Float32Array|Float64Array} window The windowing function to apply of shape `(frame_length,)`, including zero-padding if necessary. The actual window length may be
+ * shorter than `frame_length`, but we're assuming the array has already been zero-padded.
+ * @param {number} frame_length The length of the analysis frames in samples (a.k.a., `fft_length`).
+ * @param {number} hop_length The stride between successive analysis frames in samples.
+ * @param {Object} options
+ * @param {number} [options.fft_length=null] The size of the FFT buffer in samples. This determines how many frequency bins the spectrogram will have.
+ * For optimal speed, this should be a power of two. If `null`, uses `frame_length`.
+ * @param {number} [options.power=1.0] If 1.0, returns the amplitude spectrogram. If 2.0, returns the power spectrogram. If `null`, returns complex numbers.
+ * @param {boolean} [options.center=true] Whether to pad the waveform so that frame `t` is centered around time `t * hop_length`. If `false`, frame
+ * `t` will start at time `t * hop_length`.
+ * @param {string} [options.pad_mode="reflect"] Padding mode used when `center` is `true`. Possible values are: `"constant"` (pad with zeros),
+ * `"edge"` (pad with edge values), `"reflect"` (pads with mirrored values).
+ * @param {boolean} [options.onesided=true] If `true`, only computes the positive frequencies and returns a spectrogram containing `fft_length // 2 + 1`
+ * frequency bins. If `false`, also computes the negative frequencies and returns `fft_length` frequency bins.
+ * @param {number} [options.preemphasis=null] Coefficient for a low-pass filter that applies pre-emphasis before the DFT.
+ * @param {boolean} [options.preemphasis_htk_flavor=true] Whether to apply the pre-emphasis filter in the HTK flavor.
+ * @param {number[][]} [options.mel_filters=null] The mel filter bank of shape `(num_freq_bins, num_mel_filters)`.
+ * If supplied, applies this filter bank to create a mel spectrogram.
+ * @param {number} [options.mel_floor=1e-10] Minimum value of mel frequency banks.
+ * @param {string} [options.log_mel=null] How to convert the spectrogram to log scale. Possible options are:
+ * `null` (don't convert), `"log"` (take the natural logarithm) `"log10"` (take the base-10 logarithm), `"dB"` (convert to decibels).
+ * Can only be used when `power` is not `null`.
+ * @param {number} [options.reference=1.0] Sets the input spectrogram value that corresponds to 0 dB. For example, use `max(spectrogram)[0]` to set
+ * the loudest part to 0 dB. Must be greater than zero.
+ * @param {number} [options.min_value=1e-10] The spectrogram will be clipped to this minimum value before conversion to decibels, to avoid taking `log(0)`.
+ * For a power spectrogram, the default of `1e-10` corresponds to a minimum of -100 dB. For an amplitude spectrogram, the value `1e-5` corresponds to -100 dB.
+ * Must be greater than zero.
+ * @param {number} [options.db_range=null] Sets the maximum dynamic range in decibels. For example, if `db_range = 80`, the difference between the
+ * peak value and the smallest value will never be more than 80 dB. Must be greater than zero.
+ * @param {boolean} [options.remove_dc_offset=null] Subtract mean from waveform on each frame, applied before pre-emphasis. This should be set to `true` in
+ * order to get the same results as `torchaudio.compliance.kaldi.fbank` when computing mel filters.
+ * @param {number} [options.max_num_frames=null] If provided, limits the number of frames to compute to this value.
+ * @param {number} [options.min_num_frames=null] If provided, ensures the number of frames to compute is at least this value.
+ * @param {boolean} [options.do_pad=true] If `true`, pads the output spectrogram to have `max_num_frames` frames.
+ * @param {boolean} [options.transpose=false] If `true`, the returned spectrogram will have shape `(num_frames, num_frequency_bins/num_mel_filters)`. If `false`, the returned spectrogram will have shape `(num_frequency_bins/num_mel_filters, num_frames)`.
+ * @param {number} [options.mel_offset=0] Offset to add to the mel spectrogram to avoid taking the log of zero.
+ * @returns {Promise<Tensor>} Spectrogram of shape `(num_frequency_bins, length)` (regular spectrogram) or shape `(num_mel_filters, length)` (mel spectrogram).
+ */
+export function spectrogram(waveform: Float32Array | Float64Array, window: Float32Array | Float64Array, frame_length: number, hop_length: number, { fft_length, power, center, pad_mode, onesided, preemphasis, preemphasis_htk_flavor, mel_filters, mel_floor, log_mel, reference, min_value, db_range, remove_dc_offset, min_num_frames, max_num_frames, do_pad, transpose, mel_offset, }?: {
+    fft_length?: number;
+    power?: number;
+    center?: boolean;
+    pad_mode?: string;
+    onesided?: boolean;
+    preemphasis?: number;
+    preemphasis_htk_flavor?: boolean;
+    mel_filters?: number[][];
+    mel_floor?: number;
+    log_mel?: string;
+    reference?: number;
+    min_value?: number;
+    db_range?: number;
+    remove_dc_offset?: boolean;
+    max_num_frames?: number;
+    min_num_frames?: number;
+    do_pad?: boolean;
+    transpose?: boolean;
+    mel_offset?: number;
+}): Promise<Tensor>;
+/**
+ * Returns an array containing the specified window.
+ * @param {number} window_length The length of the window in samples.
+ * @param {string} name The name of the window function.
+ * @param {Object} options Additional options.
+ * @param {boolean} [options.periodic=true] Whether the window is periodic or symmetric.
+ * @param {number} [options.frame_length=null] The length of the analysis frames in samples.
+ * Provide a value for `frame_length` if the window is smaller than the frame length, so that it will be zero-padded.
+ * @param {boolean} [options.center=true] Whether to center the window inside the FFT buffer. Only used when `frame_length` is provided.
+ * @returns {Float64Array} The window of shape `(window_length,)` or `(frame_length,)`.
+ */
+export function window_function(window_length: number, name: string, { periodic, frame_length, center, }?: {
+    periodic?: boolean;
+    frame_length?: number;
+    center?: boolean;
+}): Float64Array;
+export class RawAudio {
+    /**
+     * Create a new `RawAudio` object.
+     * @param {Float32Array} audio Audio data
+     * @param {number} sampling_rate Sampling rate of the audio data
+     */
+    constructor(audio: Float32Array, sampling_rate: number);
+    audio: Float32Array<ArrayBufferLike>;
+    sampling_rate: number;
+    /**
+     * Convert the audio to a wav file buffer.
+     * @returns {ArrayBuffer} The WAV file.
+     */
+    toWav(): ArrayBuffer;
+    /**
+     * Convert the audio to a blob.
+     * @returns {Blob}
+     */
+    toBlob(): Blob;
+    /**
+     * Save the audio to a wav file.
+     * @param {string} path
+     */
+    save(path: string): Promise<void>;
+}
+import { Tensor } from './tensor.js';
+//# sourceMappingURL=audio.d.ts.map

package/tfjs-types/utils/constants.d.ts

@@ -0,0 +1,8 @@
+export const GITHUB_ISSUE_URL: "https://github.com/huggingface/transformers.js/issues/new/choose";
+export const CONFIG_NAME: "config.json";
+export const FEATURE_EXTRACTOR_NAME: "preprocessor_config.json";
+export const IMAGE_PROCESSOR_NAME: "preprocessor_config.json";
+export const PROCESSOR_NAME: "processor_config.json";
+export const CHAT_TEMPLATE_NAME: "chat_template.jinja";
+export const GENERATION_CONFIG_NAME: "generation_config.json";
+//# sourceMappingURL=constants.d.ts.map

package/tfjs-types/utils/core.d.ts

@@ -0,0 +1,231 @@
+/**
+ * @file Core utility functions/classes for Transformers.js.
+ *
+ * These are only used internally, meaning an end-user shouldn't
+ * need to access anything here.
+ *
+ * @module utils/core
+ */
+/**
+ * @typedef {Object} InitiateProgressInfo
+ * @property {'initiate'} status
+ * @property {string} name The model id or directory path.
+ * @property {string} file The name of the file.
+ */
+/**
+ * @typedef {Object} DownloadProgressInfo
+ * @property {'download'} status
+ * @property {string} name The model id or directory path.
+ * @property {string} file The name of the file.
+ */
+/**
+ * @typedef {Object} ProgressStatusInfo
+ * @property {'progress'} status
+ * @property {string} name The model id or directory path.
+ * @property {string} file The name of the file.
+ * @property {number} progress A number between 0 and 100.
+ * @property {number} loaded The number of bytes loaded.
+ * @property {number} total The total number of bytes to be loaded.
+ */
+/**
+ * @typedef {Object} DoneProgressInfo
+ * @property {'done'} status
+ * @property {string} name The model id or directory path.
+ * @property {string} file The name of the file.
+ */
+/**
+ * @typedef {Object} ReadyProgressInfo
+ * @property {'ready'} status
+ * @property {string} task The loaded task.
+ * @property {string} model The loaded model.
+ */
+/**
+ * @typedef {InitiateProgressInfo | DownloadProgressInfo | ProgressStatusInfo | DoneProgressInfo | ReadyProgressInfo} ProgressInfo
+ */
+/**
+ * A callback function that is called with progress information.
+ * @callback ProgressCallback
+ * @param {ProgressInfo} progressInfo
+ * @returns {void}
+ */
+/**
+ * Helper function to dispatch progress callbacks.
+ *
+ * @param {ProgressCallback | null | undefined} progress_callback The progress callback function to dispatch.
+ * @param {ProgressInfo} data The data to pass to the progress callback function.
+ * @returns {void}
+ * @private
+ */
+export function dispatchCallback(progress_callback: ProgressCallback | null | undefined, data: ProgressInfo): void;
+/**
+ * Reverses the keys and values of an object.
+ *
+ * @param {Object} data The object to reverse.
+ * @returns {Object} The reversed object.
+ * @see https://ultimatecourses.com/blog/reverse-object-keys-and-values-in-javascript
+ */
+export function reverseDictionary(data: any): any;
+/**
+ * Escapes regular expression special characters from a string by replacing them with their escaped counterparts.
+ *
+ * @param {string} string The string to escape.
+ * @returns {string} The escaped string.
+ */
+export function escapeRegExp(string: string): string;
+/**
+ * Check if a value is a typed array.
+ * @param {*} val The value to check.
+ * @returns {boolean} True if the value is a `TypedArray`, false otherwise.
+ *
+ * Adapted from https://stackoverflow.com/a/71091338/13989043
+ */
+export function isTypedArray(val: any): boolean;
+/**
+ * Check if a value is an integer.
+ * @param {*} x The value to check.
+ * @returns {boolean} True if the value is a string, false otherwise.
+ */
+export function isIntegralNumber(x: any): boolean;
+/**
+ * Determine if a provided width or height is nullish.
+ * @param {*} x The value to check.
+ * @returns {boolean} True if the value is `null`, `undefined` or `-1`, false otherwise.
+ */
+export function isNullishDimension(x: any): boolean;
+/**
+ * Calculates the dimensions of a nested array.
+ *
+ * @param {any[]} arr The nested array to calculate dimensions for.
+ * @returns {number[]} An array containing the dimensions of the input array.
+ */
+export function calculateDimensions(arr: any[]): number[];
+/**
+ * Replicate python's .pop() method for objects.
+ * @param {Object} obj The object to pop from.
+ * @param {string} key The key to pop.
+ * @param {*} defaultValue The default value to return if the key does not exist.
+ * @returns {*} The value of the popped key.
+ * @throws {Error} If the key does not exist and no default value is provided.
+ */
+export function pop(obj: any, key: string, defaultValue?: any): any;
+/**
+ * Efficiently merge arrays, creating a new copy.
+ * Adapted from https://stackoverflow.com/a/6768642/13989043
+ * @param  {Array[]} arrs Arrays to merge.
+ * @returns {Array} The merged array.
+ */
+export function mergeArrays(...arrs: any[][]): any[];
+/**
+ * Compute the Cartesian product of given arrays
+ * @param {...Array} a Arrays to compute the product
+ * @returns {Array} Returns the computed Cartesian product as an array
+ * @private
+ */
+export function product(...a: any[][]): any[];
+/**
+ * Calculates the index offset for a given index and window size.
+ * @param {number} i The index.
+ * @param {number} w The window size.
+ * @returns {number} The index offset.
+ */
+export function calculateReflectOffset(i: number, w: number): number;
+/**
+ * Save blob file on the web.
+ * @param {string} path The path to save the blob to
+ * @param {Blob} blob The blob to save
+ */
+export function saveBlob(path: string, blob: Blob): void;
+/**
+ *
+ * @param {Object} o
+ * @param {string[]} props
+ * @returns {Object}
+ */
+export function pick(o: any, props: string[]): any;
+/**
+ * Calculate the length of a string, taking multi-byte characters into account.
+ * This mimics the behavior of Python's `len` function.
+ * @param {string} s The string to calculate the length of.
+ * @returns {number} The length of the string.
+ */
+export function len(s: string): number;
+/**
+ * Count the occurrences of a value in an array or string.
+ * This mimics the behavior of Python's `count` method.
+ * @param {any[]|string} arr The array or string to search.
+ * @param {any} value The value to count.
+ */
+export function count(arr: any[] | string, value: any): number;
+export type InitiateProgressInfo = {
+    status: "initiate";
+    /**
+     * The model id or directory path.
+     */
+    name: string;
+    /**
+     * The name of the file.
+     */
+    file: string;
+};
+export type DownloadProgressInfo = {
+    status: "download";
+    /**
+     * The model id or directory path.
+     */
+    name: string;
+    /**
+     * The name of the file.
+     */
+    file: string;
+};
+export type ProgressStatusInfo = {
+    status: "progress";
+    /**
+     * The model id or directory path.
+     */
+    name: string;
+    /**
+     * The name of the file.
+     */
+    file: string;
+    /**
+     * A number between 0 and 100.
+     */
+    progress: number;
+    /**
+     * The number of bytes loaded.
+     */
+    loaded: number;
+    /**
+     * The total number of bytes to be loaded.
+     */
+    total: number;
+};
+export type DoneProgressInfo = {
+    status: "done";
+    /**
+     * The model id or directory path.
+     */
+    name: string;
+    /**
+     * The name of the file.
+     */
+    file: string;
+};
+export type ReadyProgressInfo = {
+    status: "ready";
+    /**
+     * The loaded task.
+     */
+    task: string;
+    /**
+     * The loaded model.
+     */
+    model: string;
+};
+export type ProgressInfo = InitiateProgressInfo | DownloadProgressInfo | ProgressStatusInfo | DoneProgressInfo | ReadyProgressInfo;
+/**
+ * A callback function that is called with progress information.
+ */
+export type ProgressCallback = (progressInfo: ProgressInfo) => void;
+//# sourceMappingURL=core.d.ts.map