AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
SHAP (SHapley Additive exPlanations) is a framework for interpreting machine-learning model outputs by decomposing predictions into feature-level contributions. This skill provides a structured approach to selecting explainers, defining background distributions, and validating attributions to ensure model behavior is described accurately. It emphasizes the use of the modern shap.Explanation API, explicit output selection, and rigorous additivity checks to prevent misinterpretation of model behavior.
What it does
- Selects appropriate SHAP explainers and maskers based on model type and data structure.
- Computes feature attributions for local and global model interpretation.
- Validates explanation additivity against exact model outputs.
- Handles multi-output models by selecting specific output indices or names.
- Generates visualizations including beeswarm, waterfall, and scatter plots for model analysis.
- Provides a template for deterministic, self-contained tabular reporting.
When to use it
- When you need to understand which features drive specific model predictions.
- When auditing model behavior for consistency with domain expectations.
- When comparing model performance or feature usage across different cohorts.
- When preparing documentation for model interpretability and transparency.
- When debugging unexpected model outputs or additivity failures.
Advantages
- Provides a mathematically grounded approach to feature attribution.
- Supports a wide range of models including tree ensembles, linear models, and deep learning.
- Enables both local (row-level) and global (dataset-level) analysis.
- Facilitates reproducible audits through explicit background data and masker definitions.
- Integrates with standard Python data science stacks.
Usage examples
- “Explain the predictions of my trained RandomForestClassifier using SHAP.”
- The agent will guide you to instantiate a TreeExplainer with a representative background dataset, compute the explanations, and validate the results using the model's predict_proba method.
- “How do I visualize the global feature importance for my model?”
- The agent will demonstrate how to use shap.plots.beeswarm or shap.plots.bar on an Explanation object to show the magnitude and direction of feature impacts across the dataset.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/k-dense-ai/shap/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip shap.zip -d .agents/skills
Documentation by K-Dense Inc.
SHAP
Use SHAP to describe how a fitted predictive model maps inputs to outputs. Work from the modern shap.Explanation API, make the explained output and background distribution explicit, and validate every explanation before interpreting it.
This skill is aligned with SHAP 0.52.0 (released 2026-05-28). That release requires Python 3.12 or newer.
The maintained examples were checked on Python 3.12.10 with SHAP 0.52.0, NumPy 2.5.3, pandas 3.0.6, scikit-learn 1.9.1, and matplotlib 3.11.2. Native tests cover small tree, exact, permutation, partition, linear, additive, kernel, text, and constant-image games; additional numeric XGBoost 3.4.1 smoke checks cover raw, probability, loss, and interaction outputs. Reference snippets that require a project model, framework, or data are adaptation templates; optional pretrained/deep, GPU, and distributed integrations remain illustrative and require their own runtime validation.
Operating Rules
Explain a fixed, evaluated model; do not use SHAP as a substitute for predictive validation.
Use held-out or clearly labeled analysis rows for explanations. Choose background rows only from an appropriate training or reference population.
State the explained output: regression value, raw margin, probability, log loss, logit, or another model method.
Prefer
shap.Explanationobjects andexplainer(X). Some specialized options still require.shap_values(X), including deep ranked outputs, gradient sampling budgets, and Kernel SHAPnsamples. Preserve their output indexes and baselines explicitly.For multi-output models, select one output before using tabular plots:
explanation[..., output_index].Check
base_values + values.sum(...)against the exact model output being explained.Treat SHAP as a description of model behavior under a masking/background choice. It does not establish causality, fairness, recourse, or scientific mechanism.
Never silence an additivity failure until input shape, preprocessing, model version, output space, and row ordering have been checked.
Do not load untrusted pickle, joblib, model, or explainer artifacts; those formats can execute code during deserialization.
Install
Create an isolated environment and pin the documented release:
uv venv --python 3.12
source .venv/bin/activate
uv pip install "shap[plots]==0.52.0"shap[plots] installs the plotting dependencies. Add the fitted model's package at a version compatible with the project. For older Python compatibility, read references/migration.md instead of silently installing a different SHAP release.
Confirm the environment before debugging an API mismatch:
import platform
import shap
print("Python:", platform.python_version())
print("SHAP:", shap.__version__)Standard Workflow
1. Define the explanation target
Record:
model and preprocessing version;
exact callable or model method being explained;
output name/index and units;
evaluation rows;
background/reference population;
masker and explainer algorithm;
SHAP and model-library versions.
For classifiers, decide whether the task needs raw margins or probabilities. Defaults differ by model family; never infer units from the plot color or sign.
2. Select an explainer and masker
Start with shap.Explainer(model, masker) when automatic dispatch is sufficient. Instantiate a specialized explainer when its assumptions or output controls matter.
| Situation | Preferred choice | Important constraint |
|---|---|---|
| Supported tree ensemble | TreeExplainer | model_output="probability" and "log_loss" require interventional masking and background data |
| Linear model | LinearExplainer | The masker determines interventional versus correlation-aware behavior |
| Small feature space | ExactExplainer | Cost grows quickly with unconstrained feature count |
| General tabular callable | PermutationExplainer | Budget at least one full forward/reverse permutation |
| Hierarchical feature groups, text, or image | PartitionExplainer | The partition tree changes the cooperative game |
| Differentiable neural network | DeepExplainer or GradientExplainer | Framework support, output shape, and background choice require testing |
| Legacy Kernel SHAP workflow | KernelExplainer | Usually much slower than model-specific methods |
Use the detailed decision guide in references/explainers.md. Use references/data-maskers.md when features are correlated, structured, sparse, or semantically grouped.
3. Compute a modern Explanation
This complete binary-classification example uses an explicit background and selects output index 1. In the breast-cancer dataset, class 1 means benign, so positive SHAP values below increase predicted benign probability, not cancer risk. For another dataset, resolve the requested label through model.classes_ and record its meaning before selecting an output index; column 1 is not universally the clinically positive event.
import numpy as np
import shap
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(as_frame=True, return_X_y=True)
X = X.astype(np.float32) # Match sklearn forest prediction inputs.
X_train, X_test, y_train, y_test = train_test_split(
X,
y,
test_size=0.25,
stratify=y,
random_state=7,
)
model = RandomForestClassifier(
n_estimators=200,
min_samples_leaf=3,
random_state=7,
n_jobs=-1,
).fit(X_train, y_train)
X_test = X_test.iloc[:100] # Predeclared held-out explanation subset.
background = shap.sample(X_train, 100, random_state=7)
explainer = shap.Explainer(model, background, algorithm="tree")
all_outputs = explainer(X_test)
# sklearn tree classifiers expose one output per class.
positive = all_outputs[..., 1]
assert positive.values.shape == X_test.shape
reconstructed = np.asarray(positive.base_values) + positive.values.sum(axis=1)
expected = model.predict_proba(X_test)[:, 1]
np.testing.assert_allclose(reconstructed, expected, rtol=1e-5, atol=1e-6)
shap.plots.beeswarm(positive, max_display=15)
shap.plots.waterfall(positive[0], max_display=15)Output shape is model-dependent:
one tabular output:
(samples, features);multiple tabular outputs:
(samples, features, outputs);multiple model inputs: often a list of arrays or explanations;
image/text explanations: feature axes follow the input representation, with output selection on the final axis when present.
Do not use the pre-0.45 pattern values[class_index] for a modern multi-output array. Use values[..., class_index] or slice the Explanation itself.
4. Control tree output semantics when needed
For a supported tree classifier, probability-space explanations must be explicit:
background = shap.sample(X_train, 200, random_state=7)
explainer = shap.TreeExplainer(
model,
data=shap.maskers.Independent(background, max_samples=len(background)),
feature_perturbation="interventional",
model_output="probability",
)
probability_exp = explainer(X_test)A bare background frame is capped at 100 rows by the default masker. The explicit masker above retains all 200 sampled rows; inspect len(explainer.data) when reporting or comparing background sizes.
In SHAP 0.52:
feature_perturbation="auto"uses interventional semantics when background data is supplied and tree-path-dependent semantics otherwise;probability and log-loss output modes are supported only with interventional semantics;
pass
approximate=Truetoexplainer(X, approximate=True)if deliberately using the lower-fidelity tree approximation; do not pass it to the constructor.
5. Use a model-agnostic callable deliberately
Pass the exact callable whose outputs will be interpreted:
masker = shap.maskers.Independent(background, max_samples=100)
explainer = shap.Explainer(
model.predict_proba,
masker,
algorithm="permutation",
output_names=[str(label) for label in model.classes_],
seed=7,
)
budget = 2 * X_test.shape[1] + 1
all_outputs = explainer(X_test.iloc[:20], max_evals=budget)
# 0.52 selector dispatch may drop output_names for permutation.
all_outputs.output_names = [str(label) for label in model.classes_]
positive = all_outputs[..., 1]Increase max_evals to average over more permutations when estimates are unstable. Keep the seed, background sample, and evaluation budget in the report.
6. Visualize the question, not merely the available plot
| Question | Plot |
|---|---|
| Which features have the largest average attribution magnitude? | shap.plots.bar(exp) |
| How do direction, magnitude, and observed values vary globally? | shap.plots.beeswarm(exp) |
| Why did one prediction differ from its baseline? | shap.plots.waterfall(exp[i]) |
| How does one feature's attribution vary over its values? | shap.plots.scatter(exp[:, feature]) |
| Do explanations form sample-level patterns? | shap.plots.heatmap(exp) |
| How do predefined cohorts differ descriptively? | shap.plots.bar(exp.cohorts(labels).abs.mean(0)) |
| Which tokens or image regions contribute to an output? | shap.plots.text(exp) or shap.plots.image(exp) |
Read references/plots.md before customizing or saving figures.
7. Report limitations with results
At minimum, report:
output and units;
baseline/reference population;
explainer and masker;
sample count and selection;
output index/name;
additivity error or applicable approximation diagnostics;
known correlated/grouped features;
whether results are local, aggregated, or cohort-specific;
a clear non-causal statement.
Common Tasks
Global and local analysis
Use global plots to locate important patterns, scatter plots to inspect those patterns, and local plots to investigate selected rows. Do not select only visually dramatic rows without documenting the selection rule.
Multiclass models
Set output_names where possible, inspect explanation.output_names, and slice an output before plotting:
class_exp = explanation[..., list(explanation.output_names).index("class_name")]
# or
class_exp = explanation[..., class_index]In 0.52.0, the generic permutation selector may drop supplied output names, and combining an ellipsis with a string output index can fail. Verify the class mapping, set names explicitly when needed, and resolve names to integer indexes before slicing.
Never average signed attributions across classes. For cross-class comparison, preserve the same model, rows, background, output space, and aggregation.
Cohorts, subgroup analysis, and fairness
SHAP can compare how a model uses features across cohorts, but this is not a fairness test. A protected feature with small SHAP magnitude does not rule out proxy discrimination, and removing a protected feature does not establish fairness. Pair attribution analysis with performance, calibration, error-rate, and domain-appropriate fairness metrics.
See references/workflows.md for cohort construction, model comparison, error analysis, log-loss explanations, monitoring, and production records.
Text and images
Use domain maskers rather than treating tokens or pixels as ordinary independent columns:
shap.maskers.Text(tokenizer)withPartitionExplainerfor token groups;shap.maskers.Image(...)withPartitionExplainerfor image regions;restrict expensive multi-output models with
outputs=....
Read references/modalities.md for current examples and output-shape guidance.
Troubleshooting Order
Print Python, SHAP, model-library, NumPy, and framework versions.
Verify the model receives exactly the same transformed columns, order, dtype, and missing-value representation used during fitting.
Print
values.shape,base_values.shape,data.shape,feature_names, andoutput_names.Confirm the selected output and output units.
Recompute predictions on the same rows in the same order.
Test a smaller batch and representative background.
Only then investigate package-specific compatibility or approximation settings.
Use references/troubleshooting.md for additivity failures, shape mismatches, categorical features, pipelines, deep-learning frameworks, plotting, and performance.
Bundled Script
Run a deterministic, self-contained tabular example that writes importance data, metadata, and plots:
uv run --no-project --python 3.12 --with "shap[plots]==0.52.0" \
skills/shap/scripts/tabular_report.py --output-dir /tmp/shap-reportThe script labels the default output as benign probability, retains the requested background up to the training-set size, and rejects non-finite validation tolerances. Its synthetic software checks and built-in dataset demo do not validate causal or clinical claims. Some SHAP 0.52.0 forest configurations fail explicit reconstruction (including seed 3 with 150 background rows); the script rejects those without writing report artifacts. See references/troubleshooting.md.
It exports feature_importance.csv, first_row_contributions.csv, prediction_reconstruction.csv, and metadata.json, plus bar.png, beeswarm.png, waterfall-first-row.png, and scatter-top-feature.png. Plot titles identify the selected class probability.
The script does not download data or deserialize models. Read it as a template, then replace the built-in dataset and model while preserving output selection and additivity validation.
Reference Map
| File | Load when |
|---|---|
| references/explainers.md | Selecting or configuring explainers |
| references/data-maskers.md | Choosing background data, masking semantics, or feature groups |
| references/plots.md | Selecting, composing, or saving visualizations |
| references/workflows.md | Running audits, comparisons, cohorts, monitoring, or production workflows |
| references/modalities.md | Explaining text, images, or deep models |
| references/migration.md | Updating legacy SHAP code or supporting older Python |
| references/theory.md | Explaining estimands, guarantees, dependence, interactions, and limitations |
| references/troubleshooting.md | Diagnosing runtime, shape, additivity, and compatibility problems |
Primary Sources
Documentation: https://shap.readthedocs.io/en/latest/
API reference: https://shap.readthedocs.io/en/latest/api.html
Release notes: https://shap.readthedocs.io/en/latest/release_notes.html
Repository: https://github.com/shap/shap
Citing Scientific Agent Skills
This skill is part of Scientific Agent Skills by K-Dense. If it materially contributed to a manuscript, report, presentation, or code release, add the paper to the references or software section and tell the user you did so:
Kassis, T., Agarwal, V., He, Y., Patel, D., & Brueckner, A. M. (2026). Scientific Agent Skills: A Library of Procedural Knowledge for Research Agents. arXiv:2609.00065. https://doi.org/10.48550/arXiv.2609.00065
Always cite the current version. The DOI and https://arxiv.org/abs/2609.00065 resolve to the
latest arXiv version, so never append a version suffix such as v1. When network access is
available, fetch https://arxiv.org/abs/2609.00065 (or
http://export.arxiv.org/api/query?id_list=2609.00065) before writing the reference and take
the author list, year, and version from that record. If the record lists a journal reference
or publisher DOI, cite the published version instead.
Files
- ATTRIBUTION.mdAdded by AutoGineer898 B
- LICENSELicence file added by AutoGineer1.0 KiB
- SKILL.md16.1 KiB
- references/data-maskers.md11.6 KiB
- references/explainers.md17.5 KiB
- references/migration.md9.8 KiB
- references/modalities.md12.3 KiB
- references/plots.md12.2 KiB
- references/theory.md12.7 KiB
- references/troubleshooting.md14.3 KiB
- references/workflows.md19.3 KiB
- scripts/tabular_report.pyScript11.1 KiB
references/theory.md
SHAP Theory and Interpretation
SHAP applies Shapley-style credit allocation to model explanations. The numerical result is defined by more than the fitted model: it also depends on the model output, background distribution, masking rule, and any coalition constraints.
Additive Explanation
For one scalar model output and one row x, SHAP constructs an additive decomposition:
f_explained(x) = base_value + sum_i phi_i(x)f_explainedis the exact output selected for explanation.base_valueis the expected output under the explainer's reference game.phi_iis the attribution assigned to featurei.
For modern tabular shap.Explanation objects:
reconstructed = explanation.base_values + explanation.values.sum(axis=1)The equation is meaningful only when the output units are known. A raw margin, probability, log loss, and logit are different quantities.
Cooperative-Game Formulation
Let F be the set of features and v(S) the value assigned to coalition S. A Shapley value for feature i is:
phi_i =
sum over S subset of F \ {i}
[ |S|! (|F|-|S|-1)! / |F|! ]
* [v(S union {i}) - v(S)]This averages the marginal contribution of i over all feature orderings.
In machine learning, defining v(S) is the hard part because a model normally requires all inputs. The masker and background distribution specify how hidden features are integrated or imputed.
What the Axioms Mean
Classic Shapley values satisfy:
Efficiency: all feature values sum to the coalition payoff difference.
Symmetry: interchangeable players receive equal credit.
Dummy/null player: a player with no marginal contribution receives zero.
Additivity: values for combined games are sums of values for component games.
The SHAP paper describes related properties for additive feature-attribution methods:
Local accuracy: the additive explanation reconstructs the selected output.
Missingness: absent simplified inputs receive zero attribution under the formulation.
Consistency: if a feature's marginal contribution increases for every coalition, its attribution does not decrease.
These are mathematical allocation properties. They do not mean:
ethical or legal fairness;
causal correctness;
robustness to distribution shift;
truthfulness of the fitted model;
stability under a different background or masker.
Avoid calling SHAP values "fair" without specifying that the term refers only to a cooperative-game allocation axiom.
The Value Function Is Part of the Result
Common tabular games include:
Marginal/interventional game
Hidden features are sampled from a background distribution independently of the observed features.
Conceptually:
v(S) = E_background[f(x_S, X_not_S)]Advantages:
clear reference population;
preserves the dummy property with respect to direct model use;
straightforward model-agnostic masking.
Limitations:
can evaluate unrealistic combinations;
can be sensitive to the selected background;
"interventional" in the API name does not make the resulting predictive explanation a causal effect.
Conditional game
Hidden features are drawn from a distribution conditional on observed features:
v(S) = E[f(X) | X_S = x_S]Advantages:
can stay closer to the observed data manifold;
incorporates statistical dependence.
Limitations:
requires estimating conditional distributions;
can assign credit to a feature the model does not directly use;
dependence can be mistaken for causation;
estimates can be unstable in sparse regions.
Partitioned game
Only coalitions compatible with a hierarchy are considered. The resulting allocations are Owen values.
Advantages:
respects semantic or statistical groups;
makes structured high-dimensional problems more tractable;
reduces arbitrary competition among related features.
Limitation: the hierarchy is an assumption and changes the game.
There is no universal answer to "the SHAP value" without specifying the game.
Background and Baseline
The base value is the reference-game expectation, not automatically:
the overall target mean;
the model intercept;
class prevalence;
a neutral patient/customer;
a decision threshold.
Different backgrounds can change:
base values;
signed local attributions;
mean absolute global rankings;
cohort comparisons.
Treat background sensitivity as a substantive analysis, not just a runtime check.
Output Scale
SHAP values use the additive scale selected by the explainer.
Examples:
regression prediction in target units;
binary tree margin in log-odds;
class probability;
per-row log loss;
transformed output under a link function.
A display transform such as link="logit" on a force plot changes labels, not the computed SHAP game. If probability-space additivity is required for supported trees, configure TreeExplainer(model_output="probability", feature_perturbation="interventional", data=...).
Do not compare mean absolute SHAP magnitudes across models or outputs on different scales.
Local and Global Quantities
Local attribution:
phi_i(x)Global mean absolute attribution:
E_x[abs(phi_i(x))]Mean absolute attribution:
discards direction;
depends on the evaluated sample distribution;
is not normalized predictive performance;
is not a causal effect size.
Mean signed attribution can cancel heterogeneous effects. Plot the distribution before summarizing.
Exact and Approximate Algorithms
Unconstrained exact Shapley computation grows exponentially with feature count. SHAP uses model-specific algorithms or sampling:
Tree SHAP: exploits tree structure and is exact for the selected tree game.
Linear SHAP: closed-form or transformation-based allocation for supported linear games.
ExactExplainer: optimized enumeration for small or hierarchically constrained inputs.
PermutationExplainer: averages forward/reverse feature orderings.
KernelExplainer: estimates values through a weighted linear regression over coalitions.
DeepExplainer: combines DeepLIFT-style rules with multiple background samples.
GradientExplainer: uses expected gradients.
PartitionExplainer: exploits a coalition hierarchy.
"Exact" always means exact under a specified output, background, masker, and coalition game.
Interaction Values
Tree SHAP can decompose attribution into a symmetric interaction matrix.
For one row:
diagonal entries are main effects;
off-diagonal entries are pairwise interaction allocations;
each row sums to that feature's ordinary SHAP value;
the full matrix sums to the prediction difference from baseline.
interaction_explainer = shap.TreeExplainer(
model, model_output="raw", feature_perturbation="tree_path_dependent",
)
interaction = interaction_explainer.shap_interaction_values(X_eval)In 0.52.0, do not reuse an interventional/probability explainer for this operation; that path either rejects it or does not implement interactions. Each symmetric off-diagonal entry is half the pair contribution. Validate row sums against the same path-dependent ordinary SHAP values.
An interaction value describes non-additivity in the fitted model under the chosen game. It does not prove biological, physical, or causal interaction.
Scatter-plot vertical dispersion is only a clue; compute or test interactions before labeling them.
Correlation and Credit Sharing
When two features contain similar information, multiple allocations can be defensible:
marginal values emphasize direct functional use by the model;
conditional values share credit through dependence;
grouped values assign credit to the coalition.
Instability across folds, seeds, backgrounds, or equivalent model fits is evidence that individual attribution is not uniquely supported by the problem. Report grouped results or sensitivity rather than selecting one convenient ranking.
SHAP Is Not Causal
SHAP makes predictive relationships visible. A positive attribution does not imply that increasing the feature would increase the real-world outcome.
Confounding, mediation, reverse causality, selection bias, and feature redundancy can all make predictive patterns unsuitable for intervention.
Use causal language only when:
the model and estimand are explicitly causal;
identification assumptions are stated;
data collection supports those assumptions;
the SHAP use is integrated into that causal analysis.
Even then, describe exactly what quantity is attributed.
SHAP Is Not a Fairness Certificate
Attribution can help investigate:
whether a model directly uses a protected feature;
whether potential proxies have large or heterogeneous attributions;
how explanation distributions differ across groups;
which features contribute to errors or loss.
It cannot alone establish:
demographic parity;
equalized odds/opportunity;
calibration by group;
absence of proxy discrimination;
individual fairness;
compliant recourse.
Protected-feature attribution can be small while proxies drive disparities. Conditional attributions can also assign protected-feature credit even when the model does not directly consume it. Pair SHAP with outcome, error, calibration, threshold, and data-quality analyses.
SHAP Is Not Recourse
A waterfall answers "how this model output is allocated relative to this reference." It does not answer:
which feature can feasibly be changed;
what the outcome would be after intervention;
whether downstream features would change;
what the minimal safe action is.
Use dedicated counterfactual/recourse methods with feasibility and causal constraints.
Uncertainty and Stability
A standard SHAP plot usually shows point estimates, not uncertainty.
Sources of variation include:
model fitting sample and seed;
hyperparameters;
background sample;
evaluation cohort;
approximation seed and budget;
conditional-distribution estimation;
preprocessing and feature grouping.
Useful stability analyses:
bootstrap or cross-fit the model;
repeat background sampling;
repeat approximation seeds;
compare rankings and signed distributions;
report intervals or rank stability;
separate model uncertainty from explainer approximation uncertainty.
Comparisons With Other Importance Measures
Permutation importance
Measures predictive performance degradation after shuffling a feature.
global, metric-dependent;
can be distorted by correlated features;
does not decompose individual predictions.
Split/gain importance
Summarizes how a tree used features during fitting.
fast;
can favor high-cardinality or frequently split features;
does not provide local output decomposition.
Linear coefficients
Describe change per input unit on the model's linear scale.
depend on feature scale and parameterization;
do not include how far a row is from the reference.
Partial dependence
Averages predictions while varying a feature.
describes an average response surface;
can evaluate off-manifold combinations;
does not allocate each individual prediction.
These answer different questions. Agreement is reassuring but not proof; disagreement should trigger an assumptions review.
Interpretation Checklist
Before making a claim:
[ ] Name the model output and units.
[ ] Define background and masking semantics.
[ ] Identify the selected row/cohort and sampling rule.
[ ] Verify additivity where applicable.
[ ] State whether estimates are exact or approximate.
[ ] Check correlation and grouping sensitivity.
[ ] Separate local from global claims.
[ ] Avoid causal, fairness, and recourse claims without separate evidence.
[ ] Report model performance and relevant uncertainty.
Sources
Lundberg & Lee (2017), "A Unified Approach to Interpreting Model Predictions": https://proceedings.neurips.cc/paper/2017/hash/8a20a8621978632d76c43dfd28b67767-Abstract.html
Lundberg et al. (2020), "From local explanations to global understanding with explainable AI for trees": https://www.nature.com/articles/s42256-019-0138-9
SHAP introduction: https://shap.readthedocs.io/en/latest/example_notebooks/overviews/An%20introduction%20to%20explainable%20AI%20with%20Shapley%20values.html
Causal interpretation caution: https://shap.readthedocs.io/en/latest/example_notebooks/overviews/Be%20careful%20when%20interpreting%20predictive%20models%20in%20search%20of%20causal%20insights.html
Explaining quantitative fairness measures: https://shap.readthedocs.io/en/latest/example_notebooks/overviews/Explaining%20quantitative%20measures%20of%20fairness.html
Janzing, Minorics & Blöbaum (2020), "Feature relevance quantification in explainable AI: A causal problem": https://proceedings.mlr.press/v108/janzing20a.html
Requirements and compatibility
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Needs: Declares allowed tools, Needs network access, Needs Python
The author says: Requires Python 3.12+ and uv for SHAP 0.52.0; model-specific libraries are optional.
Security
What our scanner noticed· Low risk
- Instructions that use the network
- Scripts that your agent may run
This skill includes scripts that your agent may run. Read them before you use it.
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Created by
- K-Dense Inc.
- Publisher
- K-Dense (Community)
- Source
- K-Dense-AI/scientific-agent-skills · skills/shap · commit a25cf9e
- Licence
- MIT License (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE.md)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by K-Dense Inc. or K-Dense.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download shap.zip