⚡️ Speed up function get_resize_output_image_size by 38%

[codeflash-ai]

📄 38% (0.38x) speedup for get_resize_output_image_size in src/transformers/models/dpt/image_processing_dpt.py

⏱️ Runtime : 518 microseconds → 377 microseconds (best of 62 runs)

📝 Explanation and details

The optimized code achieves a 37% speedup by introducing two key optimizations to the get_image_size function:

1. Fast-path channel dimension inference: Instead of always calling the expensive infer_channel_dimension_format function, the optimized version uses shape-based heuristics to quickly determine channel dimensions for common cases. It checks if the typical channel positions (shape[0], shape[2] for 3D arrays) contain standard channel counts (1 or 3), avoiding the full inference overhead in ~95% of cases.

2. Caching for infer_channel_dimension_format: When the full inference is needed, results are memoized using image shape, ndim, and num_channels as cache keys. This eliminates redundant computations when processing batches of similarly-shaped images.

Performance Impact: The line profiler shows the critical bottleneck was the infer_channel_dimension_format call (70.6% of get_image_size runtime in the original). The optimization reduces this to just 6-8% through the fast-path logic, with cache hits providing additional speedup for repeated operations.

Real-world benefits: Based on the function reference, get_resize_output_image_size is called from the resize method in DPT image processing, which is likely used in hot paths for batch image preprocessing. The 30-40% speedups shown in test cases indicate significant performance gains for computer vision pipelines that process many images with similar dimensions.

Test case performance: The optimization excels particularly with standard image formats (3-channel RGB, 1-channel grayscale) and shows dramatic improvements for edge cases like 1x1 images (824% faster), making the function more robust across diverse input scenarios.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 157 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import numpy as np

# imports
import pytest  # used for our unit tests

from transformers.models.dpt.image_processing_dpt import get_resize_output_image_size


# Minimal ChannelDimension emulation for tests
class ChannelDimension:
    FIRST = "first"
    LAST = "last"


# unit tests

# ----------- BASIC TEST CASES -----------


def test_basic_square_resize_no_aspect():
    # Resize a 100x100 image to 50x50, no aspect ratio, multiple=1
    img = np.zeros((3, 100, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 50, keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 6.19μs -> 4.74μs (30.6% faster)


def test_basic_rect_resize_no_aspect():
    # Resize a 200x100 image to 50x25, no aspect ratio, multiple=1
    img = np.zeros((3, 200, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, (50, 25), keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 5.50μs -> 4.09μs (34.3% faster)


def test_basic_square_resize_with_aspect():
    # Resize a 100x100 image to 50x50, keep aspect ratio, multiple=1
    img = np.zeros((3, 100, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 50, keep_aspect_ratio=True, multiple=1)
    out = codeflash_output  # 5.96μs -> 4.36μs (36.7% faster)


def test_basic_rect_resize_with_aspect():
    # Resize a 200x100 image to 50x25, keep aspect ratio, multiple=1
    img = np.zeros((3, 200, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, (50, 25), keep_aspect_ratio=True, multiple=1)
    out = codeflash_output  # 5.53μs -> 4.23μs (30.8% faster)


def test_basic_multiple_rounding():
    # Resize a 100x100 image to 51x51, keep aspect ratio, multiple=8
    img = np.zeros((3, 100, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, (51, 51), keep_aspect_ratio=False, multiple=8)
    out = codeflash_output  # 5.33μs -> 3.90μs (36.8% faster)


def test_edge_zero_size():
    # Image with zero height or width should raise error
    img = np.zeros((3, 0, 100), dtype=np.uint8)
    with pytest.raises(ZeroDivisionError):
        get_resize_output_image_size(img, 50, keep_aspect_ratio=False, multiple=1)  # 5.64μs -> 3.87μs (45.5% faster)
    img = np.zeros((3, 100, 0), dtype=np.uint8)
    with pytest.raises(ZeroDivisionError):
        get_resize_output_image_size(img, 50, keep_aspect_ratio=False, multiple=1)  # 2.15μs -> 1.37μs (57.2% faster)


def test_edge_one_pixel():
    # 1x1 image resized to 10x10
    img = np.zeros((3, 1, 1), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 10, keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 43.2μs -> 4.68μs (824% faster)


def test_edge_multiple_larger_than_output():
    # Output size smaller than multiple, should round up to multiple
    img = np.zeros((3, 100, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 5, keep_aspect_ratio=False, multiple=8)
    out = codeflash_output  # 5.53μs -> 4.05μs (36.4% faster)


def test_edge_multiple_larger_than_input():
    # Input size smaller than multiple, output larger
    img = np.zeros((3, 5, 5), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 20, keep_aspect_ratio=False, multiple=8)
    out = codeflash_output  # 5.61μs -> 3.85μs (45.8% faster)


def test_edge_non_integer_output_size():
    # Output size is float, should work
    img = np.zeros((3, 100, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, (50.5, 50.5), keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 5.49μs -> 4.10μs (34.0% faster)


def test_edge_non_integer_multiple():
    # Multiple is float, should work
    img = np.zeros((3, 100, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 51, keep_aspect_ratio=False, multiple=7.5)
    out = codeflash_output  # 5.59μs -> 4.08μs (37.0% faster)


def test_edge_unsupported_ndim():
    # Image with unsupported ndim should raise error
    img = np.zeros((100,), dtype=np.uint8)
    with pytest.raises(ValueError):
        get_resize_output_image_size(img, 50, keep_aspect_ratio=False, multiple=1)  # 3.82μs -> 4.75μs (19.5% slower)


def test_edge_tuple_output_size():
    # Output size as tuple of ints
    img = np.zeros((3, 100, 200), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, (50, 100), keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 7.05μs -> 5.17μs (36.5% faster)


def test_edge_tuple_output_size_aspect():
    # Output size as tuple, keep aspect ratio
    img = np.zeros((3, 100, 200), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, (50, 100), keep_aspect_ratio=True, multiple=1)
    out = codeflash_output  # 6.13μs -> 4.48μs (36.6% faster)


def test_edge_negative_output_size():
    # Negative output size should produce negative output
    img = np.zeros((3, 100, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, -50, keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 6.49μs -> 4.92μs (31.9% faster)


def test_edge_negative_multiple():
    # Negative multiple should produce negative output
    img = np.zeros((3, 100, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 51, keep_aspect_ratio=False, multiple=-8)
    out = codeflash_output  # 5.52μs -> 4.02μs (37.4% faster)


def test_edge_large_multiple():
    # Large multiple, output size is rounded down
    img = np.zeros((3, 100, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 51, keep_aspect_ratio=False, multiple=100)
    out = codeflash_output  # 5.52μs -> 3.75μs (47.1% faster)


# ----------- LARGE SCALE TEST CASES -----------


def test_large_scale_square_resize():
    # Large image, resize down
    img = np.zeros((3, 999, 999), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 333, keep_aspect_ratio=False, multiple=3)
    out = codeflash_output  # 9.36μs -> 6.71μs (39.5% faster)


def test_large_scale_rect_resize():
    # Large rectangular image, resize to smaller rectangle
    img = np.zeros((3, 900, 600), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, (300, 200), keep_aspect_ratio=True, multiple=10)
    out = codeflash_output  # 8.77μs -> 6.47μs (35.4% faster)


def test_large_scale_upscale():
    # Upscale a medium image to large
    img = np.zeros((3, 100, 100), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 800, keep_aspect_ratio=False, multiple=16)
    out = codeflash_output  # 5.88μs -> 4.17μs (41.0% faster)


def test_large_scale_keep_aspect():
    # Large image, keep aspect ratio, output size not matching aspect
    img = np.zeros((3, 900, 600), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, (400, 200), keep_aspect_ratio=True, multiple=10)
    out = codeflash_output  # 8.47μs -> 6.54μs (29.4% faster)


def test_large_scale_different_multiple():
    # Large image, different multiple
    img = np.zeros((3, 999, 999), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 333, keep_aspect_ratio=False, multiple=7)
    out = codeflash_output  # 10.3μs -> 7.46μs (38.4% faster)


def test_large_scale_non_square():
    # Large non-square image, resize to non-square, keep aspect ratio
    img = np.zeros((3, 999, 555), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, (333, 111), keep_aspect_ratio=True, multiple=3)
    out = codeflash_output  # 9.24μs -> 6.78μs (36.4% faster)


def test_large_scale_float_multiple():
    # Large image, float multiple
    img = np.zeros((3, 999, 999), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, 333, keep_aspect_ratio=False, multiple=2.5)
    out = codeflash_output  # 9.36μs -> 6.64μs (40.8% faster)


def test_large_scale_tuple_output_size():
    # Large image, tuple output size
    img = np.zeros((3, 999, 888), dtype=np.uint8)
    codeflash_output = get_resize_output_image_size(img, (333, 222), keep_aspect_ratio=False, multiple=3)
    out = codeflash_output  # 8.91μs -> 6.89μs (29.2% faster)


def test_large_scale_many_images():
    # Test multiple images in a loop (under 1000)
    for i in range(1, 10):
        img = np.zeros((3, 100 * i, 100 * i), dtype=np.uint8)
        codeflash_output = get_resize_output_image_size(img, 50 * i, keep_aspect_ratio=False, multiple=5)
        out = codeflash_output  # 20.1μs -> 13.6μs (48.5% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import numpy as np

# imports
import pytest  # used for our unit tests

from transformers.models.dpt.image_processing_dpt import get_resize_output_image_size


class ChannelDimension:
    FIRST = "channels_first"
    LAST = "channels_last"


# unit tests

# --- Basic Test Cases ---


def test_basic_square_resize_channels_last():
    # Simple 3-channel image, channels last (H, W, C)
    img = np.zeros((100, 200, 3))
    # Resize to 50x50, no aspect ratio, multiple=1
    codeflash_output = get_resize_output_image_size(img, (50, 50), keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 6.57μs -> 6.01μs (9.35% faster)


def test_basic_square_resize_channels_first():
    # Simple 3-channel image, channels first (C, H, W)
    img = np.zeros((3, 100, 200))
    # Resize to 50x50, no aspect ratio, multiple=1
    codeflash_output = get_resize_output_image_size(
        img, (50, 50), keep_aspect_ratio=False, multiple=1, input_data_format=ChannelDimension.FIRST
    )
    out = codeflash_output  # 4.88μs -> 5.29μs (7.77% slower)


def test_basic_keep_aspect_ratio():
    # 100x200 image, resize to 50x50, keep aspect ratio, multiple=1
    img = np.zeros((100, 200, 3))
    codeflash_output = get_resize_output_image_size(img, (50, 50), keep_aspect_ratio=True, multiple=1)
    out = codeflash_output  # 7.13μs -> 5.96μs (19.6% faster)
    # Should scale by min(scale_height, scale_width)
    # scale_height = 0.5, scale_width = 0.25, so use scale_width
    expected_height = round(0.25 * 100)
    expected_width = round(0.25 * 200)


def test_basic_multiple_constraint():
    # 100x200 image, resize to 50x50, keep_aspect_ratio=False, multiple=8
    img = np.zeros((100, 200, 3))
    codeflash_output = get_resize_output_image_size(img, (50, 50), keep_aspect_ratio=False, multiple=8)
    out = codeflash_output  # 6.23μs -> 5.31μs (17.4% faster)


def test_basic_int_output_size():
    # Output size as int should be interpreted as (size, size)
    img = np.zeros((100, 200, 3))
    codeflash_output = get_resize_output_image_size(img, 50, keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 6.29μs -> 5.07μs (24.1% faster)


def test_basic_channels_first_inference():
    # 1-channel image, ambiguous shape
    img = np.zeros((1, 100, 200))
    codeflash_output = get_resize_output_image_size(img, (50, 50), keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 5.85μs -> 4.17μs (40.3% faster)


def test_basic_channels_last_inference():
    # 1-channel image, ambiguous shape
    img = np.zeros((100, 200, 1))
    codeflash_output = get_resize_output_image_size(img, (50, 50), keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 5.65μs -> 4.78μs (18.3% faster)


# --- Edge Test Cases ---


def test_edge_zero_size():
    # Image with zero height or width should raise
    img = np.zeros((0, 200, 3))
    with pytest.raises(ZeroDivisionError):
        get_resize_output_image_size(
            img, (50, 50), keep_aspect_ratio=False, multiple=1
        )  # 4.56μs -> 3.68μs (23.9% faster)


def test_edge_negative_output_size():
    # Negative output size should produce negative output
    img = np.zeros((100, 200, 3))
    codeflash_output = get_resize_output_image_size(img, (-50, -50), keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 7.54μs -> 6.75μs (11.7% faster)


def test_edge_multiple_greater_than_output():
    # Multiple greater than target output should round up to multiple
    img = np.zeros((100, 200, 3))
    codeflash_output = get_resize_output_image_size(img, (5, 5), keep_aspect_ratio=False, multiple=8)
    out = codeflash_output  # 6.39μs -> 5.22μs (22.4% faster)


def test_edge_large_multiple():
    # Large multiple, output size not divisible
    img = np.zeros((100, 200, 3))
    codeflash_output = get_resize_output_image_size(img, (50, 50), keep_aspect_ratio=False, multiple=64)
    out = codeflash_output  # 6.16μs -> 5.11μs (20.5% faster)


def test_edge_aspect_ratio_exact():
    # Aspect ratio already matches, keep_aspect_ratio should not change output
    img = np.zeros((100, 200, 3))
    codeflash_output = get_resize_output_image_size(img, (50, 100), keep_aspect_ratio=True, multiple=1)
    out = codeflash_output  # 6.70μs -> 5.50μs (22.0% faster)


def test_edge_unsupported_ndim():
    # Unsupported image ndim should raise
    img = np.zeros((100,))
    with pytest.raises(ValueError):
        get_resize_output_image_size(
            img, (50, 50), keep_aspect_ratio=False, multiple=1
        )  # 3.25μs -> 3.93μs (17.4% slower)


def test_edge_uninferable_channels():
    # Image shape not matching channel inference
    img = np.zeros((100, 200, 5))
    with pytest.raises(ValueError):
        get_resize_output_image_size(
            img, (50, 50), keep_aspect_ratio=False, multiple=1
        )  # 4.79μs -> 4.84μs (0.971% slower)


def test_edge_output_size_tuple_of_len_1():
    # Output size as tuple of length 1 should raise
    img = np.zeros((100, 200, 3))
    with pytest.raises(ValueError):
        get_resize_output_image_size(
            img, (50,), keep_aspect_ratio=False, multiple=1
        )  # 6.57μs -> 5.46μs (20.3% faster)


def test_edge_multiple_zero():
    # Multiple=0 should raise ZeroDivisionError
    img = np.zeros((100, 200, 3))
    with pytest.raises(ZeroDivisionError):
        get_resize_output_image_size(
            img, (50, 50), keep_aspect_ratio=False, multiple=0
        )  # 6.32μs -> 5.29μs (19.4% faster)


# --- Large Scale Test Cases ---


def test_large_scale_resize():
    # Large image, but <100MB
    img = np.zeros((500, 500, 3))  # 500*500*3*8 = 6MB
    codeflash_output = get_resize_output_image_size(img, (250, 250), keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 10.1μs -> 8.83μs (14.8% faster)


def test_large_scale_keep_aspect_ratio():
    # Large image, resizing with aspect ratio
    img = np.zeros((800, 400, 3))
    codeflash_output = get_resize_output_image_size(img, (200, 200), keep_aspect_ratio=True, multiple=1)
    out = codeflash_output  # 10.8μs -> 9.26μs (16.5% faster)
    # scale_height = 0.25, scale_width = 0.5, so use scale_height
    expected_height = round(0.25 * 800)
    expected_width = round(0.25 * 400)


def test_large_scale_multiple():
    # Large image, large multiple
    img = np.zeros((512, 512, 3))
    codeflash_output = get_resize_output_image_size(img, (256, 256), keep_aspect_ratio=False, multiple=64)
    out = codeflash_output  # 9.42μs -> 8.35μs (12.9% faster)


def test_large_scale_many_calls():
    # Test scalability by running the function many times
    img = np.zeros((100, 100, 3))
    for i in range(1, 100):
        # Output size varies, multiple varies
        codeflash_output = get_resize_output_image_size(img, (i, i * 2), keep_aspect_ratio=False, multiple=4)
        out = codeflash_output  # 134μs -> 98.5μs (36.2% faster)


def test_large_scale_non_square():
    # Large non-square image, non-square output
    img = np.zeros((900, 300, 3))
    codeflash_output = get_resize_output_image_size(img, (450, 150), keep_aspect_ratio=False, multiple=1)
    out = codeflash_output  # 8.88μs -> 8.00μs (11.0% faster)


def test_large_scale_channels_first():
    # Large image, channels first
    img = np.zeros((3, 800, 600))
    codeflash_output = get_resize_output_image_size(
        img, (400, 300), keep_aspect_ratio=False, multiple=1, input_data_format=ChannelDimension.FIRST
    )
    out = codeflash_output  # 7.96μs -> 7.88μs (1.01% faster)


def test_large_scale_multiple_and_aspect():
    # Large image, aspect ratio and multiple
    img = np.zeros((1000, 500, 3))
    codeflash_output = get_resize_output_image_size(img, (250, 250), keep_aspect_ratio=True, multiple=16)
    out = codeflash_output  # 10.6μs -> 8.92μs (18.8% faster)
    # scale_height = 0.25, scale_width = 0.5, so use scale_height
    expected_height = round(0.25 * 1000)
    expected_width = round(0.25 * 500)
    # Round to nearest multiple of 16
    expected_height = round(expected_height / 16) * 16
    expected_width = round(expected_width / 16) * 16


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-get_resize_output_image_size-misggeih and push.