⚡️ Speed up function sigmoid_stable by 232%

[codeflash-ai]

📄 232% (2.32x) speedup for sigmoid_stable in codeflash/process/infer.py

⏱️ Runtime : 1.77 milliseconds → 532 microseconds (best of 631 runs)

📝 Explanation and details

Here is an optimized version of your function. The original code computes np.exp(x) twice for the x < 0 case. To optimize, we can precompute the exponent, reducing redundant computation.

This computes np.exp(-np.abs(x)) once and reuses it for both cases, improving speed and efficiency for large arrays.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import numpy as np
# imports
import pytest  # used for our unit tests
from codeflash.process.infer import sigmoid_stable

# unit tests

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

def test_sigmoid_zero():
    # Sigmoid(0) should be exactly 0.5
    codeflash_output = sigmoid_stable(0.0)

def test_sigmoid_positive_scalar():
    # Test a basic positive scalar input
    x = 1.0
    expected = 1 / (1 + np.exp(-1.0))

def test_sigmoid_negative_scalar():
    # Test a basic negative scalar input
    x = -1.0
    expected = 1 / (1 + np.exp(1.0))

def test_sigmoid_small_array():
    # Test a small array of mixed values
    x = np.array([-1.0, 0.0, 1.0])
    expected = 1 / (1 + np.exp(-x))

def test_sigmoid_list_input():
    # Test that list input is handled correctly (should be converted to numpy array)
    x = [-2, 0, 2]
    expected = 1 / (1 + np.exp(-np.array(x)))
    codeflash_output = sigmoid_stable(np.array(x)); result = codeflash_output

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

def test_sigmoid_large_positive():
    # Test very large positive input (should approach 1.0)
    x = 1000
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    # Should not overflow

def test_sigmoid_large_negative():
    # Test very large negative input (should approach 0.0)
    x = -1000
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    # Should not underflow

def test_sigmoid_inf():
    # Test np.inf and -np.inf
    pos_inf = np.inf
    neg_inf = -np.inf
    codeflash_output = sigmoid_stable(pos_inf)
    codeflash_output = sigmoid_stable(neg_inf)

def test_sigmoid_nan():
    # Test np.nan input (should return nan)
    nan_val = np.nan
    codeflash_output = sigmoid_stable(nan_val); result = codeflash_output

def test_sigmoid_array_inf_nan():
    # Test array with inf, -inf, and nan
    x = np.array([-np.inf, -100, 0, 100, np.inf, np.nan])
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    # -inf -> 0, inf -> 1, nan -> nan, 0 -> 0.5, others standard
    expected = np.array([0.0, 1/(1+np.exp(100)), 0.5, 1/(1+np.exp(-100)), 1.0, np.nan])

def test_sigmoid_dtype_preservation():
    # The output dtype should be float64 for float inputs
    x = np.array([0, 1, -1], dtype=np.float32)
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_integer_input():
    # Integer input should be handled and output should be float
    x = 2
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    expected = 1 / (1 + np.exp(-2))

def test_sigmoid_empty_array():
    # Empty input should return an empty array
    x = np.array([])
    codeflash_output = sigmoid_stable(x); result = codeflash_output

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

def test_sigmoid_large_array():
    # Test with a large array of values
    x = np.linspace(-10, 10, 1000)
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    expected = 1 / (1 + np.exp(-x))

def test_sigmoid_large_extremes_array():
    # Test with a large array of extreme values
    x = np.concatenate([np.full(500, -1000), np.full(500, 1000)])
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_performance_large_random():
    # Test with a large random array for performance and correctness
    rng = np.random.default_rng(seed=42)
    x = rng.uniform(-20, 20, size=1000)
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    expected = 1 / (1 + np.exp(-x))

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

def test_sigmoid_object_array():
    # Test object dtype array (should raise or handle gracefully)
    x = np.array([1, 'a', None], dtype=object)
    with pytest.raises(TypeError):
        sigmoid_stable(x)


def test_sigmoid_multidimensional_array():
    # Test 2D array input
    x = np.array([[-1, 0], [1, 2]])
    expected = 1 / (1 + np.exp(-x))
    codeflash_output = sigmoid_stable(x); 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 codeflash.process.infer import sigmoid_stable


def test_sigmoid_positive_scalar():
    # Test a positive scalar input
    val = 2.0
    expected = 1 / (1 + np.exp(-val))

def test_sigmoid_negative_scalar():
    # Test a negative scalar input
    val = -2.0
    expected = 1 / (1 + np.exp(-val))

def test_sigmoid_vector_basic():
    # Test a vector of small positive and negative numbers
    x = np.array([-1.0, 0.0, 1.0])
    expected = 1 / (1 + np.exp(-x))
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_matrix_basic():
    # Test a 2D array input
    x = np.array([[-1.0, 0.0], [1.0, 2.0]])
    expected = 1 / (1 + np.exp(-x))
    codeflash_output = sigmoid_stable(x); result = codeflash_output

# --------------------
# 2. Edge Test Cases
# --------------------

def test_sigmoid_large_positive():
    # For large positive x, sigmoid(x) should approach 1
    x = np.array([100, 500, 1000])
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_large_negative():
    # For large negative x, sigmoid(x) should approach 0
    x = np.array([-100, -500, -1000])
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_extreme_values():
    # Test both large positive and negative in the same array
    x = np.array([-1000, 0, 1000])
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    expected = np.array([0.0, 0.5, 1.0])

def test_sigmoid_inf_nan():
    # Test inf, -inf, and nan
    x = np.array([np.inf, -np.inf, np.nan])
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_dtype_preserved():
    # Test that output dtype matches input dtype
    x = np.array([0.0, 1.0, -1.0], dtype=np.float32)
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_empty_array():
    # Test empty array input
    x = np.array([])
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_broadcasting():
    # Test broadcasting for mixed shape inputs
    x = np.array([[0, 1], [-1, -2]])
    expected = 1 / (1 + np.exp(-x))
    codeflash_output = sigmoid_stable(x); result = codeflash_output

# --------------------
# 3. Large Scale Test Cases
# --------------------

def test_sigmoid_large_vector():
    # Test a large vector of random values
    rng = np.random.default_rng(42)
    x = rng.normal(size=1000)
    expected = 1 / (1 + np.exp(-x))
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_large_extremes():
    # Test a large vector with extreme values
    x = np.linspace(-1000, 1000, 1000)
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_large_matrix():
    # Test a large 2D array
    rng = np.random.default_rng(123)
    x = rng.uniform(-10, 10, size=(100, 10))
    expected = 1 / (1 + np.exp(-x))
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_performance_large_input():
    # Test that function does not raise or hang with large input
    x = np.linspace(-20, 20, 1000)
    codeflash_output = sigmoid_stable(x); result = codeflash_output

# --------------------
# 4. Additional Robustness Tests
# --------------------

def test_sigmoid_object_array_raises():
    # Should raise TypeError if input is not numeric
    x = np.array(['a', 'b', 'c'], dtype=object)
    with pytest.raises(TypeError):
        sigmoid_stable(x)

def test_sigmoid_list_input():
    # Should handle Python list input via np.array conversion
    x = [0, 1, -1]
    expected = 1 / (1 + np.exp(-np.array(x)))
    codeflash_output = sigmoid_stable(np.array(x)); 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.

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup

To edit these changes git checkout codeflash/optimize-sigmoid_stable-mde2nmmj and push.