conf_interval() occasionally fails with "f(a) and f(b) must have different signs" when run concurrently

[AlexHelloWorld]

I'm using lmfit.Model for fitting a 4-parameter logistic (4PL) model and calling conf_interval() after fitting to get confidence interval estimation. When I ran this concurrently, some threads raised the following error during confidence interval estimation

ValueError: f(a) and f(b) must have different signs, but f(-2.402492e+00)=-6.970775e-02, f(5.950746e-01)=-9.500000e-01

The error is intermittent: only some threads fail, and the rest produce identical results.

Observations:

• The failure always occurs inside .conf_interval(), not .fit().
• Running the same logic serially (one thread at a time) does not produce any error.
• My best guess is that concurrent execution introduces small numerical variations which are just enough to break the root-finding step inside conf_interval()

Minimal Repro Example:

from lmfit import Model
import numpy as np
import pandas as pd
from scipy import stats
from scipy.stats import linregress
from concurrent.futures import ThreadPoolExecutor

Y_COLUMN = "yValues"
X_COLUMN = "log_xValues"


def equation(
    x_values: np.ndarray, min: float, max: float, log_inflection_point: float, hill_slope: float
) -> np.ndarray:
    """General 4PL regression equation.
    """
    return min + (max - min) / (1.0 + 10.0 ** ((log_inflection_point - x_values) * hill_slope))


def _guess_initial_parameters(dataframe: pd.DataFrame) -> list[float]:
    data_summary = dataframe.describe()

    linear_regression_slope = linregress(dataframe[X_COLUMN], dataframe[Y_COLUMN]).slope
    initial_slope = 1 if linear_regression_slope >= 0 else -1

    return [
        data_summary[Y_COLUMN]["min"],  # min
        data_summary[Y_COLUMN]["max"],  # max
        np.log10(data_summary[X_COLUMN]["mean"]),  # inflection_point
        initial_slope,  # hill_slope
    ]


def calculate_conf_interval(dataframe):
    initial_params = _guess_initial_parameters(dataframe)
    model = Model(equation)
    parameters = model.make_params()
    parameters.add("min", value=initial_params[0])
    parameters.add("max", value=initial_params[1])
    parameters.add("log_inflection_point", value=initial_params[2])
    parameters.add("hill_slope", value=initial_params[3])

    max_num_function_evals = (dataframe.shape[0] + 1) * 50
    results = model.fit(
        dataframe["yValues"].to_numpy(),
        x_values=dataframe["log_xValues"].to_numpy(),
        params=parameters,
        method="least_squares",
        max_nfev=max_num_function_evals,
    )

    confidence_interval = 0.95
    ppf_lookup = 1 - ((1 - confidence_interval) / 2)
    z_score = stats.norm.ppf(ppf_lookup)
    return results.conf_interval(sigmas=[z_score])

dataframe = pd.DataFrame(
    {
        "xValues": [1.0, 32.0, 2.0, 4.0, 8.0, 16.0],
        "yValues": [
            0.5662811,
            1.660522548333333,
            0.7189390766666666,
            0.8275612533333333,
            1.1556886833333333,
            1.5709728833333332,
        ],
    }
)
dataframe["log_xValues"] = dataframe["xValues"].apply(np.log10)

with ThreadPoolExecutor() as executor:
    results = list(executor.map(calculate_conf_interval, [dataframe] * 10))

Questions

Is conf_interval() expected to be thread-safe? Any suggestions on how to mitigate this issue?

Thank you!

[newville]

@AlexHelloWorld I can certainly believe that conf_interval() is not thread safe. It will call scipy.optimize.leastsq() many times, and that is probably not thread-safe.

Using multiple processes is probably safer. I would generally not assume that multi-threading was useful for numerically intensive work in Python.