⚡️ Speed up function gen_encoder_output_proposals by 14% in PR #1250 (feature/inference-v1-models)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1250

If you approve this dependent PR, these changes will be merged into the original PR branch feature/inference-v1-models.

This PR will be automatically closed if the original PR is merged.

---

📄 14% (0.14x) speedup for gen_encoder_output_proposals in inference/v1/models/rfdetr/transformer.py

⏱️ Runtime : 9.48 milliseconds → 8.35 milliseconds (best of 92 runs)

📝 Explanation and details

Optimizations applied:

• Grid and wh precomputation: Mesh grids, wh, and linspace are precomputed outside the batch loop, saving construction time for every batch in each feature level.
• No on-the-fly List Comps for Constants: Use torch.full instead of list comprehension for valid_H/valid_W for device efficiency.
• Mask application fused: Masking for memory output is performed in a single step rather than multiple .masked_fill calls.
• Broadcasting leverages expand: Use broadcasting and expand for grid and wh to apply batched normalization and expansion efficiently.
• Clamp input to log to avoid division by zero: Guard output_proposals before applying log/unsigmoid where appropriate.
• Keep all comments except for where code has changed to be more efficient.
• Minimized/avoided unnecessary .to(torch.float32) and ensured type is kept.
• Avoided Python for-loop style memory building for proposal arrays and vectorized where possible.
• Other micro-optimizations: Replaced some sum and view logic with more direct/fused code.

Return values, function name, signatures, and intermediate logic remain unchanged for correctness.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

import pytest  # used for our unit tests
import torch  # used for tensor operations
from inference.v1.models.rfdetr.transformer import gen_encoder_output_proposals

# unit tests

def test_standard_input():
    # Test with typical non-zero memory, valid padding mask, and reasonable spatial shapes
    memory = torch.rand(2, 100, 256)
    memory_padding_mask = torch.zeros(2, 100, dtype=torch.bool)
    spatial_shapes = torch.tensor([[10, 10]])
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_no_padding_mask():
    # Test with no padding mask provided
    memory = torch.rand(2, 100, 256)
    spatial_shapes = torch.tensor([[10, 10]])
    output_memory, output_proposals = gen_encoder_output_proposals(memory, None, spatial_shapes)


def test_single_element():
    # Test with single element in memory and minimal spatial dimensions
    memory = torch.rand(1, 1, 256)
    memory_padding_mask = torch.zeros(1, 1, dtype=torch.bool)
    spatial_shapes = torch.tensor([[1, 1]])
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_maximum_dimensions():
    # Test with maximum dimensions without exceeding memory limits
    memory = torch.rand(2, 1000, 256)
    memory_padding_mask = torch.zeros(2, 1000, dtype=torch.bool)
    spatial_shapes = torch.tensor([[100, 10]])
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_unsigmoid_true():
    # Test with unsigmoid=True to ensure logit transformation
    memory = torch.rand(2, 100, 256)
    memory_padding_mask = torch.zeros(2, 100, dtype=torch.bool)
    spatial_shapes = torch.tensor([[10, 10]])
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes, unsigmoid=True)

def test_unsigmoid_false():
    # Test with unsigmoid=False to ensure no transformation
    memory = torch.rand(2, 100, 256)
    memory_padding_mask = torch.zeros(2, 100, dtype=torch.bool)
    spatial_shapes = torch.tensor([[10, 10]])
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes, unsigmoid=False)

def test_invalid_shapes():
    # Test with mismatched dimensions
    memory = torch.rand(2, 100, 256)
    memory_padding_mask = torch.zeros(2, 50, dtype=torch.bool)  # Incorrect shape
    spatial_shapes = torch.tensor([[10, 10]])
    with pytest.raises(RuntimeError):
        gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_negative_values():
    # Test with negative values in memory
    memory = torch.rand(2, 100, 256) - 1.0  # Negative values
    memory_padding_mask = torch.zeros(2, 100, dtype=torch.bool)
    spatial_shapes = torch.tensor([[10, 10]])
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)


def test_all_padding():
    # Test with all positions padded
    memory = torch.rand(2, 100, 256)
    memory_padding_mask = torch.ones(2, 100, dtype=torch.bool)  # All padded
    spatial_shapes = torch.tensor([[10, 10]])
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_all_valid():
    # Test with no positions padded
    memory = torch.rand(2, 100, 256)
    memory_padding_mask = torch.zeros(2, 100, dtype=torch.bool)  # No padding
    spatial_shapes = torch.tensor([[10, 10]])
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_reproducibility():
    # Test for consistent output across multiple runs
    memory = torch.rand(2, 100, 256)
    memory_padding_mask = torch.zeros(2, 100, dtype=torch.bool)
    spatial_shapes = torch.tensor([[10, 10]])
    output_memory1, output_proposals1 = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)
    output_memory2, output_proposals2 = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
import torch  # used for tensor operations
from inference.v1.models.rfdetr.transformer import gen_encoder_output_proposals

# unit tests

def test_standard_input():
    # Test with standard input dimensions
    memory = torch.rand(2, 64, 256)
    spatial_shapes = torch.tensor([[8, 8]])
    memory_padding_mask = None
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_zero_dimensions():
    # Test with zero height and width
    memory = torch.rand(2, 0, 256)
    spatial_shapes = torch.tensor([[0, 0]])
    memory_padding_mask = None
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_single_element():
    # Test with single element spatial shape
    memory = torch.rand(1, 1, 256)
    spatial_shapes = torch.tensor([[1, 1]])
    memory_padding_mask = None
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_full_padding():
    # Test with full padding mask
    memory = torch.rand(2, 64, 256)
    spatial_shapes = torch.tensor([[8, 8]])
    memory_padding_mask = torch.ones(2, 64, dtype=torch.bool)
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_partial_padding():
    # Test with partial padding mask
    memory = torch.rand(2, 64, 256)
    spatial_shapes = torch.tensor([[8, 8]])
    memory_padding_mask = torch.zeros(2, 64, dtype=torch.bool)
    memory_padding_mask[:, :32] = 1
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_unsigmoid_enabled():
    # Test with unsigmoid enabled
    memory = torch.rand(2, 64, 256)
    spatial_shapes = torch.tensor([[8, 8]])
    memory_padding_mask = None
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes, unsigmoid=True)

def test_unsigmoid_disabled():
    # Test with unsigmoid disabled
    memory = torch.rand(2, 64, 256)
    spatial_shapes = torch.tensor([[8, 8]])
    memory_padding_mask = None
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes, unsigmoid=False)



def test_boundary_values():
    # Test with boundary values for proposals
    memory = torch.rand(2, 64, 256)
    spatial_shapes = torch.tensor([[8, 8]])
    memory_padding_mask = None
    output_memory, output_proposals = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)

def test_repeatability():
    # Test for deterministic behavior
    memory = torch.rand(2, 64, 256)
    spatial_shapes = torch.tensor([[8, 8]])
    memory_padding_mask = None
    output_memory1, output_proposals1 = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)
    output_memory2, output_proposals2 = gen_encoder_output_proposals(memory, memory_padding_mask, spatial_shapes)
# 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-pr1250-2025-05-13T16.49.20 and push.