Skip to main content
`Ctrl`+`K`

# Wrapping an existing model

SALib performs sensitivity analysis for any model that can be expressed in the form of \(f(X) = Y\), where \(X\) is a matrix of inputs (often referred to as the model’s factors).

The analysis methods are independent of the model and can be applied non-intrusively such that it does not matter what \(f\) is.

Typical model implementations take the form of \(f(a, b, c, ...) = Y\). In other words, each model factor is supplied as a separate argument to the function. In such cases it is necessary to write a wrapper to allow use with SALib. This is illustrated here with a simple linear function:

    def linear(a, b, x):
        """Return y = a + b + x"""
        return a + b + x

As SALib expects a (numpy) matrix of factors, we simply “wrap” the function above like so:

    def wrapped_linear(X, func=linear):
        """g(X) = Y, where X := [a b x] and g(X) := f(X)"""
        # We transpose to obtain each column (the model factors) as separate variables
        a, b, x = X.T

        # Then call the original model
        return func(a, b, x)

Note

Wrapped function is an argument

Note here that the model being “wrapped” is also passed in as an argument. This will be revisited further down below.

Tip

Interfacing with external models/programs

Here we showcase interacting with models written in Python. If the model is an external program, this is where interfacing code would be written.

A pragmatic approach could be to use subprocess to start the external program, then read in the results.

Constants, which SALib should not consider, can be expressed by defining default keyword arguments (for flexibility) or otherwise defined within the wrapper function itself.

    def wrapped_linear_w_constant(X, a=10, func=linear):
        """f(X, a) = Y, where X := [b x] and a = 10"""
        # We transpose to obtain each column as separate variables
        b, x = X.T

        # Then call the original model
        return func(a, b, x)

Note that the first argument to any function provided to SALib is assumed to be a numpy array of shape \(N*D\), where \(D\) is the number of model factors (dimensions) and \(N\) is the number of their combinations. The argument name is, by convention, denoted as `X`. This is to maximize compatibility with all methods provided in SALib as they expect the first argument to hold the model factor values. Using `functools.partial()` from the functools package to create wrappers can be useful.

In this example, the model (`linear()`) can be used with both scalar inputs or numpy arrays. In cases where a, b or x are a vector of inputs, numpy will automatically vectorize the calculation. There are many cases where the model is not (or cannot be easily) expressed in a vectorizable form. In such cases, simply apply a `for` loop as in the example below.

    import numpy as np
    from SALib import ProblemSpec

    def linear(a: float, b: float, x: float) -> float:
        return a + b * x

    def wrapped_linear(X: np.ndarray, func=linear) -> np.ndarray:
        N, D = X.shape
        results = np.empty(N)
        for i in range(N):
            a, b, x = X[i, :]
            results[i] = func(a, b, x)

        return results

    sp = ProblemSpec({
        'names': ['a', 'b', 'x'],
        'bounds': [
            [-1, 0],
            [-1, 0],
            [-1, 1],
        ],
    })

    (
        sp.sample_sobol(2**6)
        .evaluate(wrapped_linear)
        .analyze_sobol()
    )

    sp.to_df()

    # [         ST   ST_conf
    #  a  0.173636  0.072142
    #  b  0.167933  0.059599
    #  x  0.654566  0.208328,
    #           S1   S1_conf
    #  a  0.182788  0.111548
    #  b  0.179003  0.145714
    #  x  0.664727  0.241977,
    #                S2   S2_conf
    #  (a, b) -0.022070  0.185510
    #  (a, x) -0.010781  0.186743
    #  (b, x) -0.014616  0.279925]

Use of the core SALib functions equivalent to the previous example are shown below:

    problem = {
        'names': ['a', 'b', 'x'],
        'bounds': [
            [-1, 0],
            [-1, 0],
            [-1, 1],
        ],
        'num_vars': 3
    }

    X = saltelli.sample(problem, 64)
    Y = np.empty(params.shape[0])
    for i in range(params.shape[0]):
        Y[i] = wrapped_linear(params[i, :])

    res = sobol.analyze(problem, Y)
    res.to_df()

    # [         ST   ST_conf
    #  a  0.165854  0.054096
    #  b  0.165854  0.053200
    #  x  0.665366  0.192756,
    #           S1   S1_conf
    #  a  0.167805  0.121550
    #  b  0.167805  0.125178
    #  x  0.665366  0.230872,
    #                    S2   S2_conf
    #  (a, b) -2.775558e-17  0.180493
    #  (a, x) -3.902439e-03  0.202343
    #  (b, x) -3.902439e-03  0.232957]

## Parallel evaluation and analysis

Here we expand on some technical details that enable parallel evaluation and analysis. We noted earlier that the model being “wrapped” is also passed in as an argument. This is to facilitate parallel evaluation, as the arguments to the wrapper are passed on to workers. The approach works be using Python’s mutable default argument behavior.

A further consideration is that imported modules/packages are not made available to workers in cases where functions are defined in the same file SALib is used in. Running the previous example with `.evaluate(wrapped_linear, nprocs=2)` will fail with `NameError: name 'np' is not defined`.

The quick fix is to re-import the required packages within the model function itself:

    def wrapped_linear(X: np.ndarray, func=linear) -> np.ndarray:
        import numpy as np  # re-import necessary packages

        N, D = X.shape
        results = np.empty(N)
        for i in range(N):
            a, b, x = X[i, :]
            results[i] = func(a, b, x)

        return results

This can, however, get unwieldy for complicated models. The recommended best practice is to separate implementation (i.e., model definitions) from its use. Simply moving the model functions into a separate file is enough for this example, such that the project structure is something like:

    project_directory
    |-- model_definition.py
    └── analysis.py

Tip

Project structure

The project structure shown above is for example purposes only. It is highly recommended that a standardized directory structure, such as drivendata/cookiecutter-data-science, be adopted to improve usability and reproducibility.

Here, `model_definitions.py` holds the model definitions:

    import numpy as np

    def linear(a: float, b: float, x: float) -> float:
        return a + b * x

    def wrapped_linear(X: np.ndarray, func=linear) -> np.ndarray:
        N, D = X.shape
        results = np.empty(N)
        for i in range(N):
            a, b, x = X[i, :]
            results[i] = func(a, b, x)

        return results

and `analysis.py` contains use of SALib:

    from model_definition import wrapped_linear

    sp = ProblemSpec({
        'names': ['a', 'b', 'x'],
        'bounds': [
            [-1, 0],
            [-1, 0],
            [-1, 1],
        ],
    })

    (
        sp.sample_sobol(2**6)
        .evaluate(wrapped_linear, nprocs=2)
        .analyze_sobol(nprocs=2)
    )

Note

Multi-processing

Some interactive Python consoles, including earlier versions of IPython, may appear to hang on Windows when utilizing parallel evaluation and analysis. In such cases, the recommended workaround is to wrap use of SALib with a `__main__` check to ensure it is only run in the top-level environment.

    if __name__ == "__main__":
        (
            sp.sample_sobol(2**6)
            .evaluate(wrapped_linear, nprocs=2)
            .analyze_sobol(nprocs=2)
        )