⚡️ Speed up function scale_confidence by 13%

[codeflash-ai]

📄 13% (0.13x) speedup for scale_confidence in inference/core/workflows/core_steps/formatters/vlm_as_detector/v2.py

⏱️ Runtime : 1.57 milliseconds → 1.39 milliseconds (best of 156 runs)

📝 Explanation and details

The optimization removes the isinstance(value, float) type check and always calls float(value) directly. This change provides a 12% speedup because:

Key optimization:

• Eliminated redundant type checking: The original code checked if the input was already a float to avoid calling float(), but this type check overhead actually costs more than the float() conversion itself
• Simplified control flow: Removed the conditional logic that was trying to be "smart" about avoiding float conversion

Why this works:

• float() is highly optimized in Python and handles all input types efficiently
• When the input is already a float, float(value) is essentially a no-op with minimal overhead
• The isinstance() check + conditional logic was actually slower than just calling float() directly
• Python's float() constructor is optimized for common cases like integers, strings, and existing floats

Performance gains by input type:

• Boolean inputs: 57-66% faster (True/False conversion is very efficient with direct float())
• Integer inputs: 14-31% faster (direct conversion without type checking)
• String inputs: 5-17% faster (consistent float() call path)
• Error cases: 3-19% faster (simpler error propagation path)
• Large scale operations: 5-22% faster across various input distributions

The optimization is particularly effective for mixed-type inputs and high-frequency calls where the isinstance overhead accumulates significantly.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from inference.core.workflows.core_steps.formatters.vlm_as_detector.v2 import \
    scale_confidence

# unit tests

# ------------------------
# Basic Test Cases
# ------------------------

def test_basic_within_range():
    # Test with values within [0.0, 1.0]
    codeflash_output = scale_confidence(0.0) # 604ns -> 630ns (4.13% slower)
    codeflash_output = scale_confidence(0.5) # 228ns -> 210ns (8.57% faster)
    codeflash_output = scale_confidence(1.0) # 159ns -> 147ns (8.16% faster)

def test_basic_integer_inputs():
    # Test with integer inputs
    codeflash_output = scale_confidence(0) # 608ns -> 532ns (14.3% faster)
    codeflash_output = scale_confidence(1) # 282ns -> 230ns (22.6% faster)
    codeflash_output = scale_confidence(7) # 271ns -> 222ns (22.1% faster)

def test_basic_string_inputs():
    # Test with string representations of numbers
    codeflash_output = scale_confidence("0.0") # 931ns -> 827ns (12.6% faster)
    codeflash_output = scale_confidence("1.0") # 425ns -> 405ns (4.94% faster)
    codeflash_output = scale_confidence("0.5") # 273ns -> 258ns (5.81% faster)

def test_basic_rounding():
    # Test with values very close to bounds
    codeflash_output = scale_confidence(0.000001) # 418ns -> 445ns (6.07% slower)
    codeflash_output = scale_confidence(0.999999) # 207ns -> 206ns (0.485% faster)

# ------------------------
# Edge Test Cases
# ------------------------

def test_edge_negative_values():
    # Test with negative values
    codeflash_output = scale_confidence(-0.0001) # 417ns -> 438ns (4.79% slower)
    codeflash_output = scale_confidence(-1.0) # 170ns -> 167ns (1.80% faster)
    codeflash_output = scale_confidence("-5.5") # 677ns -> 551ns (22.9% faster)

def test_edge_above_one_values():
    # Test with values above 1.0
    codeflash_output = scale_confidence(1.0001) # 445ns -> 477ns (6.71% slower)
    codeflash_output = scale_confidence(2.0) # 236ns -> 250ns (5.60% slower)
    codeflash_output = scale_confidence("5.5") # 568ns -> 472ns (20.3% faster)

def test_edge_non_numeric_string():
    # Test with non-numeric string input (should raise ValueError)
    with pytest.raises(ValueError):
        scale_confidence("hello") # 1.83μs -> 1.77μs (3.05% faster)
    with pytest.raises(ValueError):
        scale_confidence("") # 762ns -> 684ns (11.4% faster)

def test_edge_none_input():
    # Test with None input (should raise TypeError)
    with pytest.raises(TypeError):
        scale_confidence(None) # 1.25μs -> 1.24μs (1.21% faster)

def test_edge_nan_and_inf():
    # Test with NaN and infinite values
    import math

    # NaN should propagate as NaN
    codeflash_output = scale_confidence(float('nan')); result = codeflash_output # 445ns -> 491ns (9.37% slower)
    # Positive infinity should clamp to 1.0
    codeflash_output = scale_confidence(float('inf')) # 301ns -> 293ns (2.73% faster)
    # Negative infinity should clamp to 0.0
    codeflash_output = scale_confidence(float('-inf')) # 166ns -> 148ns (12.2% faster)

def test_edge_boolean_input():
    # Test with boolean input (True/False are subclasses of int)
    codeflash_output = scale_confidence(True) # 930ns -> 563ns (65.2% faster)
    codeflash_output = scale_confidence(False) # 376ns -> 283ns (32.9% faster)

def test_edge_object_input():
    # Test with object input (should raise TypeError)
    class Dummy:
        pass
    with pytest.raises(TypeError):
        scale_confidence(Dummy()) # 1.48μs -> 1.27μs (16.7% faster)

def test_edge_list_input():
    # Test with list input (should raise TypeError)
    with pytest.raises(TypeError):
        scale_confidence([0.5]) # 1.28μs -> 1.22μs (4.99% faster)

def test_edge_tuple_input():
    # Test with tuple input (should raise TypeError)
    with pytest.raises(TypeError):
        scale_confidence((0.5,)) # 1.35μs -> 1.19μs (13.4% faster)

def test_edge_dict_input():
    # Test with dict input (should raise TypeError)
    with pytest.raises(TypeError):
        scale_confidence({'value': 0.5}) # 1.30μs -> 1.23μs (6.28% faster)

# ------------------------
# Large Scale Test Cases
# ------------------------


def test_large_scale_many_negative_values():
    # Test with a large list of negative values
    negatives = [-i for i in range(1000)]  # -0, -1, ..., -999
    for v in negatives:
        codeflash_output = scale_confidence(v) # 163μs -> 133μs (22.4% faster)

def test_large_scale_many_above_one_values():
    # Test with a large list of values above 1.0
    values = [1.0 + (i / 100.0) for i in range(1000)]  # 1.0 to 11.0
    for v in values:
        codeflash_output = scale_confidence(v) # 146μs -> 137μs (6.90% faster)

def test_large_scale_string_inputs():
    # Test with a large list of string inputs
    values = [str(i / 999) for i in range(1000)]  # strings "0.0" to "1.0"
    for v in values:
        codeflash_output = scale_confidence(v) # 315μs -> 283μs (11.4% faster)

def test_large_scale_boolean_inputs():
    # Test with a large list of boolean values
    bools = [True, False] * 500  # 1000 elements
    for b in bools:
        expected = 1.0 if b else 0.0
        codeflash_output = scale_confidence(b) # 178μs -> 147μs (21.2% faster)

def test_large_scale_mixed_types():
    # Test with a large list of mixed types
    mixed = [0.5, "0.5", 1, "1", True, False, -0.5, "2.5", 0.0, "hello"]
    # Repeat to reach 1000 elements
    mixed = mixed * (1000 // len(mixed))
    # The last element "hello" should raise ValueError
    for v in mixed[:-1]:
        try:
            codeflash_output = scale_confidence(v); result = codeflash_output
            # For valid values, check clamping
            if isinstance(v, (int, float)):
                expected = max(0.0, min(float(v), 1.0))
            elif isinstance(v, str):
                try:
                    fv = float(v)
                    expected = max(0.0, min(fv, 1.0))
                except ValueError:
                    continue  # skip
            elif isinstance(v, bool):
                expected = 1.0 if v else 0.0
        except Exception:
            continue
    # Last element should raise ValueError
    with pytest.raises(ValueError):
        scale_confidence("hello") # 487ns -> 466ns (4.51% 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  # used for our unit tests
from inference.core.workflows.core_steps.formatters.vlm_as_detector.v2 import \
    scale_confidence

# unit tests

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

def test_basic_within_range():
    # Test typical values within [0.0, 1.0]
    codeflash_output = scale_confidence(0.0) # 584ns -> 471ns (24.0% faster)
    codeflash_output = scale_confidence(0.25) # 267ns -> 262ns (1.91% faster)
    codeflash_output = scale_confidence(0.5) # 174ns -> 164ns (6.10% faster)
    codeflash_output = scale_confidence(0.75) # 148ns -> 143ns (3.50% faster)
    codeflash_output = scale_confidence(1.0) # 146ns -> 140ns (4.29% faster)

def test_basic_integer_inputs():
    # Test integer inputs in range
    codeflash_output = scale_confidence(0) # 576ns -> 536ns (7.46% faster)
    codeflash_output = scale_confidence(1) # 279ns -> 213ns (31.0% faster)

def test_basic_string_inputs():
    # Test string inputs that can be converted to float
    codeflash_output = scale_confidence("0.5") # 899ns -> 900ns (0.111% slower)
    codeflash_output = scale_confidence("1.0") # 365ns -> 314ns (16.2% faster)
    codeflash_output = scale_confidence("0") # 259ns -> 250ns (3.60% faster)

def test_basic_rounding_behavior():
    # Test values very close to bounds
    codeflash_output = scale_confidence(0.999999) # 433ns -> 408ns (6.13% faster)
    codeflash_output = scale_confidence(0.000001) # 229ns -> 197ns (16.2% faster)

# ---- EDGE TEST CASES ----

def test_edge_below_zero():
    # Test values below 0.0
    codeflash_output = scale_confidence(-0.1) # 425ns -> 442ns (3.85% slower)
    codeflash_output = scale_confidence(-100) # 436ns -> 348ns (25.3% faster)
    codeflash_output = scale_confidence("-5") # 495ns -> 513ns (3.51% slower)

def test_edge_above_one():
    # Test values above 1.0
    codeflash_output = scale_confidence(1.1) # 455ns -> 485ns (6.19% slower)
    codeflash_output = scale_confidence(2.5) # 241ns -> 260ns (7.31% slower)
    codeflash_output = scale_confidence("100") # 610ns -> 537ns (13.6% faster)

def test_edge_float_precision():
    # Test values extremely close to bounds
    codeflash_output = scale_confidence(1.0000000001) # 419ns -> 438ns (4.34% slower)
    codeflash_output = scale_confidence(-0.0000000001) # 251ns -> 223ns (12.6% faster)

def test_edge_non_numeric_string():
    # Test string that cannot be converted to float should raise ValueError
    with pytest.raises(ValueError):
        scale_confidence("not_a_number") # 1.62μs -> 1.50μs (8.56% faster)

def test_edge_none_input():
    # Test None input should raise TypeError
    with pytest.raises(TypeError):
        scale_confidence(None) # 1.36μs -> 1.29μs (5.52% faster)

def test_edge_bool_input():
    # Test boolean input: True should convert to 1.0, False to 0.0
    codeflash_output = scale_confidence(True) # 985ns -> 625ns (57.6% faster)
    codeflash_output = scale_confidence(False) # 395ns -> 260ns (51.9% faster)

def test_edge_large_negative_float():
    # Test very large negative float
    codeflash_output = scale_confidence(-1e10) # 415ns -> 449ns (7.57% slower)

def test_edge_large_positive_float():
    # Test very large positive float
    codeflash_output = scale_confidence(1e10) # 472ns -> 485ns (2.68% slower)

def test_edge_inf_nan():
    # Test special float values
    import math

    # inf should clamp to 1.0
    codeflash_output = scale_confidence(float('inf')) # 428ns -> 438ns (2.28% slower)
    # -inf should clamp to 0.0
    codeflash_output = scale_confidence(float('-inf')) # 231ns -> 247ns (6.48% slower)
    # nan should propagate (float('nan') == float('nan') is False, so use math.isnan)
    codeflash_output = scale_confidence(float('nan')); result = codeflash_output # 235ns -> 219ns (7.31% faster)

def test_edge_object_input():
    # Test input that cannot be converted to float should raise TypeError
    class Dummy:
        pass
    with pytest.raises(TypeError):
        scale_confidence(Dummy()) # 1.57μs -> 1.32μs (18.8% faster)


def test_edge_list_input():
    # Test list input should raise TypeError
    with pytest.raises(TypeError):
        scale_confidence([0.5]) # 1.62μs -> 1.52μs (7.06% faster)

def test_edge_dict_input():
    # Test dict input should raise TypeError
    with pytest.raises(TypeError):
        scale_confidence({'value': 0.5}) # 1.35μs -> 1.31μs (2.59% faster)

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


def test_large_scale_random_floats():
    # Test random floats between -10 and 10
    import random
    random.seed(42)  # for determinism
    values = [random.uniform(-10, 10) for _ in range(1000)]
    for v in values:
        codeflash_output = scale_confidence(v); result = codeflash_output # 145μs -> 138μs (4.69% faster)

def test_large_scale_string_inputs():
    # Test a large number of string inputs
    values = [str(x/1000) for x in range(-1000, 1000, 2)]  # from -1.0 to 1.998 step 0.002
    for s in values:
        codeflash_output = scale_confidence(s); result = codeflash_output # 203μs -> 174μs (16.9% faster)
        float_val = float(s)
        if float_val < 0.0:
            pass
        elif float_val > 1.0:
            pass
        else:
            pass

def test_large_scale_extreme_values():
    # Test large scale with extreme float values
    extreme_values = [-1e308, -1e100, 1e100, 1e308]
    expected = [0.0, 0.0, 1.0, 1.0]
    for v, exp in zip(extreme_values, expected):
        codeflash_output = scale_confidence(v) # 1.13μs -> 1.02μs (10.0% faster)

To edit these changes git checkout codeflash/optimize-scale_confidence-mh9xmb6d and push.