While the previous chapters introduced LIME and SHAP, applying them to different types of machine learning tasks requires understanding how to interpret the explanations in context. For regression problems, where the model predicts a continuous value (like price, temperature, or sales count), both LIME and SHAP help attribute the final predicted value to the input features. The core mechanisms remain the same, but the interpretation focuses on how features push the prediction higher or lower relative to some baseline.

Explaining Regression Predictions with LIME

LIME explains a regression prediction by fitting a simpler, interpretable model (often a linear model) to perturbations of the instance you want to explain. For regression, this local model predicts the output of the original complex model in the vicinity of that instance.

The output of LIME for a regression prediction is typically a list of features and their corresponding weights. These weights represent the coefficients of the local linear model.

Positive Weight: Indicates that the feature's value in the specific instance contributed positively to the prediction, pushing it higher than the average prediction in that local region.
Negative Weight: Indicates that the feature's value contributed negatively, pushing the prediction lower.
Magnitude: The absolute value of the weight suggests the strength of the feature's influence on this particular prediction, locally.

Consider predicting house prices. For a specific house predicted to cost $500,000, LIME might produce explanations like:

sqft_living > 2500: +$80,000 (The large living area increased the predicted price)
condition == 'poor': -$50,000 (The poor condition decreased the predicted price)
zipcode == '98103': +$70,000 (The desirable location increased the predicted price)

These weights show the estimated local linear effect of each feature deviation on the final prediction. Keep in mind LIME's explanation is local; these weights approximate the model's behavior only near the instance being explained and depend on the perturbation strategy and the quality of the local fit.

Here's a conceptual Python snippet using the lime library:

# Assume 'model' is your trained regression model
# 'X_train' is your training data (needed for statistics)
# 'instance' is the specific data point you want to explain

import lime
import lime.lime_tabular

# Create a LIME explainer for tabular data
explainer = lime.lime_tabular.LimeTabularExplainer(
    training_data=X_train.values,
    feature_names=X_train.columns,
    class_names=['prediction'], # Use a generic name for regression
    mode='regression' # Specify 'regression' mode
)

# Generate explanation for the instance
explanation = explainer.explain_instance(
    data_row=instance.values,
    predict_fn=model.predict, # Pass the model's prediction function
    num_features=5 # Number of features to show in the explanation
)

# Show the explanation
explanation.show_in_notebook() # Or access explanation.as_list()

Explaining Regression Predictions with SHAP

SHAP values provide a theoretically grounded way to attribute the difference between a specific prediction and the average prediction across all features. For regression, a SHAP value for a feature represents its contribution to pushing the prediction away from the base value (often the mean prediction over the training set).

The fundamental equation for SHAP is:

$f(x) = \phi_0 + \sum_{i=1}^{M} \phi_i$

Where:

$f(x)$ is the model's prediction for instance $x$ .
$\phi_0$ is the base value (e.g., the average prediction over the dataset).
$M$ is the number of features.
$\phi_i$ is the SHAP value for feature $i$ , representing its contribution to this specific prediction.

Similar to LIME, positive SHAP values push the prediction higher than the base value, while negative values push it lower. The magnitude indicates the strength of the contribution. SHAP guarantees that the sum of the SHAP values plus the base value equals the exact prediction for the instance (local accuracy).

SHAP offers various visualisations. For individual regression predictions, the force plot is particularly informative.

# Assume 'model' is your trained regression model
# 'X' is your data
# 'instance_index' is the index of the row you want to explain

import shap

# Use KernelExplainer for model-agnostic approach
# Or TreeExplainer for tree-based models (faster)
explainer = shap.Explainer(model.predict, X) # Or shap.TreeExplainer(model) for trees

# Calculate SHAP values for the specific instance
shap_values = explainer(X.iloc[[instance_index]])

# Visualize the explanation for the first instance explained
shap.plots.force(shap_values[0])

This generates an interactive plot showing features pushing the prediction higher (typically in red) or lower (typically in blue) relative to the base value.

A conceptual SHAP force plot for a regression model predicting a value of 250k. Features shown in blue decrease the prediction relative to the base value (200k), while features in red increase it. The size of each block represents the magnitude of the feature's impact.

Interpreting the Output in Context

When interpreting explanations for regression models:

Focus on Units: The LIME weights and SHAP values are in the same units as your target variable. A SHAP value of +15 means the feature added 15 units (e.g., $15, £15, 15kg) to the prediction relative to the baseline. This makes the explanation directly relatable to the prediction scale.
Baseline Awareness: Understand what the baseline prediction is. For SHAP, it's usually the average prediction across the dataset. For LIME, it's implicitly the average prediction within the local region it modeled. Features explain the deviation from this baseline.
Local vs. Global: Remember LIME provides purely local explanations. SHAP values are calculated for specific predictions (local) but can be aggregated (e.g., using summary plots) to understand global feature importance trends across the entire dataset for the regression task.
Identify Key Drivers: Use the explanations to pinpoint which features are most influential in driving specific predictions higher or lower than average. This is useful for understanding model behavior for specific segments or outliers.
Debug Unexpected Predictions: If the model predicts an unusually high or low value, LIME or SHAP can help diagnose whether this is due to expected feature influences or potentially erroneous model behavior related to specific feature values or interactions.

By applying LIME and SHAP to regression tasks and carefully interpreting their outputs, you gain valuable transparency into how your models arrive at their continuous predictions, enabling better debugging, validation, and communication of model behavior.