⚡️ Speed up function sigmoid_stable by 26%

[codeflash-ai]

📄 26% (0.26x) speedup for sigmoid_stable in codeflash/process/infer.py

⏱️ Runtime : 1.78 milliseconds → 1.42 milliseconds (best of 298 runs)

📝 Explanation and details

Here is an optimized version of your sigmoid_stable function. The performance bottleneck is due to repeated calls to np.exp(x) within the np.where function, causing unnecessary recomputation over potentially large arrays.

We'll precompute exp_x = np.exp(x) and exp_neg_x = np.exp(-x) outside of np.where to avoid recomputation and improve cache use. This significantly reduces redundant computation for both branches of the np.where.

Explanation of Changes:

• Precompute both exp_neg_x and exp_x out of np.where to avoid duplicate calculations.
• This reduces two extra expensive np.exp calls down to one each, regardless of input.

This will make the function significantly faster, especially on large arrays. The output is mathematically identical.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 43 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

# ----------------------------
# 1. 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 few positive scalars
    codeflash_output = sigmoid_stable(1.0)
    codeflash_output = sigmoid_stable(2.0)
    codeflash_output = sigmoid_stable(10.0)

def test_sigmoid_negative_scalar():
    # Test a few negative scalars
    codeflash_output = sigmoid_stable(-1.0)
    codeflash_output = sigmoid_stable(-2.0)
    codeflash_output = sigmoid_stable(-10.0)

def test_sigmoid_array_basic():
    # Test a small array of mixed values
    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_large_positive():
    # For large positive values, sigmoid should approach 1.0
    x = 1000.0
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_large_negative():
    # For large negative values, sigmoid should approach 0.0
    x = -1000.0
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_extreme_array():
    # Array with extreme values
    x = np.array([-1000.0, -50.0, 0.0, 50.0, 1000.0])
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    expected = np.array([0.0, 1 / (1 + np.exp(50.0)), 0.5, 1 / (1 + np.exp(-50.0)), 1.0])


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

def test_sigmoid_dtype_preservation():
    # Output should be float64 for float input, float32 for float32 input
    x64 = np.array([0.0, 1.0], dtype=np.float64)
    x32 = np.array([0.0, 1.0], dtype=np.float32)
    codeflash_output = sigmoid_stable(x64); result64 = codeflash_output
    codeflash_output = sigmoid_stable(x32); result32 = codeflash_output

def test_sigmoid_int_input():
    # Should accept integer input and return float output
    x = np.array([-1, 0, 1], dtype=np.int32)
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    expected = 1 / (1 + np.exp(-x))

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

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

def test_sigmoid_large_extreme_array():
    # Array with many extreme values to ensure stability and no overflow
    x = np.concatenate([
        np.full(500, -1000.0),
        np.full(500, 1000.0)
    ])
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_large_random_array():
    # Test with a large array of random floats
    rng = np.random.default_rng(42)
    x = rng.normal(0, 10, 1000)
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    # Spot check a few values for correctness
    for idx in [0, 100, 500, 999]:
        expected = 1 / (1 + np.exp(-x[idx]))
# 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():
    # Sigmoid(2) should be close to 1/(1+exp(-2))
    expected = 1 / (1 + np.exp(-2))

def test_sigmoid_negative_scalar():
    # Sigmoid(-2) should be close to 1/(1+exp(2))
    expected = 1 / (1 + np.exp(2))

def test_sigmoid_small_positive():
    # Test with a small positive value
    expected = 1 / (1 + np.exp(-0.01))

def test_sigmoid_small_negative():
    # Test with a small negative value
    expected = 1 / (1 + np.exp(0.01))

def test_sigmoid_array_basic():
    # Test with a simple array of values
    x = np.array([-1, 0, 1])
    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 should approach 1
    x = 1000
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_large_negative():
    # For large negative x, sigmoid should approach 0
    x = -1000
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_extreme_values_array():
    # Test with array containing extreme values
    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_integer_input():
    # Test with integer input
    x = 5
    expected = 1 / (1 + np.exp(-5))


def test_sigmoid_very_small_values():
    # Test with very small values (close to zero)
    x = np.array([-1e-12, 0, 1e-12])
    expected = 1 / (1 + np.exp(-x))
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_dtype_preservation():
    # Ensure output dtype is float even if input is int
    x = np.array([1, 2, 3], dtype=int)
    codeflash_output = sigmoid_stable(x); result = codeflash_output

# ----------------------
# 3. 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_extreme_array():
    # Test with a large array including extreme values
    x = np.concatenate([np.linspace(-1000, -500, 250), np.linspace(-5, 5, 500), np.linspace(500, 1000, 250)])
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    # For x << 0, sigmoid ~ 0; for x >> 0, sigmoid ~ 1; for midrange, compute exactly
    expected = np.where(x < -20, 0.0, np.where(x > 20, 1.0, 1 / (1 + np.exp(-x))))

def test_sigmoid_performance_large_random():
    # Test with a large random array (performance and correctness)
    rng = np.random.default_rng(seed=42)
    x = rng.normal(loc=0, scale=100, size=1000)
    codeflash_output = sigmoid_stable(x); result = codeflash_output
    # For very large positive/negative, expected is 1/0; else compute exactly
    expected = np.where(x < -20, 0.0, np.where(x > 20, 1.0, 1 / (1 + np.exp(-x))))

# ----------------------
# Additional Robustness Cases
# ----------------------

def test_sigmoid_shape_preservation():
    # Output shape should match input shape
    x = np.random.randn(10, 10)
    codeflash_output = sigmoid_stable(x); result = codeflash_output

def test_sigmoid_scalar_vs_array_consistency():
    # Scalar and array input for same value should yield same result
    for val in [-10, 0, 10]:
        codeflash_output = sigmoid_stable(val); scalar_res = codeflash_output
        array_res = sigmoid_stable(np.array([val]))[0]

def test_sigmoid_object_input_raises():
    # Non-numeric input should raise an error
    with pytest.raises(TypeError):
        sigmoid_stable("not a number")
# 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-mdf1ifk6 and push.