SHAP Analysis

SHAP analysis is a model explanation tool used to break down a model prediction into feature-level contributions. Instead of only reporting the final prediction, SHAP assigns each input feature a value describing how much that feature moved the prediction away from a reference value. This helps identify which variables support, oppose, or have little effect on a prediction for each row of data.

In Isalos, SHAP analysis is available for several model families through both model-agnostic and model-specific explanation methods. Model-agnostic methods, such as Kernel SHAP and Permutation SHAP, explain a fitted model by repeatedly evaluating it under different feature-substitution scenarios. Model-specific methods, such as Linear SHAP, Tree SHAP, and Deep SHAP, use the structure of the fitted model directly to calculate explanations more efficiently or more exactly for supported models.

Use SHAP Analysis by browsing in the top ribbon:

Statistics $\rightarrow$ SHAP Analysis

Mathematical Background

SHAP is based on Shapley values from cooperative game theory.¹ In the SHAP setting, the “game” is the model prediction and the “players” are the input features. The objective is to distribute the difference between a reference prediction and the prediction for the row being explained among the model input features.²

SHAP explains one scalar model output at a time. For regression models this scalar is usually the predicted response. For classification models it is usually the probability or score of one explained class. If a model produces several outputs, the SHAP values shown in one output table refer only to the scalar output selected internally by the SHAP method and model adapter.

For a model prediction $f(x)$, SHAP explanations are commonly written as:

$$ \begin{equation} f(x) = \phi_0 + \sum_{j=1}^{M} \phi_j \end{equation} $$

where $M$ is the number of model input features, $\phi_0$ is the reference or baseline value, and $\phi_j$ is the contribution assigned to feature $j$.

The baseline $\phi_0$ is the prediction expected before seeing the explained row. The SHAP values then describe how the features of the explained row move the model away from this baseline. A positive SHAP value increases the explained scalar prediction relative to the baseline, while a negative SHAP value decreases it.

The classical Shapley value for feature $j$ is:

$$ \begin{equation} \phi_j = \sum_{S \subseteq F \setminus \{j\}} \frac{|S|!(M-|S|-1)!}{M!} \left[ v(S \cup \{j\}) - v(S) \right] \end{equation} $$

where $F$ is the full set of model features, $S$ is a subset of features that does not include feature $j$, $v(S)$ is the model output assigned to the feature coalition $S$, and $v(S \cup \{j\}) - v(S)$ is the marginal contribution of adding feature $j$ to coalition $S$.

The practical challenge in predictive modeling is that most models cannot directly evaluate a row with a feature “missing”. SHAP methods therefore differ mainly in how they define and compute the value function $v(S)$. This is the missing-feature problem.

The most important property for interpretation is the efficiency property:

$$ \begin{equation} \sum_{j=1}^{M} \phi_j = f(x) - \phi_0 \end{equation} $$

Isalos checks this reconstruction numerically and reports the result once in the output table’s reporting box, together with the maximum absolute residual and the tolerance. The check applies to the scalar named in Output Space; for example, class-probability contributions reconstruct a probability, while raw-margin contributions reconstruct a margin. Passing this check confirms numerical reconstruction, but does not by itself establish that sampled attributions have converged or that the chosen background population is appropriate. See How to Read SHAP Tables.

The Missing-Feature Problem

When a feature is absent from a coalition, the model still requires a complete input vector. SHAP methods solve this by defining how missing features are represented during explanation. This is why Isalos exposes different configuration options for different SHAP methods.

In model-agnostic methods, missing features are usually replaced using values from a background dataset. The background dataset represents the reference population against which explanations are computed. For example, if feature $x_j$ is considered absent, Kernel SHAP or Permutation SHAP can replace it with values sampled from the background rows while keeping the present features fixed.

In model-specific methods, the fitted model structure is used directly. Linear SHAP uses fitted coefficients and a reference feature distribution. Tree SHAP uses tree paths and node statistics. Deep SHAP uses layer-by-layer contribution propagation through a fitted neural network. These approaches still require a clear baseline, but they avoid brute-force feature coalition evaluation where the model structure permits a more direct calculation.

For a background dataset $B = \{b^{(1)}, b^{(2)}, \ldots, b^{(N_B)}\}$, a common model-agnostic value function for row $x$ and coalition $S$ is:

$$ \begin{equation} v_x(S) = \frac{1}{N_B} \sum_{i=1}^{N_B} f\left(h_S(x,b^{(i)})\right) \end{equation} $$

where the hybrid row $h_S(x,b)$ is:

$$ \begin{equation} h_S(x,b)_j = \begin{cases} x_j, & j \in S \\ b_j, & j \notin S \end{cases} \end{equation} $$

This means that present features come from the row being explained, while absent features come from one background row. Averaging over background rows approximates the expected prediction for the coalition. Kernel SHAP and Permutation SHAP use this idea directly. Linear SHAP, Tree SHAP, and Deep SHAP specialize the baseline and contribution calculation to the fitted model family.

Choosing the Background Dataset

The background dataset should be interpreted as the reference population for the explanation. It is not simply an additional input table. It defines the baseline prediction and, for methods that substitute missing features, it also defines the values used when a feature is treated as absent.

Isalos allows the background dataset to be selected independently from the dataset used to train the model. This is intentional. It gives the user control over the reference population, allows smaller representative background subsets to be used for efficient computation, and supports imported or pre-trained models whose original Isalos training datasheet may not be available.

Choose representative rows from the population against which predictions should be interpreted, using the model’s feature names, units, encodings and preprocessing. Training, validation/test or deployment data can supply this reference population; a held-out dataset is not automatically a better SHAP background because it was excluded from model fitting. Keep the role of the background separate from the role of a held-out test set used to assess predictive performance.

Using complete background rows retains the relationships among the features replaced together. However, combining those values with the query’s retained features can break relationships between the two groups and create combinations that are uncommon in the original data. Background substitution does not generally compute a conditional distribution of missing features given the present features. This distinction matters for strongly dependent inputs, and a larger background does not remove it.

For imported Isalos-compatible fitted models, supply a compatible background datasheet when the selected SHAP method requires one. The original training datasheet need not be present in the project. Tree SHAP models with sufficient stored path statistics can be explained without a separately supplied background. Importing a model does not mean that arbitrary external formats, such as a Keras model file, are accepted by Isalos.

SHAP Methods Available in Isalos

The SHAP type shown in the configuration window depends on the selected model. Isalos prioritizes the model-specific method when one is available, while still allowing Kernel SHAP or Permutation SHAP for many supported model families.

SHAP method	Main idea	Background/reference data	Sampling budget field	Typical supported model family
Kernel SHAP	Model-agnostic Shapley approximation using weighted coalitions	Required	Number of Coalition Samples	Supported fallback for XGBoost, Random Forest, J48, Linear SGD, kNN, MLP, RBF, MLR, GLM, GEE, and Random Tree models
Permutation SHAP	Model-agnostic attribution by feature reveal orderings	Required	Number of Permutations	Supported fallback for the same model families; default SHAP option for RBF models
Linear SHAP	Uses fitted linear coefficients and reference values	Required	Not shown	MLR and Linear SGD regression models
Tree SHAP	Uses tree structure and path statistics	Usually not required; Random Forest may require reference rows	Not shown	Random Forest, J48, Random Tree, and compatible XGBoost classification/regression tree models
Deep SHAP	Uses fitted MLP layers and background-based baselines	Required	Not shown	Multi-Layer Perceptron models

Both k-Nearest Neighbors (kNN) and k-Nearest Neighbors (kNN) NEW support Kernel SHAP and Permutation SHAP, with Kernel SHAP selected by default. Select the exact fitted model intended for the explanation: the two kNN implementations can produce different predictions and consequently different SHAP values. Their shared eligibility does not imply numerical equivalence.

The sampling-budget field is visible only for Kernel SHAP and Permutation SHAP. Deep SHAP, Linear SHAP, and Tree SHAP do not use a coalition or permutation budget in the SHAP configuration window.

After a model is selected, Isalos automatically selects the best-fitting compatible SHAP type for that model family. This automatic selection is intended to guide the user toward the most appropriate available method without requiring them to know the implementation details. For example, a supported MLP model is directed toward Deep SHAP, a supported linear model is directed toward Linear SHAP, and supported tree models are directed toward Tree SHAP when the model-specific compatibility checks are satisfied.

Query and background tables must contain the fitted model’s input features with compatible datatypes. Numeric feature columns may be Integer or Double; an Integer model feature must be supplied without fractional values. Additional target or identifier columns are not explanation features unless they were actually used to train the model.

The selected SHAP type can still be reviewed and changed when alternative compatible methods are available. The model-agnostic methods remain useful when the user wants a method with a different missing-feature interpretation or when a model-specific compatibility check is not satisfied. In the method-specific examples below, “select” the SHAP type should therefore be read as “confirm the auto-selected option or choose this method deliberately if another compatible option is currently selected.”

Selecting Features for the Beeswarm Plot

After ticking Beeswarm Plot, the Select Features button appears below it. Choose the features to display, or leave the selection unspecified to show the ten features with the largest mean absolute SHAP values across the query rows. If fewer than ten features are available, all are shown.

This selection controls the plot only. SHAP still explains all model input features and exports all feature contributions in the table. The selector inside the Beeswarm window allows features to be added or removed afterward. See Beeswarm Plot for interpretation and display controls.

Example Datasets and Configuration Hints

The method examples use small synthetic datasets for illustrating the workflow, not for assessing model accuracy. Each training dataset has 100 rows and each test dataset has 12 rows. The five input features are Temperature, Pressure, Concentration, Duration, and Flow. They are min-max scaled using the training-set bounds; the test data uses the same transformation. The final column is the unscaled target: Response for regression or Class (0/1) for classification. Do not include the target or the worksheet’s User Row ID column among model input features.

The screenshots show some fields before values have been entered. Light-grey text is a placeholder, not a configured value. A numerical Default in a sampling-budget field is used when that field is left blank. In contrast, Background Size (Rows) shows Default: -: enter a valid number before executing. For these examples, enter 100 to use all rows of train_reg or train_class. The displayed interval [1, 100] describes the valid range; it does not select 100 automatically.

Kernel SHAP

Kernel SHAP is a model-agnostic SHAP method. It treats the selected model as a prediction function and estimates feature contributions by evaluating masked versions of the input row. Each masked row represents a coalition of present features, while missing features are supplied from the selected background dataset.²

Kernel SHAP is useful when no exact model-specific SHAP implementation is available. The advantage is generality: the method only needs to call the fitted model. The cost is computational: the method must evaluate many hybrid rows and then solve a weighted regression problem for each explained row.

Mathematical Formulation

Kernel SHAP fits a local additive explanation model around the row being explained. A coalition is represented by a binary vector $z \in \{0,1\}^{M}$, where $z_j = 1$ means feature $j$ is present and $z_j = 0$ means feature $j$ is absent.

The local explanation model is:

$$ \begin{equation} g(z) = \phi_0 + \sum_{j=1}^{M} \phi_j z_j \end{equation} $$

For each coalition $z$, the model-agnostic coalition value is computed by replacing absent features with background values:

$$ \begin{equation} v_x(z) = \frac{1}{N_B} \sum_{i=1}^{N_B} f\left(h_z(x,b^{(i)})\right) \end{equation} $$

$$ \begin{equation} h_z(x,b)_j = \begin{cases} x_j, & z_j = 1 \\ b_j, & z_j = 0 \end{cases} \end{equation} $$

The SHAP values are obtained by fitting $g(z)$ to the coalition values using the Shapley kernel. In Kernel SHAP, the Shapley kernel is the coalition-weighting function $\pi(z)$. For a coalition with size $s = \sum_j z_j$, where $0 < s < M$:

$$ \begin{equation} \pi(z) = \frac{M-1} {\binom{M}{s}s(M-s)} \end{equation} $$

The weighted least-squares objective is:

$$ \begin{equation} \min_{\phi} \sum_{z} \pi(z) \left[ v_x(z) - \phi_0 - \sum_{j=1}^{M}\phi_j z_j \right]^2 \end{equation} $$

subject to the SHAP efficiency constraint:

$$ \begin{equation} \sum_{j=1}^{M}\phi_j = f(x) - \phi_0 \end{equation} $$

In Isalos, the baseline is:

$$ \begin{equation} \phi_0 = \frac{1}{N_B}\sum_{i=1}^{N_B} f(b^{(i)}) \end{equation} $$

Background Interpretation

The background dataset defines what “missing” means. If a feature is excluded from a coalition, Isalos substitutes the feature value from each selected background row and averages the resulting predictions. The explanation is therefore relative to the selected background population, not relative to an abstract zero vector.

This is important in practice:

A background set drawn from the model’s training distribution usually gives explanations relative to typical modeled data.
A very small or unrepresentative background set can shift the baseline and change the apparent contributions.
Background rows must contain the same model input feature names as the selected model. Extra columns are ignored.

Computational Technique in Isalos

For each query row, Isalos executes Kernel SHAP as follows:

Compute the baseline prediction as the mean prediction over the selected background rows.
Compute the full prediction $f(x)$ for the query row.
Build a coalition set according to the requested coalition-sample budget.
Give high-weight coalition sizes priority. Small coalitions and their large-complement counterparts are enumerated first when the budget permits.
Use random sampling for the remaining middle coalition sizes when the requested budget is smaller than the full coalition space.
For every coalition, build a batch of hybrid rows by combining the query row with each selected background row.
Average the model predictions for those hybrid rows to obtain the coalition value $v_x(z)$.
Solve the weighted least-squares system with the efficiency constraint applied algebraically.

Each evaluated non-trivial coalition becomes one row in a local regression problem. The row records which features were present in that coalition. The target is not the raw coalition prediction itself, but the coalition prediction measured relative to the baseline:

$$ \begin{equation} y(z) = v_x(z) - \phi_0 \end{equation} $$

This centering step is important because SHAP explains a prediction difference, not an absolute prediction. The baseline $\phi_0$ represents the model output before the explained row’s feature values are introduced. When all features are present, the coalition value is the full prediction $f(x)$, so the feature contributions must reconstruct the movement from the baseline to the full prediction. The full prediction difference for the query row is:

$$ \begin{equation} d = f(x) - \phi_0 \end{equation} $$

The efficiency constraint requires the feature contributions to sum to this full prediction difference:

$$ \begin{equation} \sum_{j=1}^{M}\phi_j = f(x)-\phi_0 = d \end{equation} $$

For one coalition mask $z$, Kernel SHAP then uses a local additive surrogate:

$$ \begin{equation} y(z) \approx \sum_{j=1}^{M} z_j\phi_j \end{equation} $$

In this equation, $z_j$ is only a coalition indicator. If $z_j=1$, feature $j$ is present in the surrogate model and its contribution $\phi_j$ is included in the sum. If $z_j=0$, feature $j$ is absent from the coalition and its contribution is excluded from that surrogate row. The approximate equality has two practical meanings. First, $v_x(z)$ is usually estimated from a finite number of background rows rather than the full population distribution. Second, for nonlinear models or models with feature interactions, one fixed additive vector $\phi$ cannot usually reproduce every coalition value exactly. Kernel SHAP therefore fits the best local additive explanation under the Shapley-kernel weighting scheme.

After the non-trivial coalitions are generated, Isalos stacks the coalition rows into a matrix problem. Let $Z$ be the coalition-design matrix, where row $i$ contains the mask values for coalition $z^{(i)}$. Let $y$ be the vector of centered coalition targets, where $y_i = y(z^{(i)})$. If $\phi$ is the vector of feature contributions, the residual for row $i$ is:

$$ \begin{equation} r_i = Z_i\phi - y_i \end{equation} $$

The Shapley kernel assigns a weight $w_i = \pi(z^{(i)})$ to each coalition row. These weights are collected in a diagonal matrix $W$. A weighted least-squares solve minimizes:

$$ \begin{equation} \sum_i w_i r_i^2 \end{equation} $$

This weighted problem can be written as an ordinary least-squares problem after rescaling each row. If row $i$ of the design matrix and target vector are multiplied by $\sqrt{w_i}$, the residual for that row becomes $\sqrt{w_i}r_i$. Squaring it gives:

$$ \begin{equation} \left(\sqrt{w_i}r_i\right)^2 = w_i r_i^2 \end{equation} $$

This is why the matrix form uses $\sqrt{W}$ rather than $W$ directly. Multiplying by $\sqrt{W}$ rescales each coalition row by the square root of its Shapley-kernel weight before the least-squares solve. High-weight coalitions therefore have a stronger influence on the fitted local explanation, while low-weight coalitions have less influence.

Kernel SHAP also needs the final explanation to satisfy the efficiency constraint exactly. This anchors the local explanation to two fixed endpoints: the empty coalition corresponds to the baseline difference $0$, and the grand coalition corresponds to the full prediction difference $d=f(x)-\phi_0$. Rather than solving all $M$ feature contributions independently and then correcting the sum afterward, Isalos removes one contribution from the set of free unknowns. This constrains the solver so the fitted explanation cannot drift away from the required full-coalition reconstruction. For one eliminated feature $k$:

$$ \begin{equation} \phi_k = d - \sum_{j \neq k}\phi_j \end{equation} $$

Substituting this expression into each coalition row changes the local model into a reduced row equation. For coalition row $i$, with mask $z^{(i)}$ and centered target $y_i = y(z^{(i)})$:

$$ \begin{equation} y_i - z^{(i)}_k d \approx \sum_{j \neq k} \left(z^{(i)}_j-z^{(i)}_k\right)\phi_j \end{equation} $$

Here, $z^{(i)}_k$ and $d$ are scalars, so $z^{(i)}_k d$ is also scalar. The vector notation only appears after these row equations are stacked. The reduced system solves only for the $M-1$ free contributions. Let $\phi_{\setminus k}$ be the vector containing all feature contributions except the eliminated contribution $\phi_k$. Let $Z_{\mathrm{red}}$ be the reduced coalition-design matrix whose row entries are $z^{(i)}_j-z^{(i)}_k$ for $j \neq k$. Let $y_{\mathrm{red}}$ be the adjusted target vector whose row entries are $y_i-z^{(i)}_kd$. This makes the reconstruction property part of the solve itself: once $\phi_{\setminus k}$ is found, the omitted contribution $\phi_k$ is recovered from the efficiency equation.

Putting these pieces together, the reduced weighted least-squares problem solved by Isalos is:

$$ \begin{equation} \hat{\phi}_{\setminus k} = \arg\min_{\phi_{\setminus k}} \left\| \sqrt{W} \left( Z_{\mathrm{red}}\phi_{\setminus k} - y_{\mathrm{red}} \right) \right\|_2^2 \end{equation} $$

Isalos solves this reduced weighted system using singular-value decomposition, which improves numerical stability when coalition rows are nearly collinear or the design matrix is close to rank deficient.

Kernel SHAP does not evaluate the empty coalition or the grand coalition as ordinary sampled coalition rows. The empty coalition is represented by the baseline $\phi_0$, and the grand coalition is represented by the full prediction $f(x)$ and the efficiency constraint. Therefore the number of non-trivial coalition masks available for the weighted regression is:

$$ \begin{equation} C_{\mathrm{nontrivial}} = 2^M - 2 \end{equation} $$

If $C_{\mathrm{budget}}$ is the requested number of coalition samples, the number of evaluated non-trivial coalition masks is bounded by:

$$ \begin{equation} C_{\mathrm{eff}} = \min\left(2^M - 2, C_{\mathrm{budget}}\right) \end{equation} $$

In exact-enumeration cases, $C_{\mathrm{eff}} = 2^M - 2$. In sampled cases, the requested budget acts as the maximum number of non-trivial coalition masks used by the regression.

For $N_{\mathrm{query}}$ explained rows and $N_B$ background rows, the dominant model-evaluation workload scales approximately as:

$$ \begin{equation} O\left(N_{\mathrm{query}} C_{\mathrm{eff}} N_B\right) \end{equation} $$

This is why the coalition budget and background size are visible configuration choices for Kernel SHAP.

Using Kernel SHAP in Isalos

Input

Kernel SHAP requires a query datasheet and a background datasheet. The query datasheet contains the rows to be explained and must include the selected model’s input feature columns. The background datasheet is selected independently and should represent the reference population for the explanation. It must contain the same model input features because it supplies replacement values for missing coalition features. Choose a representative reference population as described in Choosing the Background Dataset. For imported or pre-trained models, upload an appropriate background datasheet with the same feature preprocessing expected by the model. Extra columns may be present in either sheet, but they are ignored during the SHAP calculation.

Configuration

Configuration field	Description
Select Model	Select the fitted model to explain.
Select SHAP Type	Confirm or choose `Kernel SHAP`. Isalos may auto-select another compatible method first when it is a better fit for the selected model.
Select Background	Select the reference dataset used to replace missing features during coalition evaluation. Follow Choosing the Background Dataset, including for imported models.
Background Size (Rows)	Select the number of rows to use from the background dataset.
Number of Coalition Samples	Select the coalition sampling budget. Larger values can improve stability but increase runtime.
Beeswarm Plot	Generate a plot using the display selection described in Beeswarm Plot.
Select Features	Shown when Beeswarm Plot is ticked. Choose displayed features, or retain the default top ten. This does not limit the SHAP calculation.

Output

The Kernel SHAP output table contains the explained prediction, the baseline value, the efficiency check, and one SHAP-value column for each model input feature. The explanation is relative to the selected background rows and the requested coalition-sample budget.

Example

This example explains a fitted kNN regression model trained on the 100-row regression datasheet. The same datasheet, named train_reg, supplies the background/reference rows. The separate 12-row test datasheet contains the queries to be explained. Model training is completed before opening SHAP Analysis.

Input

Prepare the 100-row regression training datasheet and the 12-row test datasheet, with the five input features and the Response target described above. Here, the training datasheet also represents the reference population for Kernel SHAP.

The background/training datasheet and the test/query datasheet must contain the same model input feature columns. The response column may be present, but SHAP uses the fitted model inputs when constructing explanations.

The first rows of the 100-row regression training/background datasheet are shown below.

Kernel SHAP kNN regression training background dataset

The 12-row test datasheet containing the rows to be explained is shown below.

Kernel SHAP kNN regression test query dataset

Configuration

Use Kernel SHAP by selecting:

Statistics $\rightarrow$ SHAP Analysis $\rightarrow$ Select SHAP Type: Kernel SHAP

Select Model is used to choose the already fitted kNN regression model that will be explained.
Model Type confirms that the selected model is a kNN model. This helps verify that the SHAP configuration is being applied to the intended fitted model.
Select SHAP Type is set to Kernel SHAP. If Isalos auto-selects another compatible SHAP type after model selection, confirm or change the selection here.
Select Background is set to train_reg. This supplies the reference rows used when Kernel SHAP substitutes values for missing coalition features.
Background Size (Rows) is blank in the screenshot. Enter 100 to use the full training background, or a smaller positive count to sample fewer reference rows. Default: - indicates that no automatic count is supplied.
Number of Coalition Samples is left blank to use the displayed default of 2058. For five input features, this follows the practical rule $2M+2^{11}=2058$, also documented for Python SHAP’s KernelExplainer.³ This is a budget, not a promise to evaluate 2058 distinct masks: with five varying features, only $2^5-2=30$ non-trivial coalitions exist. Fewer varying features reduce this further. The empty and full coalitions supply the constraints described in the computational method.
Beeswarm Plot is enabled so that Isalos also produces a global summary plot after the SHAP table is generated. The plot interpretation is shared across SHAP methods and is described later in the Beeswarm Plot section.
Plot Features: Select Features (5) opens the feature selector. Five features are selected for display in this screenshot. This selection does not restrict the features explained in the output table.
Execute starts the Kernel SHAP calculation.

The Model Input Features -> Datatypes panel lists the five fitted inputs as Double. The message panel below the background selector summarizes the runtime warning and confirms that the query and background datasets each match all five model features. Extra columns, such as the target, are ignored by the SHAP calculation.

Kernel SHAP configuration window for kNN regression, callouts 1 to 9

Output

The output is a regression SHAP table. Each row corresponds to one explained test row. The prediction column contains the kNN regression prediction for that test row, base_value is the mean prediction over the selected background rows, and the feature-level SHAP columns show how each input feature moves the prediction away from that background baseline.

Inspect the SHAP output table by checking that the displayed prediction is reconstructed by the baseline plus the feature-level SHAP values. Positive feature SHAP values increase the explained regression prediction relative to the baseline, while negative values decrease it.

The reporting box’s Efficiency Check summarizes reconstruction across all 12 queries. The columns φ_Temperature, φ_Pressure, φ_Concentration, φ_Duration, and φ_Flow report contributions for the five inputs, in regression-response units. See How to Read SHAP Tables for the shared layout.

The completed example is shown below. Click the image to inspect the full-size table.

Kernel SHAP results for 12 kNN regression queries, with the reporting box and five feature contributions

The common base_value is approximately 33.2277484. For the first query, the five contributions sum to approximately 0.8028139, giving the displayed prediction 34.0305623 when added to the baseline. The reporting box states Passed for all rows under Efficiency Check, with a tolerance of 0.0000010. Its residual is displayed as 0E-7; this is a formatted numerical result, not a claim of exact arithmetic. The predicted response need not equal the observed Response target: SHAP reconstructs the fitted model’s prediction, not the ground-truth value.

If Beeswarm Plot was selected, see Beeswarm Plot for a shared example, interpretation and display controls.

Permutation SHAP

Permutation SHAP is a model-agnostic method that estimates feature contributions by repeatedly revealing features in different orders. For each sampled ordering, the method starts from background rows, inserts the explained row’s feature values one by one, and records the marginal prediction change assigned to the feature that was just revealed. Averaging these marginal changes across orderings and background rows estimates the contribution of each feature.⁴

Like Kernel SHAP, Permutation SHAP uses a background dataset to represent missing features. The conceptual difference is in how the Shapley averaging is approximated. Kernel SHAP fits a weighted coalition regression, while Permutation SHAP estimates Shapley values directly from sampled feature orderings. In Isalos, this makes Permutation SHAP the default choice for Radial Basis Function (RBF) models. RBF models are nonlinear, distance-based predictors whose behavior depends on centers, widths, and radial kernel responses. They do not fit the assumptions of the implemented Linear SHAP, Tree SHAP, or Deep SHAP paths. Permutation SHAP can still explain them because it only needs reliable model predictions for complete rows and a representative background dataset for missing-feature substitution. Kernel SHAP remains available as an alternative model-agnostic method, but Permutation SHAP is the default RBF choice because it avoids an additional weighted surrogate-regression solve and keeps the explanation tied to direct reveal-order prediction differences.