parakeet.js 0.0.2 → 0.0.3

package/docs/parakeet-transformers-js/src/models/florence2/processing_florence2.js

@@ -1,131 +0,0 @@
-import { Processor } from "../../base/processing_utils.js";
-import { AutoImageProcessor } from "../auto/image_processing_auto.js";
-import { AutoTokenizer } from "../../tokenizers.js";
-
-export class Florence2Processor extends Processor {
-    static tokenizer_class = AutoTokenizer
-    static image_processor_class = AutoImageProcessor
-
-    constructor(config, components, chat_template) {
-        super(config, components, chat_template);
-
-        const {
-            // @ts-expect-error TS2339
-            tasks_answer_post_processing_type,
-            // @ts-expect-error TS2339
-            task_prompts_without_inputs,
-            // @ts-expect-error TS2339
-            task_prompts_with_input,
-        } = this.image_processor.config;
-
-        /** @type {Map<string, string>} */
-        this.tasks_answer_post_processing_type = new Map(Object.entries(tasks_answer_post_processing_type ?? {}));
-
-        /** @type {Map<string, string>} */
-        this.task_prompts_without_inputs = new Map(Object.entries(task_prompts_without_inputs ?? {}));
-
-        /** @type {Map<string, string>} */
-        this.task_prompts_with_input = new Map(Object.entries(task_prompts_with_input ?? {}));
-
-        this.regexes = {
-            quad_boxes: /(.+?)<loc_(\d+)><loc_(\d+)><loc_(\d+)><loc_(\d+)><loc_(\d+)><loc_(\d+)><loc_(\d+)><loc_(\d+)>/gm,
-            bboxes: /([^<]+)?<loc_(\d+)><loc_(\d+)><loc_(\d+)><loc_(\d+)>/gm,
-        }
-        this.size_per_bin = 1000;
-    }
-
-    /**
-     * Helper function to construct prompts from input texts
-     * @param {string|string[]} text
-     * @returns {string[]}
-     */
-    construct_prompts(text) {
-        if (typeof text === 'string') {
-            text = [text];
-        }
-
-        const prompts = [];
-        for (const t of text) {
-            // 1. fixed task prompts without additional inputs
-            if (this.task_prompts_without_inputs.has(t)) {
-                prompts.push(this.task_prompts_without_inputs.get(t));
-            }
-            // 2. task prompts with additional inputs 
-            else {
-                for (const [task, prompt] of this.task_prompts_with_input) {
-                    if (t.includes(task)) {
-                        prompts.push(prompt.replaceAll('{input}', t).replaceAll(task, ''));
-                        break;
-                    }
-                }
-
-                // 3. default prompt
-                if (prompts.length !== text.length) {
-                    prompts.push(t);
-                }
-            }
-        }
-        return prompts;
-    }
-
-    /**
-     * Post-process the output of the model to each of the task outputs.
-     * @param {string} text The text to post-process.
-     * @param {string} task The task to post-process the text for.
-     * @param {[number, number]} image_size The size of the image. height x width.
-     */
-    post_process_generation(text, task, image_size) {
-        const task_answer_post_processing_type = this.tasks_answer_post_processing_type.get(task) ?? 'pure_text';
-
-        // remove the special tokens
-        text = text.replaceAll('<s>', '').replaceAll('</s>', '');
-
-        let final_answer;
-        switch (task_answer_post_processing_type) {
-            case 'pure_text':
-                final_answer = text;
-                break;
-
-            case 'description_with_bboxes':
-            case 'bboxes':
-            case 'phrase_grounding':
-            case 'ocr':
-                const key = task_answer_post_processing_type === 'ocr' ? 'quad_boxes' : 'bboxes';
-                const matches = text.matchAll(this.regexes[key]);
-                const labels = [];
-                const items = [];
-                for (const [_, label, ...locations] of matches) {
-                    // Push new label, or duplicate the last label
-                    labels.push(label ? label.trim() : labels.at(-1) ?? '');
-                    items.push(locations.map((x, i) =>
-                        // NOTE: Add 0.5 to use the center position of the bin as the coordinate.
-                        (Number(x) + 0.5) / this.size_per_bin * image_size[i % 2])
-                    );
-                }
-                final_answer = { labels, [key]: items };
-                break;
-
-            default:
-                throw new Error(`Task "${task}" (of type "${task_answer_post_processing_type}") not yet implemented.`);
-        }
-
-        return { [task]: final_answer }
-    }
-
-    // NOTE: images and text are switched from the python version
-    // `images` is required, `text` is optional
-    async _call(images, text=null, kwargs = {}) {
-
-        if (!images && !text){
-            throw new Error('Either text or images must be provided');
-        }
-
-        const image_inputs = await this.image_processor(images, kwargs);
-        const text_inputs = text ? this.tokenizer(this.construct_prompts(text), kwargs) : {};
-
-        return {
-            ...image_inputs,
-            ...text_inputs,
-        }
-    }
-}

package/docs/parakeet-transformers-js/src/models/gemma3n/feature_extraction_gemma3n.js

@@ -1,97 +0,0 @@
-import { FeatureExtractor, validate_audio_inputs } from '../../base/feature_extraction_utils.js';
-import { full, Tensor } from '../../utils/tensor.js';
-import { mel_filter_bank, spectrogram, window_function } from '../../utils/audio.js';
-
-export class Gemma3nAudioFeatureExtractor extends FeatureExtractor {
-
-    constructor(config) {
-        super(config);
-
-        const {
-            fft_length, feature_size, min_frequency, max_frequency, sampling_rate, frame_length
-        } = this.config;
-
-        const mel_filters = mel_filter_bank(
-            Math.floor(1 + fft_length / 2), // num_frequency_bins
-            feature_size, // num_mel_filters
-            min_frequency, // min_frequency
-            max_frequency, // max_frequency
-            sampling_rate, // sampling_rate
-            null, // norm
-            "htk", // mel_scale
-            false, // triangularize_in_mel_space
-        );
-        this.mel_filters = mel_filters;
-
-        this.window = window_function(frame_length, 'hann')
-    }
-
-    /**
-     * Computes the log-Mel spectrogram of the provided audio waveform.
-     * @param {Float32Array|Float64Array} waveform The audio waveform to process.
-     * @param {number} max_length The maximum number of frames to return.
-     * @returns {Promise<Tensor>} An object containing the log-Mel spectrogram data as a Float32Array and its dimensions as an array of numbers.
-     */
-    async _extract_fbank_features(waveform, max_length) {
-        // NOTE: We don't pad/truncate since that is passed in as `max_num_frames`
-        return spectrogram(
-            waveform,
-            this.window, // window
-            this.config.frame_length, // frame_length
-            this.config.hop_length, // hop_length
-            {
-                fft_length: this.config.fft_length,
-                center: false,
-                onesided: true,
-                preemphasis: this.config.preemphasis,
-                preemphasis_htk_flavor: this.config.preemphasis_htk_flavor,
-                mel_filters: this.mel_filters,
-                log_mel: 'log',
-                mel_floor: this.config.mel_floor,
-                remove_dc_offset: false,
-
-                // Custom
-                transpose: true,
-            }
-        )
-    }
-
-    /**
-     * Asynchronously extracts features from a given audio using the provided configuration.
-     * @param {Float32Array|Float64Array} audio The audio data as a Float32Array/Float64Array.
-     * @param {Object} options Optional parameters for feature extraction.
-     * @param {number} [options.max_length=480_000] If provided, defines the maximum length of the audio to allow.
-     * Audio longer than this will be truncated if `truncation=True`.
-     * @param {boolean} [options.truncation=true] Whether or not to truncate audio above `max_length`.
-     * @param {boolean} [options.padding=true] Whether to pad the sequence to a multiple of `pad_to_multiple_of`.
-     * @param {number} [options.pad_to_multiple_of=128] The number to pad the sequence to a multiple of.
-     * @returns {Promise<{ input_features: Tensor, input_features_mask: Tensor }>} A Promise resolving to an object containing the extracted input features and attention masks as Tensors.
-     */
-    async _call(audio, {
-        max_length = 480_000,
-        truncation=true,
-        padding = true,
-        pad_to_multiple_of = 128,
-    } = {}) {
-        validate_audio_inputs(audio, 'Gemma3nAudioFeatureExtractor');
-        if (truncation && audio.length > max_length) {
-            audio = audio.slice(0, max_length);
-        }
-        if (padding && audio.length % pad_to_multiple_of !== 0) {
-            const padding_length = pad_to_multiple_of - (audio.length % pad_to_multiple_of);
-            const padded_audio = new Float64Array(audio.length + padding_length);
-            padded_audio.set(audio);
-            if (this.config.padding_value !== 0) {
-                padded_audio.fill(this.config.padding_value, audio.length);
-            }
-            audio = padded_audio;
-        }
-
-        const features = await this._extract_fbank_features(audio, this.config.max_length);
-        const padded_attention_mask = full([1, features.dims[0]], true);
-        return {
-            input_features: features.unsqueeze_(0),
-            input_features_mask: padded_attention_mask,
-        }
-    }
-}

package/docs/parakeet-transformers-js/src/models/gemma3n/processing_gemma3n.js

@@ -1,74 +0,0 @@
-
-import { Processor } from "../../base/processing_utils.js";
-import { AutoImageProcessor } from "../auto/image_processing_auto.js";
-import { AutoFeatureExtractor } from "../auto/feature_extraction_auto.js";
-import { AutoTokenizer } from "../../tokenizers.js";
-import { RawImage } from "../../utils/image.js";
-import { RawAudio } from "../../utils/audio.js";
-
-export class Gemma3nProcessor extends Processor {
-    static image_processor_class = AutoImageProcessor;
-    static feature_extractor_class = AutoFeatureExtractor;
-    static tokenizer_class = AutoTokenizer;
-    static uses_processor_config = true;
-    static uses_chat_template_file = true;
-
-    constructor(config, components, chat_template) {
-        super(config, components, chat_template);
-        this.audio_seq_length = this.config.audio_seq_length;
-        this.image_seq_length = this.config.image_seq_length;
-
-        const {
-            // Audio tokens
-            audio_token_id, boa_token, audio_token, eoa_token,
-
-            // Image tokens
-            image_token_id, boi_token, image_token, eoi_token
-        } = this.tokenizer.config;
-
-        this.audio_token_id = audio_token_id
-        this.boa_token = boa_token
-        this.audio_token = audio_token
-        const audio_tokens_expanded = audio_token.repeat(this.audio_seq_length);
-        this.full_audio_sequence = `\n\n${boa_token}${audio_tokens_expanded}${eoa_token}\n\n`
-
-        this.image_token_id = image_token_id
-        this.boi_token = boi_token
-        this.image_token = image_token
-        const image_tokens_expanded = image_token.repeat(this.image_seq_length);
-        this.full_image_sequence = `\n\n${boi_token}${image_tokens_expanded}${eoi_token}\n\n`
-    }
-
-    /**
-     * 
-     * @param {string|string[]} text 
-     * @param {RawImage|RawImage[]|RawImage[][]} images
-     * @param {RawAudio|RawAudio[]|RawAudio[][]} audio
-     * @returns {Promise<any>}
-     */
-    async _call(text, images = null, audio = null, options = {}) {
-
-        if (typeof text === 'string') {
-            text = [text];
-        }
-
-        let audio_inputs;
-        if (audio) {
-            audio_inputs = await this.feature_extractor(audio, options);
-
-            text = text.map(prompt => prompt.replaceAll(this.audio_token, this.full_audio_sequence));
-        }
-        let image_inputs;
-        if (images) {
-            image_inputs = await this.image_processor(images, options);
-            text = text.map(prompt => prompt.replaceAll(this.image_token, this.full_image_sequence));
-        }
-
-        let text_inputs = this.tokenizer(text, options);
-        return {
-            ...text_inputs,
-            ...image_inputs,
-            ...audio_inputs,
-        }
-    }
-}

package/docs/parakeet-transformers-js/src/models/glpn/image_processing_glpn.js

@@ -1,5 +0,0 @@
-import { 
-    ImageProcessor,
-} from "../../base/image_processors_utils.js";
-
-export class GLPNFeatureExtractor extends ImageProcessor { }

package/docs/parakeet-transformers-js/src/models/grounding_dino/image_processing_grounding_dino.js

@@ -1,29 +0,0 @@
-
-import { 
-    ImageProcessor,
-} from "../../base/image_processors_utils.js";
-import { ones } from '../../utils/tensor.js';
-
-
-/**
- * @typedef {object} GroundingDinoFeatureExtractorResultProps
- * @property {import('../../utils/tensor.js').Tensor} pixel_mask
- * @typedef {import('../../base/image_processors_utils.js').ImageProcessorResult & GroundingDinoFeatureExtractorResultProps} GroundingDinoFeatureExtractorResult
- */
-
-export class GroundingDinoImageProcessor extends ImageProcessor {
-    /**
-     * Calls the feature extraction process on an array of images, preprocesses
-     * each image, and concatenates the resulting features into a single Tensor.
-     * @param {import('../../utils/image.js').RawImage[]} images The image(s) to extract features from.
-     * @returns {Promise<GroundingDinoFeatureExtractorResult>} An object containing the concatenated pixel values of the preprocessed images.
-     */
-    async _call(images) {
-        const result = await super._call(images);
-
-        const dims = result.pixel_values.dims;
-        const pixel_mask = ones([dims[0], dims[2], dims[3]]);
-
-        return { ...result, pixel_mask };
-    }
-}

package/docs/parakeet-transformers-js/src/models/grounding_dino/processing_grounding_dino.js

@@ -1,101 +0,0 @@
-import { Processor } from "../../base/processing_utils.js";
-import { AutoImageProcessor } from "../auto/image_processing_auto.js";
-import { AutoTokenizer } from "../../tokenizers.js";
-import { center_to_corners_format } from "../../base/image_processors_utils.js";
-
-/**
- * Get token ids of phrases from posmaps and input_ids.
- * @param {import('../../utils/tensor.js').Tensor} posmaps A boolean tensor of unbatched text-thresholded logits related to the detected bounding boxes of shape `(hidden_size, )`.
- * @param {import('../../utils/tensor.js').Tensor} input_ids A tensor of token ids of shape `(sequence_length, )`.
- */
-function get_phrases_from_posmap(posmaps, input_ids) {
-
-    const left_idx = 0;
-    const right_idx = posmaps.dims.at(-1) - 1;
-
-    const posmaps_list = posmaps.tolist();
-    posmaps_list.fill(false, 0, left_idx + 1);
-    posmaps_list.fill(false, right_idx);
-
-    const input_ids_list = input_ids.tolist();
-    return posmaps_list
-        .map((val, idx) => val ? idx : null)
-        .filter(idx => idx !== null)
-        .map(i => input_ids_list[i]);
-}
-
-export class GroundingDinoProcessor extends Processor {
-    static tokenizer_class = AutoTokenizer
-    static image_processor_class = AutoImageProcessor
-
-    /**
-     * @typedef {import('../../utils/image.js').RawImage} RawImage
-     */
-    /**
-     * 
-     * @param {RawImage|RawImage[]|RawImage[][]} images  
-     * @param {string|string[]} text 
-     * @returns {Promise<any>}
-     */
-    async _call(images, text, options = {}) {
-
-        const image_inputs = images ? await this.image_processor(images, options) : {};
-        const text_inputs = text ? this.tokenizer(text, options) : {};
-
-        return {
-            ...text_inputs,
-            ...image_inputs,
-        }
-    }
-    post_process_grounded_object_detection(outputs, input_ids, {
-        box_threshold = 0.25,
-        text_threshold = 0.25,
-        target_sizes = null
-    } = {}) {
-        const { logits, pred_boxes } = outputs;
-        const batch_size = logits.dims[0];
-
-        if (target_sizes !== null && target_sizes.length !== batch_size) {
-            throw Error("Make sure that you pass in as many target sizes as the batch dimension of the logits")
-        }
-        const num_queries = logits.dims.at(1);
-
-        const probs = logits.sigmoid(); // (batch_size, num_queries, 256)
-        const scores = probs.max(-1).tolist(); // (batch_size, num_queries)
-
-        // Convert to [x0, y0, x1, y1] format
-        const boxes = pred_boxes.tolist() // (batch_size, num_queries, 4)
-            .map(batch => batch.map(box => center_to_corners_format(box)));
-
-        const results = [];
-        for (let i = 0; i < batch_size; ++i) {
-            const target_size = target_sizes !== null ? target_sizes[i] : null;
-
-            // Convert from relative [0, 1] to absolute [0, height] coordinates
-            if (target_size !== null) {
-                boxes[i] = boxes[i].map(box => box.map((x, j) => x * target_size[(j + 1) % 2]));
-            }
-
-            const batch_scores = scores[i];
-            const final_scores = [];
-            const final_phrases = [];
-            const final_boxes = [];
-            for (let j = 0; j < num_queries; ++j) {
-                const score = batch_scores[j];
-                if (score <= box_threshold) {
-                    continue;
-                }
-                const box = boxes[i][j];
-                const prob = probs[i][j];
-
-                final_scores.push(score);
-                final_boxes.push(box);
-
-                const phrases = get_phrases_from_posmap(prob.gt(text_threshold), input_ids[i]);
-                final_phrases.push(phrases);
-            }
-            results.push({ scores: final_scores, boxes: final_boxes, labels: this.batch_decode(final_phrases) });
-        }
-        return results;
-    }
-}

package/docs/parakeet-transformers-js/src/models/idefics3/image_processing_idefics3.js

@@ -1,232 +0,0 @@
-
-
-import {
-    ImageProcessor,
-} from "../../base/image_processors_utils.js";
-import { cat, full, interpolate_4d, slice, stack } from "../../utils/tensor.js";
-
-export class Idefics3ImageProcessor extends ImageProcessor {
-    constructor(config) {
-        super(config);
-
-        this.do_image_splitting = config.do_image_splitting ?? true;
-        this.max_image_size = config.max_image_size;
-    }
-
-    /**
-     * @typedef {import('../../utils/image.js').RawImage} RawImage
-     * @typedef {import('../../utils/tensor.js').Tensor} Tensor
-     */
-
-    /**
-     * Calculate size to resize images to, to be multiples of `vision_encoder_max_size` while preserving the aspect ratio.
-     * @param {Tensor} pixel_values Tensor of the image to resize.
-     * @param {number} vision_encoder_max_size Maximum size of the output image. If the image is larger than this size,
-     * it will be split into patches of this size, and the original image will be concatenated with the patches, resized to max_size.
-     */
-    get_resize_for_vision_encoder(pixel_values, vision_encoder_max_size) {
-        let [height, width] = pixel_values.dims.slice(-2);
-
-        const aspect_ratio = width / height;
-        if (width >= height) {
-            width = Math.ceil(width / vision_encoder_max_size) * vision_encoder_max_size;
-            height = Math.floor(width / aspect_ratio);
-            height = Math.ceil(height / vision_encoder_max_size) * vision_encoder_max_size;
-        } else {
-            height = Math.ceil(height / vision_encoder_max_size) * vision_encoder_max_size;
-            width = Math.floor(height * aspect_ratio);
-            width = Math.ceil(width / vision_encoder_max_size) * vision_encoder_max_size;
-        }
-        return { height, width };
-    }
-
-    /** @param {RawImage|RawImage[]|RawImage[][]} images */
-    async _call(images, {
-        do_image_splitting = null,
-        return_row_col_info = false,
-    } = {}) {
-
-        /** @type {RawImage[][]} */
-        let batched_2d_images;
-        if (!Array.isArray(images)) {
-            batched_2d_images = [[images]];
-        } else {
-            if (images.length === 0 || !images[0]) {
-                throw new Error("No images provided.");
-            }
-            if (!Array.isArray(images[0])) {
-                batched_2d_images = [/** @type {RawImage[]} */(images)];
-            } else {
-                batched_2d_images = /** @type {RawImage[][]} */(images);
-            }
-        }
-
-        // List of tensors, each with shape [patches, channels, height, width]
-        let all_pixel_values = [];
-        let images_list_rows = [];
-        let images_list_cols = [];
-
-        const original_sizes = [];
-        const reshaped_input_sizes = [];
-        for (const image_batch of batched_2d_images) {
-
-            let images_list = await Promise.all(image_batch.map(x => this.preprocess(x)));
-
-            // Original sizes of images
-            original_sizes.push(...images_list.map(x => x.original_size));
-
-            // Reshaped sizes of images, before padding or cropping
-            reshaped_input_sizes.push(...images_list.map(x => x.reshaped_input_size));
-
-            // Convert images to 4D tensors for easier processing
-            images_list.forEach(x => x.pixel_values.unsqueeze_(0));
-
-            const { longest_edge } = this.max_image_size;
-
-            /** @type {Tensor[]} */
-            let images_tensor;
-            if (do_image_splitting ?? this.do_image_splitting) {
-                let image_rows = new Array(images_list.length);
-                let image_cols = new Array(images_list.length);
-
-                // We first resize both height and width of each image to the nearest max_image_size multiple, disregarding the aspect ratio
-                images_tensor = await Promise.all(images_list.map(async (x, i) => {
-                    const new_size = this.get_resize_for_vision_encoder(x.pixel_values, longest_edge);
-
-                    const resized = await interpolate_4d(x.pixel_values, {
-                        size: [new_size.height, new_size.width],
-                    });
-
-                    const { frames, num_splits_h, num_splits_w } = await this.split_image(resized, this.max_image_size);
-                    image_rows[i] = num_splits_h;
-                    image_cols[i] = num_splits_w;
-                    return cat(frames, 0);
-                }));
-
-                images_list_rows.push(image_rows);
-                images_list_cols.push(image_cols);
-
-            } else {
-                /** @type {[number, number]} */
-                const size = [longest_edge, longest_edge];
-                images_tensor = await Promise.all(
-                    images_list.map(x => interpolate_4d(x.pixel_values, { size }))
-                );
-
-                images_list_rows.push(new Array(images_list.length).fill(0));
-                images_list_cols.push(new Array(images_list.length).fill(0));
-            }
-
-            all_pixel_values.push(cat(images_tensor, 0));
-        }
-
-        const batch_size = all_pixel_values.length;
-        const [n, c, h, w] = all_pixel_values[0].dims;
-
-        // Stack pixel values
-        let pixel_values;
-        let pixel_attention_mask;
-        if (batch_size === 1) {
-            pixel_values = all_pixel_values[0].unsqueeze_(0);
-            pixel_attention_mask = full([batch_size, n, h, w], true);
-        } else {
-            // Add padding (if necessary) to images with less patches than the maximum number of patches
-            const max_num_patches = Math.max(...all_pixel_values.map(x => x.dims.at(0)));
-
-            pixel_attention_mask = full([batch_size, max_num_patches, h, w], true);
-            const pixel_attention_mask_data = pixel_attention_mask.data;
-            const pixel_attention_mask_stride = max_num_patches * h * w;
-            for (let i = 0; i < batch_size; ++i) {
-                const num_patches = all_pixel_values[i].dims[0];
-                if (num_patches < max_num_patches) {
-                    all_pixel_values[i] = cat([
-                        all_pixel_values[i],
-                        full([max_num_patches - num_patches, c, h, w], 0),
-                    ], 0);
-
-                    const start_offset = i * pixel_attention_mask_stride + num_patches * h * w;
-                    const end_offset = (i + 1) * pixel_attention_mask_stride;
-
-                    // @ts-ignore
-                    pixel_attention_mask_data.fill(false, start_offset, end_offset);
-                }
-            }
-            pixel_values = stack(all_pixel_values, 0);
-        }
-
-        return {
-            pixel_values,
-            pixel_attention_mask,
-
-            original_sizes,
-            reshaped_input_sizes,
-            ...(
-                return_row_col_info
-                    ? { rows: images_list_rows, cols: images_list_cols }
-                    : {}
-            ),
-        }
-    }
-
-    async split_image(pixel_values, { longest_edge }) {
-        const max_height = longest_edge;
-        const max_width = longest_edge;
-
-        const frames = [];
-
-        const [height, width] = pixel_values.dims.slice(-2);
-
-        let num_splits_h = 0, num_splits_w = 0;
-
-        if (height > max_height || width > max_width) {
-            // Calculate the number of splits
-            num_splits_h = Math.ceil(height / max_height);
-            num_splits_w = Math.ceil(width / max_width);
-
-            // Calculate the optimal width and height for the sub-images
-            const optimal_height = Math.ceil(height / num_splits_h);
-            const optimal_width = Math.ceil(width / num_splits_w);
-
-            // Iterate through each row and column
-            for (let r = 0; r < num_splits_h; ++r) {
-                for (let c = 0; c < num_splits_w; ++c) {
-                    let start_x, start_y, end_x, end_y;
-                    if (r === num_splits_h - 1) { // At bottom
-                        start_y = height - optimal_height;
-                        end_y = height;
-                    } else {
-                        start_y = r * optimal_height;
-                        end_y = (r + 1) * optimal_height;
-                    }
-                    if (c === num_splits_w - 1) { // At right
-                        start_x = width - optimal_width;
-                        end_x = width;
-                    } else {
-                        start_x = c * optimal_width;
-                        end_x = (c + 1) * optimal_width;
-                    }
-
-                    const starts = [start_y, start_x];
-                    const ends = [end_y, end_x];
-
-                    const patch = await slice(pixel_values, starts, ends, [2, 3]);
-                    frames.push(patch);
-                }
-            }
-
-            // Resize the global image to match max dimensions for memory efficiency
-            const global_image_height = max_height;
-            const global_image_width = max_width;
-
-            if (height !== global_image_height || width !== global_image_width) {
-                pixel_values = await interpolate_4d(pixel_values, {
-                    size: [global_image_height, global_image_width],
-                })
-            }
-        }
-
-        frames.push(pixel_values);
-
-        return { frames, num_splits_h, num_splits_w };
-    }
-}