⚡️ Speed up function poi_average by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for poi_average in modules/textual_inversion/autocrop.py

⏱️ Runtime : 952 microseconds → 883 microseconds (best of 383 runs)

📝 Explanation and details

The optimization achieves a 7% speedup through two key improvements:

1. Cached Attribute Access: The optimized code stores poi.weight in a local variable w within the loop, avoiding repeated attribute lookups. This reduces the cost per iteration from ~228ns to ~169ns for weight access operations.

2. Explicit Zero-Weight Handling: Instead of using the cryptic weight and x / weight pattern, the code uses an explicit if weight: check. This eliminates the boolean evaluation overhead and makes the zero-weight case more efficient.

The line profiler shows the most significant gains in the loop operations - weight assignment drops from 179.9ns to 164.3ns per hit, and the weighted calculations become faster due to using the cached weight value.

Performance by test case type:

• Empty/zero-weight cases: 16-21% faster due to optimized conditional handling
• Large datasets (1000+ POIs): 10-12% faster from reduced attribute lookups
• Small datasets: 3-8% faster, with diminishing returns on very simple cases

The optimization particularly shines when processing many POIs or handling edge cases with zero weights, while maintaining identical mathematical behavior and rounding semantics.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from collections import namedtuple

# imports
import pytest
from modules.textual_inversion.autocrop import poi_average

# Define the PointOfInterest class for testing
PointOfInterest = namedtuple('PointOfInterest', ['x', 'y'])
from modules.textual_inversion.autocrop import poi_average

# --- Unit Tests ---

# Basic Test Cases

def test_single_poi():
    # Single POI should return its own coordinates
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(10, 20, 1)]
    codeflash_output = poi_average(pois, None); result = codeflash_output # 2.72μs -> 2.64μs (3.03% faster)

def test_two_equal_weight_pois():
    # Two POIs, equal weight, average should be arithmetic mean
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(0, 0, 1), POI(10, 10, 1)]
    codeflash_output = poi_average(pois, None); result = codeflash_output # 2.56μs -> 2.55μs (0.432% faster)

def test_two_unequal_weight_pois():
    # Two POIs, different weights, average should be weighted
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(0, 0, 1), POI(10, 10, 3)]
    # Weighted average: ((0*1)+(10*3))/(1+3) = 7.5 -> rounds to 8
    codeflash_output = poi_average(pois, None) # 2.56μs -> 2.47μs (3.56% faster)

def test_three_pois_varied_weights():
    # Three POIs, varied weights
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(1, 2, 1), POI(3, 4, 2), POI(5, 6, 3)]
    # x: (1*1 + 3*2 + 5*3) = 1+6+15=22; total weight=6; avg=22/6=3.666...->4
    # y: (2*1 + 4*2 + 6*3) = 2+8+18=28; avg=28/6=4.666...->5
    codeflash_output = poi_average(pois, None) # 2.54μs -> 2.44μs (3.93% faster)

# Edge Test Cases

def test_empty_pois_list():
    # No POIs, should return (0,0) as per implementation (since weight==0)
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = []
    codeflash_output = poi_average(pois, None) # 1.35μs -> 1.12μs (21.1% faster)

def test_all_zero_weights():
    # All POIs have zero weights, should return (0,0)
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(10, 10, 0), POI(20, 20, 0)]
    codeflash_output = poi_average(pois, None) # 2.26μs -> 1.94μs (16.5% faster)

def test_negative_weights():
    # Negative weights should be included in calculation
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(10, 10, 1), POI(20, 20, -1)]
    # (10*1 + 20*-1) = 10 - 20 = -10; weight = 0; so returns (0,0)
    codeflash_output = poi_average(pois, None) # 2.46μs -> 2.05μs (19.8% faster)

def test_large_and_small_weights():
    # Large and small weights, check for floating point precision
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(1, 1, 1e-9), POI(1000, 1000, 1e9)]
    # Weighted avg x: (1*1e-9 + 1000*1e9)/(1e-9+1e9) ≈ 1000
    codeflash_output = poi_average(pois, None); result = codeflash_output # 2.74μs -> 2.75μs (0.109% slower)

def test_rounding_half_up():
    # Test that rounding is correct (Python's round: ties to even)
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(1, 1, 1), POI(2, 2, 1)]
    # avg = 1.5, round(1.5) == 2 (Python rounds ties to even)
    codeflash_output = poi_average(pois, None); result = codeflash_output # 2.58μs -> 2.51μs (2.71% faster)

def test_rounding_half_down():
    # Test that rounding is correct for .5 to even
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(2, 2, 1), POI(3, 3, 1)]
    # avg = 2.5, round(2.5) == 2
    codeflash_output = poi_average(pois, None); result = codeflash_output # 2.62μs -> 2.41μs (8.93% faster)

def test_non_integer_coordinates():
    # POIs with float coordinates
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(1.2, 3.7, 1), POI(2.8, 4.3, 1)]
    # avg_x = (1.2+2.8)/2 = 2.0, round(2.0) == 2
    # avg_y = (3.7+4.3)/2 = 4.0, round(4.0) == 4
    codeflash_output = poi_average(pois, None) # 2.72μs -> 2.76μs (1.27% slower)

def test_negative_coordinates():
    # POIs with negative coordinates
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(-5, -5, 1), POI(5, 5, 1)]
    # avg_x = 0, avg_y = 0
    codeflash_output = poi_average(pois, None) # 2.48μs -> 2.46μs (0.855% faster)

def test_mixed_sign_weights():
    # POIs with mixed positive and negative weights
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(10, 10, 2), POI(20, 20, -1)]
    # (10*2 + 20*-1) = 20 - 20 = 0; weight = 1; avg = 0/1 = 0
    codeflash_output = poi_average(pois, None) # 2.54μs -> 2.42μs (4.93% faster)

def test_zero_and_nonzero_weights():
    # POIs with some zero weights
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(100, 100, 0), POI(200, 200, 2)]
    # Only the second POI counts
    codeflash_output = poi_average(pois, None) # 2.57μs -> 2.42μs (6.15% faster)

# Large Scale Test Cases

def test_many_pois_identical():
    # Many POIs with identical coordinates and weights
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(7, 9, 1) for _ in range(1000)]
    codeflash_output = poi_average(pois, None); result = codeflash_output # 94.0μs -> 84.2μs (11.7% faster)

def test_many_pois_linear_distribution():
    # POIs from (0,0) to (999,999), weights all 1
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(i, i, 1) for i in range(1000)]
    # Average is (0+999)/2 = 499.5, round(499.5) = 500 (ties to even)
    codeflash_output = poi_average(pois, None); result = codeflash_output # 97.5μs -> 88.4μs (10.3% faster)

def test_many_pois_varied_weights():
    # POIs from (0,0) to (999,999), weight = i
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(i, i, i) for i in range(1, 1001)]
    # Weighted average: sum(i*i)/sum(i), for i=1..1000
    n = 1000
    sum_weights = sum(i for i in range(1, n+1))
    sum_weighted_x = sum(i*i for i in range(1, n+1))
    expected = round(sum_weighted_x / sum_weights)
    codeflash_output = poi_average(pois, None); result = codeflash_output # 99.6μs -> 88.8μs (12.1% faster)

def test_many_pois_alternating_weights():
    # POIs with alternating positive and negative weights
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(i, -i, (-1)**i) for i in range(1, 1001)]
    # The sum of weights will be 0 if even, 1 if odd, but for 1000 it's 0
    # So should return (0,0)
    codeflash_output = poi_average(pois, None); result = codeflash_output # 99.4μs -> 88.5μs (12.3% faster)

def test_many_pois_float_weights():
    # POIs with float weights
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(i, i, 0.1) for i in range(1000)]
    # Average should be same as integer weights
    codeflash_output = poi_average(pois, None); result = codeflash_output # 90.7μs -> 80.8μs (12.2% faster)

def test_large_coordinates():
    # POIs with very large coordinates to check for overflow/precision
    POI = namedtuple('POI', ['x', 'y', 'weight'])
    pois = [POI(10**9, -10**9, 1), POI(-10**9, 10**9, 1)]
    # Average is (0, 0)
    codeflash_output = poi_average(pois, None); result = codeflash_output # 2.84μs -> 2.71μs (4.76% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest
from modules.textual_inversion.autocrop import poi_average


# Define a minimal PointOfInterest class for testing purposes
class PointOfInterest:
    def __init__(self, x, y, weight=1.0):
        self.x = x
        self.y = y
        self.weight = weight

    def __eq__(self, other):
        return (
            isinstance(other, PointOfInterest)
            and self.x == other.x
            and self.y == other.y
        )

    def __repr__(self):
        return f"PointOfInterest(x={self.x}, y={self.y}, weight={self.weight})"
from modules.textual_inversion.autocrop import poi_average

# =========================
# Basic Test Cases
# =========================

def test_single_poi():
    # Single POI: average should be the POI itself
    pois = [PointOfInterest(3, 4, 1.0)]
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.35μs -> 2.19μs (7.40% faster)

def test_two_pois_equal_weight():
    # Two POIs, equal weights: average is the midpoint
    pois = [PointOfInterest(0, 0, 1.0), PointOfInterest(2, 2, 1.0)]
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.25μs -> 2.28μs (1.40% slower)

def test_two_pois_unequal_weight():
    # Two POIs, different weights: average is weighted
    pois = [PointOfInterest(0, 0, 1.0), PointOfInterest(2, 2, 3.0)]
    # Weighted average: ((0*1)+(2*3))/(1+3) = 1.5 -> round(1.5)=2
    # Same for y
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.26μs -> 2.26μs (0.000% faster)

def test_three_pois_varied_weight():
    # Three POIs, varied weights
    pois = [
        PointOfInterest(1, 1, 1.0),
        PointOfInterest(3, 1, 2.0),
        PointOfInterest(5, 5, 1.0),
    ]
    # x: (1*1 + 3*2 + 5*1)/(1+2+1) = (1+6+5)/4 = 12/4=3
    # y: (1*1 + 1*2 + 5*1)/(1+2+1) = (1+2+5)/4 = 8/4=2
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.37μs -> 2.28μs (3.59% faster)

def test_negative_coordinates():
    # POIs with negative coordinates
    pois = [
        PointOfInterest(-2, -2, 1.0),
        PointOfInterest(2, 2, 1.0),
    ]
    # Average: ( (-2+2)/2, (-2+2)/2 ) = (0,0)
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.13μs -> 2.13μs (0.188% faster)

def test_float_weights_and_coordinates():
    # POIs with float weights and float coordinates
    pois = [
        PointOfInterest(1.5, 2.5, 2.0),
        PointOfInterest(3.5, 4.5, 3.0),
    ]
    # x: (1.5*2 + 3.5*3)/(2+3) = (3+10.5)/5 = 13.5/5 = 2.7 -> round(2.7)=3
    # y: (2.5*2 + 4.5*3)/(2+3) = (5+13.5)/5 = 18.5/5 = 3.7 -> round(3.7)=4
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.12μs -> 2.15μs (1.39% slower)

# =========================
# Edge Test Cases
# =========================

def test_empty_pois_list():
    # No POIs: should return (0,0)
    pois = []
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 1.34μs -> 1.15μs (16.8% faster)

def test_all_zero_weights():
    # POIs with zero weights: should return (0,0)
    pois = [
        PointOfInterest(10, 10, 0.0),
        PointOfInterest(-10, -10, 0.0),
    ]
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.12μs -> 1.81μs (16.6% faster)

def test_some_zero_weights():
    # Some POIs with zero weights, should ignore them
    pois = [
        PointOfInterest(10, 10, 0.0),
        PointOfInterest(2, 4, 2.0),
        PointOfInterest(6, 8, 2.0),
    ]
    # Only the last two count: ((2*2)+(6*2))/4 = (4+12)/4=4, ((4*2)+(8*2))/4=(8+16)/4=6
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.43μs -> 2.41μs (0.705% faster)

def test_large_and_small_weights():
    # POIs with very large and very small weights
    pois = [
        PointOfInterest(1000, 1000, 1e-6),
        PointOfInterest(1, 1, 1e6),
    ]
    # The large weight dominates, so average should be (1,1)
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.06μs -> 2.09μs (1.48% slower)

def test_rounding_half_up():
    # Test rounding at .5 boundary (Python's round uses round-half-to-even)
    pois = [
        PointOfInterest(1, 1, 1.0),
        PointOfInterest(2, 2, 1.0),
    ]
    # (1+2)/2 = 1.5, round(1.5) = 2 (since Python rounds .5 to nearest even)
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.18μs -> 2.18μs (0.275% faster)

def test_negative_and_positive_weights():
    # Negative weights: not typical, but let's see what happens
    pois = [
        PointOfInterest(10, 0, 2.0),
        PointOfInterest(0, 10, -2.0),
    ]
    # weight = 0, should return (0,0)
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.06μs -> 1.67μs (23.3% faster)

def test_large_negative_coordinates():
    # Large negative coordinates
    pois = [
        PointOfInterest(-999, -999, 1.0),
        PointOfInterest(-1, -1, 1.0),
    ]
    # Average: (-999+-1)/2 = -500, round(-500) = -500
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.39μs -> 2.48μs (3.51% slower)

def test_all_same_point():
    # All POIs at the same point, different weights
    pois = [
        PointOfInterest(7, 7, 1.0),
        PointOfInterest(7, 7, 2.0),
        PointOfInterest(7, 7, 3.0),
    ]
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.37μs -> 2.45μs (3.11% slower)

def test_non_integer_result():
    # Weighted average is non-integer, check rounding
    pois = [
        PointOfInterest(0, 0, 1.0),
        PointOfInterest(1, 1, 1.0),
        PointOfInterest(2, 2, 1.0),
    ]
    # (0+1+2)/3 = 1.0, round(1.0)=1
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 2.26μs -> 2.22μs (1.80% faster)

# =========================
# Large Scale Test Cases
# =========================

def test_many_pois_uniform():
    # 1000 POIs at (1,1), average should be (1,1)
    pois = [PointOfInterest(1, 1, 1.0) for _ in range(1000)]
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 76.3μs -> 73.3μs (4.13% faster)

def test_many_pois_linear_distribution():
    # 1000 POIs from (0,0) to (999,999), all weight 1
    pois = [PointOfInterest(i, i, 1.0) for i in range(1000)]
    # Average: sum(i for i in 0..999)/1000 = (999*1000/2)/1000 = 499.5, round(499.5)=500
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 80.4μs -> 77.7μs (3.52% faster)

def test_many_pois_varied_weights():
    # 1000 POIs, x=i, y=1000-i, weight=i+1
    pois = [PointOfInterest(i, 1000-i, i+1) for i in range(1000)]
    total_weight = sum(i+1 for i in range(1000))
    avg_x = round(sum(i*(i+1) for i in range(1000)) / total_weight)
    avg_y = round(sum((1000-i)*(i+1) for i in range(1000)) / total_weight)
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 87.9μs -> 83.6μs (5.06% faster)

def test_many_pois_some_zero_weights():
    # 1000 POIs, half with zero weight, half with weight 1
    pois = [PointOfInterest(i, i, 0.0) for i in range(500)] + [PointOfInterest(i, i, 1.0) for i in range(500, 1000)]
    # Only last 500 count: average of 500..999 = (500+999)*500/2/500 = (1499*500/2)/500 = 749.5, round(749.5)=750
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 76.9μs -> 72.1μs (6.66% faster)

def test_many_pois_float_weights():
    # 1000 POIs, weights are floats
    pois = [PointOfInterest(i, 2*i, i/1000.0+0.1) for i in range(1000)]
    total_weight = sum(i/1000.0+0.1 for i in range(1000))
    avg_x = round(sum(i*(i/1000.0+0.1) for i in range(1000)) / total_weight)
    avg_y = round(sum(2*i*(i/1000.0+0.1) for i in range(1000)) / total_weight)
    codeflash_output = poi_average(pois, settings=None); result = codeflash_output # 79.4μs -> 78.3μs (1.36% faster)
# 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-poi_average-mhadl4q0 and push.