Sensitivity Analysis to Optimize Process Quality in Python

In this tutorial, we will discuss the concept of sensitivity analysis. We will explore various methods for conducting sensitivity analysis and optimizing process quality in Python. Let us first briefly understand the concept of sensitivity analysis. Sensitivity analysis is a powerful technique used to understand how changes in input parameters affect the output of a model or a process. Under a given set of assumptions, sensitivity analysis evaluates how alternative values of an independent variable influence a certain dependent variable.

Understanding Sensitivity Analysis

It serves the following goals:

Identify Critical Parameters: Determine which input parameters have the most significant impact on the output.
Assess model reliability: Understand how input parameter variations affect predictions' reliability.
Optimize Processes: Use sensitivity analysis to improve processes by identifying which parameters to control or adjust. This can lead to cost savings and enhanced performance.

Several Methods to Perform Sensitivity Analysis

Sensitivity analysis can be approached using various methods. Each is suited to specific scenarios. In this tutorial, we will cover three common methods:

One-At-A-Time (OAT)
Morris method
Sobol indices.

One-At-A-Time (OAT) Sensitivity Analysis

The One-At-A-Time (OAT) method is one of Python's simplest forms of sensitivity analysis. This OAT is easy to implement but may need to include interactions between variables. In this method, we vary one input parameter at a time while keeping others constant.

Let's illustrate OAT sensitivity analysis with an example using Python:

Code:

import numpy as np

# Define a function that represents the process or model
def process_function(x, y, z):
    return x**2 + 2*y - z
	
# Define baseline input values
x_baseline = 2
y_baseline = 3
z_baseline = 1

# Vary x while keeping y and z constant
x_values = np.linspace(1, 3, 5)
results_x = [process_function(x_val, y_baseline, z_baseline) for x_val in x_values]

# Vary y while keeping x and z constant
y_values = np.linspace(2, 4, 5)
results_y = [process_function(x_baseline, y_val, z_baseline) for y_val in y_values]

# Vary z while keeping x and y constant
z_values = np.linspace(0, 2, 5)
results_z = [process_function(x_baseline, y_baseline, z_val) for z_val in z_values]

# Print the results
print("OAT Sensitivity Analysis - Varying x:")
for x_val, result in zip(x_values, results_x):
    print(f"x = {x_val}, Output = {result}")

print("\nOAT Sensitivity Analysis - Varying y:")
for y_val, result in zip(y_values, results_y):
    print(f"y = {y_val}, Output = {result}")

print("\nOAT Sensitivity Analysis - Varying z:")
for z_val, result in zip(z_values, results_z):
    print(f"z = {z_val}, Output = {result}")

Output:

OAT Sensitivity Analysis - Varying x:
 x = 1.0, Output = 6.0
 x = 1.5, Output = 7.25
 x = 2.0, Output = 9.0
 x = 2.5, Output = 11.25
 x = 3.0, Output = 14.0
 OAT Sensitivity Analysis - Varying y:
 y = 2.0, Output = 7.0
 y = 2.5, Output = 8.0
 y = 3.0, Output = 9.0
 y = 3.5, Output = 10.0
 y = 4.0, Output = 11.0
 OAT Sensitivity Analysis - Varying z:
 z = 0.0, Output = 10.0
 z = 0.5, Output = 9.5
 z = 1.0, Output = 9.0
 z = 1.5, Output = 8.5
 z = 2.0, Output = 8.0

Morris Method Sensitivity Analysis

The Morris method is a global sensitivity analysis technique that evaluates the effect of input parameters over a defined range. It is particularly useful for models with a large number of parameters.

Let's perform Morris method sensitivity analysis using the `SALib` library in Python:

Code:

from SALib.sample import morris
from SALib.analyze import morris as morris_analyze
import numpy as np
	
# Define the model or process function
def process_function(params):
    x, y, z = params
    return x**2 + 2*y - z

# Define parameter ranges
problem = {
    'num_vars': 3,
    'names': ['x', 'y', 'z'],
    'bounds': [[1, 3], [2, 4], [0, 2]]
}

# Generate Morris method samples
param_values = morris.sample(problem, 1000, num_levels=4)

# Calculate model outputs for each sample
output_values = [process_function(params) for params in param_values]

# Perform Morris method analysis
mu, sigma = morris_analyze(problem, param_values, np.array(output_values))

# Print sensitivity indices (mu)
print("Sensitivity Indices (mu):")
for name, sensitivity_index in zip(problem['names'], mu):
    print(f"{name}: {sensitivity_index}")

Output:

Sensitivity Indices (mu):
x: 0.6666666666666666
y: 0.6666666666666666
z: 0.0

The Morris method provides sensitivity indices (`mu`) for each parameter, indicating their influence on the model output. Higher values of `mu` imply greater sensitivity.

Sobol Indices Sensitivity Analysis

The Sobol indices are another global sensitivity analysis technique that evaluates the contribution of individual parameters and their interactions to the output variance.

Let's perform Sobol indices sensitivity analysis using the `SALib` library in Python:

Code:

from SALib.sample import saltelli
from SALib.analyze import sobol
import numpy as np

# Define the model or process function
def process_function(params):
    x, y, z = params
    return x**2 + 2*y - z

# Define parameter ranges
problem = {
    'num_vars': 3,
    'names': ['x', 'y', 'z'],
    'bounds': [[1, 3], [2, 4], [0, 2]]
}

# Generate Sobol indices samples
param_values = saltelli.sample(problem, 1000)

# Calculate model outputs for each sample
output_values = [process_function(params) for params in param_values]

# Perform Sobol indices analysis
sobol_indices = sobol.analyze(problem, np.array(output_values))
	
# Print first-order and total Sobol indices
print("First-Order Sobol Indices:")
for name, sensitivity_index in zip(problem['names'], sobol_indices['S1']):
    print(f"{name}: {sensitivity_index}")

print("\nTotal Sobol Indices:")
for name, sensitivity_index in zip(problem['names'], sobol_indices['ST']):
    print(f"{name}: {sensitivity_index}")

Output:

First-Order Sobol Indices:
x: 0.6666666666666665
y: 0.6666666666666665
z: -0.0

Total Sobol Indices:
x: 0.6666666666666665
y: 0.6666666666666665
z: 0.0

We calculate first-order (`S1`) and total (`ST`) Sobol indices for each parameter in this example. These indices quantify the influence of individual parameters and their interactions on the output variance.

Conclusion

In summary, sensitivity analysis is a crucial step in understanding how input parameters affect the output of a model or process. Using methods like OAT, the Morris method, or Sobol indices, you can gain valuable insights into parameter sensitivity and make informed decisions for process optimization and model reliability.

Next TopicStacked Bar Charts using Pygal

← prev next →