⚡️ Speed up function _replace_numpy_floats by 107%

[codeflash-ai]

📄 107% (1.07x) speedup for _replace_numpy_floats in spacy/language.py

⏱️ Runtime : 6.11 milliseconds → 2.95 milliseconds (best of 250 runs)

📝 Explanation and details

The optimized version achieves a 107% speedup by replacing the generic thinc.util.convert_recursive function with a specialized, direct recursive implementation.

Key optimizations:

1. Eliminates external dependency overhead: The original code relies on convert_recursive, which adds significant function call overhead and generic dispatch logic. The profiler shows this accounts for 99.8% of execution time (32.6ms out of 32.6ms total).

2. Direct type checking and conversion: Instead of passing lambda functions to a generic recursive utility, the optimized version performs direct isinstance() checks and conversions inline, eliminating multiple function call layers.

3. Specialized data structure handling: The new implementation explicitly handles the common container types (dict, list, tuple) with optimized comprehensions rather than going through a generic conversion framework.

Performance characteristics:

• Small structures (2-8μs): 20-50% faster due to reduced function call overhead
• Large structures (100-600μs): 80-280% faster, showing excellent scaling as the overhead elimination compounds with data size
• Edge cases: Maintains correctness while being consistently faster, with only negligible slowdown on empty dicts (1-2% due to the function definition overhead)

The optimization is particularly effective for large-scale data processing scenarios, which appear common based on the test cases, making this a valuable improvement for any workload that processes substantial amounts of nested data containing numpy floats.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import numpy
# imports
import pytest  # used for our unit tests
from spacy.language import _replace_numpy_floats

# unit tests

# 1. Basic Test Cases

def test_basic_single_numpy_float():
    # Should convert a single numpy float value to a Python float
    input_dict = {"a": numpy.float32(1.5)}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 3.18μs -> 2.35μs (35.7% faster)

def test_basic_multiple_numpy_floats():
    # Should convert multiple numpy float values to Python floats
    input_dict = {"a": numpy.float64(2.3), "b": numpy.float32(4.7)}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 3.45μs -> 2.36μs (46.0% faster)

def test_basic_python_float_and_int():
    # Should leave Python float and int unchanged
    input_dict = {"a": 3.14, "b": 42}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 3.34μs -> 2.51μs (33.0% faster)

def test_basic_mixed_types():
    # Should convert only numpy floats, leave others unchanged
    input_dict = {
        "a": numpy.float32(5.5),
        "b": "string",
        "c": 7,
        "d": None,
        "e": 3.14,
        "f": False
    }
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 6.12μs -> 3.99μs (53.2% faster)

# 2. Edge Test Cases

def test_edge_empty_dict():
    # Should handle empty dict
    input_dict = {}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 1.46μs -> 1.50μs (2.67% slower)

def test_edge_nested_dict():
    # Should convert numpy floats inside nested dicts
    input_dict = {
        "a": {
            "b": numpy.float64(10.1),
            "c": {
                "d": numpy.float32(20.2)
            }
        }
    }
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 4.59μs -> 3.18μs (44.4% faster)

def test_edge_list_of_numpy_floats():
    # Should convert numpy floats in lists
    input_dict = {"a": [numpy.float32(1.1), numpy.float64(2.2), 3]}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 4.21μs -> 2.87μs (46.5% faster)

def test_edge_tuple_of_numpy_floats():
    # Should convert numpy floats in tuples
    input_dict = {"a": (numpy.float32(1.1), numpy.float64(2.2), 3)}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 4.80μs -> 3.78μs (27.0% faster)

def test_edge_set_of_numpy_floats():
    # Should convert numpy floats in sets
    input_dict = {"a": {numpy.float32(1.1), numpy.float64(2.2), 3}}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 2.33μs -> 1.94μs (20.3% faster)

def test_edge_mixed_nested_structures():
    # Should convert numpy floats in mixed nested structures
    input_dict = {
        "a": [
            {"b": numpy.float64(5.5)},
            (numpy.float32(6.6), {"c": numpy.float64(7.7)}),
            {numpy.float32(8.8), 9}
        ]
    }
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 7.19μs -> 5.46μs (31.6% faster)

def test_edge_numpy_float_subclasses():
    # Should handle subclasses of numpy.floating
    class MyFloat(numpy.float64):
        pass
    input_dict = {"a": MyFloat(123.456)}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 2.56μs -> 2.08μs (23.4% faster)

def test_edge_non_dict_input():
    # Should raise TypeError if input is not a dict
    with pytest.raises(TypeError):
        _replace_numpy_floats([numpy.float64(1.1)]) # 3.06μs -> 3.05μs (0.328% faster)

def test_edge_dict_with_non_string_keys():
    # Should handle dicts with non-string keys
    input_dict = {1: numpy.float32(2.2), (3, 4): numpy.float64(5.5)}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 5.34μs -> 2.53μs (111% faster)

def test_edge_dict_with_numpy_float_key():
    # Should preserve numpy float keys (not convert them)
    input_dict = {numpy.float32(1.1): "value"}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 2.61μs -> 2.09μs (24.5% faster)

# 3. Large Scale Test Cases

def test_large_scale_flat_dict():
    # Should handle large flat dicts efficiently
    input_dict = {f"key_{i}": numpy.float64(i) for i in range(1000)}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 408μs -> 111μs (267% faster)

def test_large_scale_nested_dict():
    # Should handle large nested dicts efficiently
    input_dict = {"outer": {f"inner_{i}": numpy.float32(i) for i in range(1000)}}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 396μs -> 103μs (283% faster)

def test_large_scale_list_of_dicts():
    # Should handle large lists of dicts efficiently
    input_dict = {"list": [{f"k_{i}": numpy.float64(i)} for i in range(1000)]}
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 633μs -> 333μs (90.3% faster)
    for i in range(1000):
        pass

def test_large_scale_mixed_types():
    # Should handle large dicts with mixed types
    input_dict = {
        f"key_{i}": (
            numpy.float32(i),
            [numpy.float64(i + 1), i + 2],
            {"nested": numpy.float32(i + 3)}
        )
        for i in range(1000)
    }
    codeflash_output = _replace_numpy_floats(input_dict); result = codeflash_output # 2.34ms -> 1.29ms (81.2% faster)
    for i in range(1000):
        tup = result[f"key_{i}"]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import numpy
# imports
import pytest  # used for our unit tests
from spacy.language import _replace_numpy_floats
from thinc.util import convert_recursive

# unit tests

# BASIC TEST CASES

def test_basic_single_numpy_float():
    # Test with a single numpy float value
    d = {"a": numpy.float32(1.5)}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 3.12μs -> 2.23μs (39.5% faster)

def test_basic_multiple_numpy_floats():
    # Test with multiple numpy float values
    d = {"a": numpy.float64(2.5), "b": numpy.float32(3.5)}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 3.25μs -> 2.23μs (45.9% faster)

def test_basic_mixed_types():
    # Test with mixed types (int, str, numpy float)
    d = {"a": numpy.float64(2.5), "b": 10, "c": "hello"}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 3.77μs -> 2.50μs (50.7% faster)

def test_basic_nested_dict():
    # Test with nested dictionary containing numpy float
    d = {"a": {"b": numpy.float32(4.5)}}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 3.24μs -> 2.45μs (32.3% faster)

def test_basic_list_of_numpy_floats():
    # Test with a list of numpy floats
    d = {"a": [numpy.float32(1.1), numpy.float64(2.2)]}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 3.80μs -> 2.60μs (45.9% faster)

# EDGE TEST CASES

def test_edge_empty_dict():
    # Test with an empty dictionary
    d = {}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 1.46μs -> 1.47μs (1.15% slower)

def test_edge_no_numpy_floats():
    # Test with a dict containing no numpy floats
    d = {"a": 1, "b": "string", "c": [1, 2, 3]}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 5.00μs -> 3.29μs (52.0% faster)

def test_edge_numpy_ints_should_not_convert():
    # Test with numpy integer types (should NOT convert)
    d = {"a": numpy.int32(5), "b": numpy.int64(10)}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 3.79μs -> 2.86μs (32.5% faster)

def test_edge_tuple_with_numpy_floats():
    # Test with a tuple containing numpy floats
    d = {"a": (numpy.float32(1.2), numpy.float64(3.4))}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 4.58μs -> 3.62μs (26.4% faster)

def test_edge_set_with_numpy_floats():
    # Test with a set containing numpy floats
    d = {"a": set([numpy.float32(2.2), numpy.float64(3.3)])}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 2.42μs -> 1.98μs (22.5% faster)

def test_edge_deeply_nested_structure():
    # Test with deeply nested structures
    d = {
        "a": [
            {"b": (numpy.float32(1.1), {"c": numpy.float64(2.2)})},
            {"d": [numpy.float64(3.3)]}
        ]
    }
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 8.30μs -> 6.28μs (32.3% faster)

def test_edge_numpy_float_in_keys():
    # Test with numpy float as a dictionary key (should not convert keys)
    d = {numpy.float32(1.5): "value"}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 2.63μs -> 1.92μs (36.8% faster)

def test_edge_numpy_float_in_non_dict_container():
    # Test numpy floats in a list at the top level (not inside a dict)
    # Should not be processed, as function expects a dict
    lst = [numpy.float32(1.1), numpy.float64(2.2)]
    with pytest.raises(TypeError):
        _replace_numpy_floats(lst) # 2.97μs -> 2.94μs (0.986% faster)

def test_edge_mutation_safety():
    # Ensure original dict is not mutated
    d = {"a": numpy.float32(7.7)}
    orig = d.copy()
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 2.72μs -> 2.18μs (24.7% faster)

# LARGE SCALE TEST CASES

def test_large_scale_flat_dict():
    # Test with a large flat dictionary of numpy floats
    d = {f"key_{i}": numpy.float64(i * 0.1) for i in range(1000)}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 406μs -> 111μs (263% faster)
    for i in range(1000):
        key = f"key_{i}"

def test_large_scale_nested_dict():
    # Test with a large nested dictionary
    d = {"outer": {f"key_{i}": numpy.float32(i * 0.2) for i in range(500)}}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 199μs -> 53.2μs (275% faster)
    for i in range(500):
        key = f"key_{i}"

def test_large_scale_list_of_dicts():
    # Test with a list of dicts, each containing numpy floats
    d = {"lst": [{f"k{i}": numpy.float64(i)} for i in range(500)]}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 331μs -> 174μs (90.6% faster)
    for i in range(500):
        pass

def test_large_scale_varied_types():
    # Test with a large dict with mixed types
    d = {f"key_{i}": (numpy.float64(i), str(i), i) for i in range(500)}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 647μs -> 353μs (83.0% faster)
    for i in range(500):
        tup = result[f"key_{i}"]

def test_large_scale_performance():
    # Test performance with a large nested structure
    d = {"a": [{"b": numpy.float32(i * 0.5)} for i in range(1000)]}
    codeflash_output = _replace_numpy_floats(d); result = codeflash_output # 635μs -> 335μs (89.1% faster)
    for i in range(1000):
        pass
# 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-_replace_numpy_floats-mhlhxqhu and push.