⚡️ Speed up method Discretization.from_config by 12%

[codeflash-ai]

📄 12% (0.12x) speedup for Discretization.from_config in keras/src/layers/preprocessing/discretization.py

⏱️ Runtime : 4.70 milliseconds → 4.18 milliseconds (best of 790 runs)

📝 Explanation and details

Here is a rewrite of your program with runtime and memory optimizations, preserving all function signatures, logic, and behavior. The key improvements focus on.

• Short-circuiting checks: Reduce conditional nesting and repetition.
• Avoid repeated backend.backend() and tuple lookups.
• Minimize attribute lookups and repeated code in from_config.
• Pre-validate types and combinations for early error detection.
• Efficient initialization and copy.

All docstrings and comments are preserved as required.

Key Optimizations Recap:

• Minimized nested ifs and reduced code repetition.
• Used direct value checks (is not None) for clarity and speed.
• Avoided ambiguous empty-list truth tests.
• Avoided repeated backend attribute lookups.
• Used np.empty for self.summary for slightly less overhead.
• Used local vars for dict items to minimize lookup cost, especially in from_config.

This will run strictly faster, especially for repeated instantiations/config deserializations, while producing the exact same results and errors as the original code.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

import pytest
from keras.src.layers.preprocessing.discretization import Discretization

# function to test (already provided above)
# from_config is a @classmethod of Discretization

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

def test_from_config_with_bin_boundaries_only():
    # Test basic restoration with bin_boundaries
    config = {
        "bin_boundaries": [0.0, 1.0, 2.0],
        "num_bins": None,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": False,
        "dtype": "int64",
        "name": "test_layer",
    }
    codeflash_output = Discretization.from_config(config); layer = codeflash_output

def test_from_config_with_num_bins_only():
    # Test basic restoration with num_bins
    config = {
        "bin_boundaries": None,
        "num_bins": 4,
        "epsilon": 0.05,
        "output_mode": "one_hot",
        "sparse": True,
        "dtype": "float32",
        "name": "num_bins_layer",
    }
    codeflash_output = Discretization.from_config(config); layer = codeflash_output

def test_from_config_with_default_dtype_and_output_mode():
    # Test that dtype defaults correctly when not provided
    config = {
        "bin_boundaries": [0.0, 2.0],
        "num_bins": None,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": False,
        "name": "default_dtype_layer",
    }
    # Remove dtype from config to test defaulting
    codeflash_output = Discretization.from_config(config); layer = codeflash_output

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

def test_from_config_with_both_bin_boundaries_and_num_bins():
    # Test restoration when both bin_boundaries and num_bins are present
    config = {
        "bin_boundaries": [0.0, 1.0, 2.0],
        "num_bins": 4,
        "epsilon": 0.01,
        "output_mode": "multi_hot",
        "sparse": False,
        "dtype": "float32",
        "name": "both_layer",
    }
    # Should restore and set bin_boundaries after construction
    codeflash_output = Discretization.from_config(config); layer = codeflash_output

def test_from_config_with_empty_bin_boundaries():
    # Test with empty bin_boundaries
    config = {
        "bin_boundaries": [],
        "num_bins": None,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": False,
        "dtype": "int64",
        "name": "empty_bin_layer",
    }
    codeflash_output = Discretization.from_config(config); layer = codeflash_output

def test_from_config_with_zero_num_bins():
    # Test with num_bins=0 (should be allowed, but may not be useful)
    config = {
        "bin_boundaries": None,
        "num_bins": 0,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": False,
        "dtype": "int64",
        "name": "zero_bin_layer",
    }
    codeflash_output = Discretization.from_config(config); layer = codeflash_output

def test_from_config_with_invalid_output_mode():
    # Test with invalid output_mode
    config = {
        "bin_boundaries": [0.0],
        "num_bins": None,
        "epsilon": 0.01,
        "output_mode": "invalid_mode",
        "sparse": False,
        "dtype": "int64",
        "name": "invalid_output_mode_layer",
    }
    with pytest.raises(ValueError):
        Discretization.from_config(config)

def test_from_config_with_sparse_true_and_int_mode():
    # Test with sparse=True and output_mode="int" (should fail)
    config = {
        "bin_boundaries": [0.0],
        "num_bins": None,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": True,
        "dtype": "int64",
        "name": "sparse_int_layer",
    }
    with pytest.raises(ValueError):
        Discretization.from_config(config)

def test_from_config_with_no_bin_boundaries_and_num_bins():
    # Test with neither bin_boundaries nor num_bins set (should fail)
    config = {
        "bin_boundaries": None,
        "num_bins": None,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": False,
        "dtype": "int64",
        "name": "no_bins_layer",
    }
    with pytest.raises(ValueError):
        Discretization.from_config(config)

def test_from_config_with_negative_num_bins():
    # Test with negative num_bins (should fail)
    config = {
        "bin_boundaries": None,
        "num_bins": -1,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": False,
        "dtype": "int64",
        "name": "negative_bins_layer",
    }
    with pytest.raises(ValueError):
        Discretization.from_config(config)

def test_from_config_with_extra_keys_in_config():
    # Test that extra keys in config are ignored or cause error if not in __init__
    config = {
        "bin_boundaries": [0.0, 1.0],
        "num_bins": None,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": False,
        "dtype": "int64",
        "name": "extra_keys_layer",
        "extra_key": 123,
    }
    # Should raise TypeError due to unexpected keyword argument
    with pytest.raises(TypeError):
        Discretization.from_config(config)

def test_from_config_with_non_list_bin_boundaries():
    # Test with bin_boundaries as a tuple (should work as __init__ only checks for None)
    config = {
        "bin_boundaries": (0.0, 1.0, 2.0),
        "num_bins": None,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": False,
        "dtype": "int64",
        "name": "tuple_bin_boundaries_layer",
    }
    codeflash_output = Discretization.from_config(config); layer = codeflash_output

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

def test_from_config_large_bin_boundaries():
    # Test with a large number of bin boundaries (up to 999)
    large_bins = [float(i) for i in range(999)]
    config = {
        "bin_boundaries": large_bins,
        "num_bins": None,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": False,
        "dtype": "int64",
        "name": "large_bin_layer",
    }
    codeflash_output = Discretization.from_config(config); layer = codeflash_output

def test_from_config_large_num_bins():
    # Test with a large num_bins value
    config = {
        "bin_boundaries": None,
        "num_bins": 999,
        "epsilon": 0.01,
        "output_mode": "one_hot",
        "sparse": False,
        "dtype": "float32",
        "name": "large_num_bins_layer",
    }
    codeflash_output = Discretization.from_config(config); layer = codeflash_output

def test_from_config_large_config_dict():
    # Test with a config dict with many keys, only the correct ones should be used
    config = {
        "bin_boundaries": [0.0, 1.0],
        "num_bins": None,
        "epsilon": 0.01,
        "output_mode": "int",
        "sparse": False,
        "dtype": "int64",
        "name": "large_config_layer",
    }
    # Add 990 extra irrelevant keys
    for i in range(990):
        config[f"irrelevant_{i}"] = i
    # Should raise TypeError due to unexpected keyword arguments
    with pytest.raises(TypeError):
        Discretization.from_config(config)

def test_from_config_large_and_both_bin_boundaries_and_num_bins():
    # Test with both large bin_boundaries and num_bins (should use special logic)
    large_bins = [float(i) for i in range(500)]
    config = {
        "bin_boundaries": large_bins,
        "num_bins": 500,
        "epsilon": 0.01,
        "output_mode": "multi_hot",
        "sparse": False,
        "dtype": "float32",
        "name": "large_both_layer",
    }
    codeflash_output = Discretization.from_config(config); layer = 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 pytest  # used for our unit tests
from keras.src.layers.preprocessing.discretization import Discretization

# 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-Discretization.from_config-maxh7d8z and push.