⚡️ Speed up function get_bin_boundaries by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for get_bin_boundaries in keras/src/layers/preprocessing/discretization.py

⏱️ Runtime : 964 microseconds → 898 microseconds (best of 172 runs)

📝 Explanation and details

Certainly! Here are specific optimizations to your code for speed and memory.

1. Remove unnecessary duplication of work (e.g., calculate cumulative weights only once).
2. Use in-place or less-allocating NumPy operations.
3. Skip certain Python abstractions for less overhead.
4. Minor efficiency in concatenation by using np.empty and assignment.

Major optimizations:

• Avoided extra allocation when differencing weights.
• Avoided recomputing values, weights, cumsums, etc.
• Typed arrays upfront as 'float32' in-place, reducing copying.

Comments are unchanged except to clarify the sections with performance changes.
This is as fast and memory-efficient as can be with vectorized NumPy. For further speed, a cython/C implementation is needed.

✅ 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 Details

import numpy as np
# imports
import pytest  # used for our unit tests
from keras.src.layers.preprocessing.discretization import get_bin_boundaries

# ------------------------
# Unit Tests for get_bin_boundaries
# ------------------------

# BASIC TEST CASES

def test_uniform_bins():
    # Test with uniform bin edges and weights
    # 5 bins: values 0,1,2,3,4, weights all 1
    summary = np.array([
        [0, 1, 2, 3, 4],
        [1, 1, 1, 1, 1]
    ])
    num_bins = 2
    # Should split at the median (value=2)
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

def test_nonuniform_weights():
    # Test with non-uniform weights
    summary = np.array([
        [0, 1, 2, 3, 4],
        [1, 2, 1, 3, 3]
    ])
    num_bins = 3
    # The boundaries should split the cumulative weight into thirds
    # Cumulative weights: 1,3,4,7,10
    # Total weight = 10, thirds at 10/3 ~3.33 and 6.66
    # First boundary: between 1 (3) and 2 (4), interpolate at (3.33-3)/(4-3) = 0.33, so at 1+0.33=1.33
    # Second boundary: between 3 (7) and 4 (10), interpolate at (6.66-7)/(10-7) = -0.11, so at 3-0.33=2.67
    # But since np.interp is used, let's compute expected values using np.interp
    cum_weights = np.cumsum(summary[1])
    cum_weight_percents = cum_weights / cum_weights[-1]
    percents = 1/3 + np.arange(0.0, 1.0, 1/3)
    expected = np.interp(percents, cum_weight_percents, summary[0])
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

def test_single_bin():
    # Only one bin requested, should return empty array
    summary = np.array([
        [0, 1, 2, 3, 4],
        [1, 1, 1, 1, 1]
    ])
    num_bins = 1
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

def test_minimal_summary():
    # Summary with only two points
    summary = np.array([
        [0, 10],
        [2, 8]
    ])
    num_bins = 2
    # The boundary should be at the weighted median
    # Cumulative weights: 2,10. Total=10, median at 5
    # The boundary is at value where cumulative weight = 5
    # Linear interpolation: (5-2)/(10-2) = 3/8, so at 0+3/8*(10-0)=3.75
    expected = [3.75]
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

def test_non_integer_bin_count():
    # Should work for num_bins that doesn't divide the weight evenly
    summary = np.array([
        [0, 1, 2, 3, 4],
        [1, 1, 1, 1, 1]
    ])
    num_bins = 4
    # Boundaries at 1,2,3
    expected = [1., 2., 3.]
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

# EDGE TEST CASES


def test_single_value_summary():
    # Only one value in summary
    summary = np.array([
        [5],
        [10]
    ])
    num_bins = 2
    # All data in one bin, so boundaries are all at 5
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

def test_large_weights():
    # Test with very large weights
    summary = np.array([
        [0, 1, 2, 3, 4],
        [1e6, 2e6, 1e6, 3e6, 3e6]
    ])
    num_bins = 3
    # Should not overflow or error
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output



def test_non_increasing_values():
    # Test with non-increasing values
    summary = np.array([
        [0, 2, 1, 3],  # not sorted
        [1, 1, 1, 1]
    ])
    num_bins = 2
    # Should interpolate as per input, but in practice, this is a user error
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

def test_num_bins_greater_than_points():
    # More bins than data points
    summary = np.array([
        [0, 1, 2],
        [1, 1, 1]
    ])
    num_bins = 5  # 2 more bins than points
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

def test_num_bins_zero():
    # num_bins is zero
    summary = np.array([
        [0, 1, 2],
        [1, 1, 1]
    ])
    num_bins = 0
    with pytest.raises(ZeroDivisionError):
        get_bin_boundaries(summary, num_bins)


def test_large_uniform_summary():
    # Large summary, uniform weights
    n = 1000
    summary = np.array([
        np.linspace(0, 100, n),
        np.ones(n)
    ])
    num_bins = 10
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output
    # Boundaries should be close to multiples of 10
    expected = np.linspace(0, 100, 11)[1:-1]

def test_large_skewed_weights():
    # Large summary, skewed weights
    n = 1000
    values = np.linspace(0, 100, n)
    weights = np.linspace(1, 1000, n)
    summary = np.array([values, weights])
    num_bins = 10
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

def test_large_random_weights():
    # Large summary, random weights
    np.random.seed(42)
    n = 1000
    values = np.sort(np.random.uniform(0, 100, n))
    weights = np.random.randint(1, 10, n)
    summary = np.array([values, weights])
    num_bins = 20
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

def test_large_sparse_weights():
    # Large summary, many zero weights, but some nonzero
    n = 1000
    values = np.linspace(0, 100, n)
    weights = np.zeros(n)
    weights[::100] = 100  # every 100th value has weight
    summary = np.array([values, weights])
    num_bins = 10
    # Should not error, but will raise ZeroDivisionError if all weights zero
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

def test_performance_large_scale():
    # Test performance/scalability for large n and bins
    n = 1000
    summary = np.array([
        np.linspace(0, 1000, n),
        np.ones(n)
    ])
    num_bins = 100
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

# Additional edge: test for dtype preservation (should be float32)
def test_output_dtype():
    summary = np.array([
        [0, 1, 2, 3, 4],
        [1, 1, 1, 1, 1]
    ])
    num_bins = 2
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

# Additional edge: test for summary with float values and weights
def test_float_values_and_weights():
    summary = np.array([
        [0.1, 1.5, 2.7, 3.9, 4.2],
        [1.2, 0.8, 1.7, 2.3, 1.0]
    ])
    num_bins = 3
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output

# Additional edge: test for summary with negative values
def test_negative_values():
    summary = np.array([
        [-5, -2, 0, 3, 7],
        [1, 2, 3, 2, 1]
    ])
    num_bins = 3
    codeflash_output = get_bin_boundaries(summary, num_bins); result = codeflash_output
# 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 keras.src.layers.preprocessing.discretization import get_bin_boundaries

# unit tests

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

def test_single_bin_returns_no_boundaries():
    # 1 bin: should return empty array (no boundaries between bins)
    summary = np.array([[0, 1], [1, 1]])
    codeflash_output = get_bin_boundaries(summary, 1); result = codeflash_output

def test_two_bins_equally_spaced():
    # Two bins: expect single boundary at the median
    summary = np.array([[0, 1], [1, 1]])
    # Bin boundaries should be at the midpoint (0.5)
    codeflash_output = get_bin_boundaries(summary, 2); result = codeflash_output

def test_three_bins_unequal_weights():
    # Three bins, uneven weights
    summary = np.array([[0, 2, 4], [1, 2, 1]])
    # Should create two boundaries: one after 25% of total weight, one after 50%
    codeflash_output = get_bin_boundaries(summary, 3); result = codeflash_output

def test_uniform_weights_and_values():
    # Uniform weights, evenly spaced values
    summary = np.array([[0, 1, 2, 3], [1, 1, 1, 1]])
    codeflash_output = get_bin_boundaries(summary, 4); result = codeflash_output
    # Boundaries should be at 0.75, 1.5, 2.25
    expected = [0.75, 1.5, 2.25]

def test_non_uniform_weights():
    # Non-uniform weights
    summary = np.array([[1, 2, 3, 4], [1, 3, 1, 5]])
    codeflash_output = get_bin_boundaries(summary, 3); result = codeflash_output

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


def test_single_value_summary():
    # Only one value in summary: no boundaries possible
    summary = np.array([[5], [10]])
    codeflash_output = get_bin_boundaries(summary, 2); result = codeflash_output

def test_large_num_bins_more_than_summary_points():
    # More bins than summary points: should interpolate and not error
    summary = np.array([[1, 2, 3], [1, 2, 1]])
    codeflash_output = get_bin_boundaries(summary, 10); result = codeflash_output



def test_non_integer_weights():
    # Non-integer weights: should work fine
    summary = np.array([[0, 1, 2], [0.5, 1.5, 2.0]])
    codeflash_output = get_bin_boundaries(summary, 2); result = codeflash_output

def test_non_monotonic_values():
    # Values not strictly increasing: should interpolate but not error
    summary = np.array([[1, 3, 2], [1, 1, 1]])
    codeflash_output = get_bin_boundaries(summary, 2); result = codeflash_output

def test_num_bins_equals_summary_points():
    # Number of bins equals number of summary points
    summary = np.array([[0, 2, 4, 6], [1, 1, 1, 1]])
    codeflash_output = get_bin_boundaries(summary, 4); result = codeflash_output

def test_num_bins_is_zero():
    # Zero bins: should raise error
    summary = np.array([[0, 1], [1, 1]])
    with pytest.raises(ZeroDivisionError):
        get_bin_boundaries(summary, 0)


def test_large_summary_and_bins():
    # Large summary (1000 points), 100 bins
    values = np.linspace(0, 100, 1000)
    weights = np.ones(1000)
    summary = np.stack((values, weights))
    codeflash_output = get_bin_boundaries(summary, 100); result = codeflash_output

def test_large_summary_nonuniform_weights():
    # Large summary with non-uniform weights
    values = np.linspace(0, 50, 500)
    weights = np.linspace(1, 10, 500)
    summary = np.stack((values, weights))
    codeflash_output = get_bin_boundaries(summary, 50); result = codeflash_output

def test_large_num_bins_small_summary():
    # Large number of bins, small summary
    summary = np.array([[0, 1, 2], [1, 2, 1]])
    codeflash_output = get_bin_boundaries(summary, 999); result = codeflash_output

def test_performance_large_scale(monkeypatch):
    # Test that function completes quickly for large input
    values = np.linspace(0, 1000, 1000)
    weights = np.ones(1000)
    summary = np.stack((values, weights))
    import time
    start = time.time()
    codeflash_output = get_bin_boundaries(summary, 100); result = codeflash_output
    elapsed = time.time() - start

# --------- ADDITIONAL EDGE CASES ---------


def test_summary_with_nan_values():
    summary = np.array([[1, np.nan, 3], [1, 1, 1]])
    codeflash_output = get_bin_boundaries(summary, 2); result = codeflash_output

def test_summary_with_inf_weights():
    summary = np.array([[1, 2, 3], [1, np.inf, 1]])
    codeflash_output = get_bin_boundaries(summary, 2); result = codeflash_output

def test_summary_with_duplicate_values():
    summary = np.array([[1, 1, 2, 3], [1, 1, 1, 1]])
    codeflash_output = get_bin_boundaries(summary, 2); result = codeflash_output
# 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_bin_boundaries-maxhmx4x and push.