sklearn-explainability
Advanced sub-skill for scikit-learn focused on model interpretability, feature importance, and diagnostic tools. Covers global and local explanations using built-in inspection tools and SHAP/LIME integrations.
Best use case
sklearn-explainability is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Advanced sub-skill for scikit-learn focused on model interpretability, feature importance, and diagnostic tools. Covers global and local explanations using built-in inspection tools and SHAP/LIME integrations.
Teams using sklearn-explainability should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/sklearn-explainability/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How sklearn-explainability Compares
| Feature / Agent | sklearn-explainability | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Advanced sub-skill for scikit-learn focused on model interpretability, feature importance, and diagnostic tools. Covers global and local explanations using built-in inspection tools and SHAP/LIME integrations.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# scikit-learn - Explainability & Interpretability
In scientific research, a model's "why" is as important as its "what". This guide focuses on tools that reveal the decision-making process of machine learning models, ensuring they are scientifically valid and not just overfitting on artifacts.
## When to Use
- Validating that a model uses physically meaningful features (e.g., in drug discovery).
- Identifying biases or "shortcuts" the model has learned from the training data.
- Explaining individual predictions to non-experts (Local explanations).
- Ranking the global impact of variables on a complex system (Global explanations).
- Scientific auditing and regulatory compliance.
## Core Principles
### 1. Model-Specific vs. Model-Agnostic
- **Model-Specific**: Tools like `feature_importances_` in Random Forests. Fast but tied to one architecture.
- **Model-Agnostic**: Tools like SHAP or Permutation Importance. Work on any model (SVM, MLP, etc.) but are more compute-intensive.
### 2. Global vs. Local Explanations
- **Global**: How does the feature "Temperature" affect the model overall?
- **Local**: Why did the model predict "Reaction Failed" for this specific sample?
### 3. Feature Importance vs. Feature Contribution
Importance tells you if a feature is used; Contribution tells you how it changed the output (positive or negative).
## Quick Reference: Built-in Inspection
```python
from sklearn.inspection import permutation_importance, PartialDependenceDisplay
# 1. Permutation Importance (Better than default tree importance)
result = permutation_importance(model, X_test, y_test, n_repeats=10)
print(result.importances_mean)
# 2. Partial Dependence Plots (How one feature affects prediction)
PartialDependenceDisplay.from_estimator(model, X, features=['temp', 'pressure'])
```
## Critical Rules
### ✅ DO
- **Prefer Permutation Importance over default RandomForest.feature_importances_** - Default importance is biased toward high-cardinality features (like unique IDs).
- **Use PartialDependenceDisplay** - To visualize the relationship between a feature and the target (Linear, Exponential, or Sigmoid).
- **Scale Features before Interpretability** - Many models (like Logistic Regression) require scaling for their coefficients (β) to be comparable.
- **Check Feature Correlations** - If two features are highly correlated, importance will be split between them, making both look "less important" than they are.
### ❌ DON'T
- **Don't trust coefficients (β) of unregularized models** - High variance in coefficients can lead to false conclusions about feature importance.
- **Don't use Feature Importance on Training Data** - Always calculate it on the Test Set to see what features actually help with generalization.
- **Don't confuse Correlation with Causation** - ML models show which features are predictive, not necessarily which ones are causative.
## Interpretation Patterns
### 1. SHAP Integration (The Gold Standard)
```python
import shap
# Works for any scikit-learn model
explainer = shap.Explainer(model.predict, X_test)
shap_values = explainer(X_test)
# Visualize global importance
shap.plots.bar(shap_values)
# Visualize local explanation for the first sample
shap.plots.waterfall(shap_values[0])
```
### 2. Partial Dependence (PDP) for Science
```python
from sklearn.inspection import PartialDependenceDisplay
# Check if the model learned the correct physical law
# (e.g., does the reaction rate increase with temperature?)
fig, ax = plt.subplots(figsize=(8, 4))
PartialDependenceDisplay.from_estimator(model, X, [0, (0, 1)], ax=ax)
# [0] is a 1D plot, [(0, 1)] is a 2D interaction plot
```
### Advanced: Feature Contribution (ELI5 style)
For a single prediction, see which features pushed it towards which class.
```python
def explain_prediction(model, sample):
# For linear models, this is: intercept + sum(coef * value)
prediction = model.predict_proba(sample)
# ... logic to map coefficients to feature names ...
pass
```
## Practical Workflows: Validating a Scientific Model
### Step 1: Detect "Leakage" Features
If a feature has 99% importance and wasn't expected to, it's likely a data leak (e.g., a sample timestamp or ID).
### Step 2: Stability Analysis
Run permutation importance with different random seeds. If the top features change significantly, the model is unstable and unreliable.
### Step 3: Interaction Check
Use 2D PDP to see if the model captured the interaction between features (e.g., Pressure only matters if Temperature > 100°C).
## Common Pitfalls
### The "Default Importance" Bias
In RandomForest, features with many categories (like Serial_Number) look very important because the tree can split on them many times.
```python
# ✅ Solution: Use Permutation Importance on the test set instead.
```
### Multicollinearity Ghosting
If Feature_A and Feature_B are 100% correlated, the model might only use one.
```python
# ✅ Solution: Use hierarchical clustering on features or check VIF
# before interpreting importance.
```
Explainability turns Machine Learning into a true scientific tool. It allows researchers to move beyond the "Black Box" and extract new hypotheses directly from trained models.Related Skills
sklearn-advanced
Professional sub-skill for scikit-learn focused on robust pipeline architecture, custom estimator development, advanced feature engineering, and rigorous model validation. Covers Target Encoding, Nested Cross-Validation, and Production Deployment.
xgboost-lightgbm
Industry-standard gradient boosting libraries for tabular data and structured datasets. XGBoost and LightGBM excel at classification and regression tasks on tables, CSVs, and databases. Use when working with tabular machine learning, gradient boosting trees, Kaggle competitions, feature importance analysis, hyperparameter tuning, or when you need state-of-the-art performance on structured data.
xarray
N-dimensional labeled arrays and datasets in Python. Built on top of NumPy and Dask. It introduces labels in the form of dimensions, coordinates, and attributes on top of raw NumPy-like arrays, making data analysis in physical sciences more intuitive and less error-prone. Use for working with multi-dimensional scientific data, NetCDF/GRIB/Zarr files, climate/weather/oceanographic datasets, remote sensing, geospatial imaging, large out-of-memory datasets with Dask, and labeled array operations.
transformers
State-of-the-art Machine Learning for PyTorch, TensorFlow, and JAX. Provides thousands of pretrained models to perform tasks on different modalities such as text, vision, and audio. The industry standard for Large Language Models (LLMs) and foundation models in science.
tqdm
A fast, extensible progress bar for Python and CLI. Instantly makes your loops show a smart progress meter with ETA, iterations per second, and customizable statistics. Minimal overhead. Use for monitoring long-running loops, simulations, data processing, ML training, file downloads, I/O operations, command-line tools, pandas operations, parallel tasks, and nested progress bars.
tensorflow
Comprehensive deep learning framework for building, training, and deploying neural networks. TensorFlow provides tf.keras high-level API for model construction, tf.data for efficient data pipelines, and tf.function for graph-mode optimization. Use when working with: neural network training and inference, image classification/detection/segmentation, NLP/text processing with embeddings or transformers, time series forecasting, generative models (VAE, GAN), transfer learning with pretrained models, custom training loops with GradientTape, GPU/TPU accelerated computation, or any deep learning task.
sympy
Comprehensive guide for SymPy - Python library for symbolic mathematics. Use for symbolic expressions, calculus (derivatives, integrals, limits, series), equation solving (algebraic, differential, systems), linear algebra, simplification, matrix operations, special functions, code generation, and mathematical proofs. Essential for analytical mathematics and computer algebra.
sunpy
The community-developed free and open-source software package for solar physics. Provides tools for data search and download, coordinate transformations specific to solar physics, and powerful image processing through the Map object. Use when working with solar data, solar images (EUV, magnetograms, white light), solar coordinates (Helioprojective, Heliographic), Fido data search, solar time series, differential rotation, limb fitting, or multi-instrument solar analysis (AIA, HMI, GOES).
statsmodels
Advanced statistical modeling and hypothesis testing. Complementary to SciPy's stats module, it provides classes and functions for the estimation of many different statistical models, as well as for conducting statistical tests and statistical data exploration. Use for linear regression, GLM, time series analysis, ANOVA, survival analysis, causal inference, and statistical hypothesis testing. Load when working with OLS, WLS, logistic regression, Poisson regression, ARIMA, SARIMAX, statistical diagnostics, p-values, confidence intervals, or R-style statistical analysis.
spacy-nltk
Natural Language Processing for text analysis, corpus linguistics, and production NLP pipelines. spaCy provides fast production-grade tokenization, POS tagging, NER, dependency parsing, and custom model training. NLTK provides classical corpus linguistics, linguistic analysis, VADER sentiment, collocation analysis, and access to standard linguistic corpora. Use when: processing and analyzing text data, extracting named entities (people, orgs, locations, dates), dependency parsing and syntactic analysis, building text classification pipelines, performing corpus-level linguistic analysis (frequency, collocations, readability), sentiment analysis, lemmatization and stemming, working with multilingual text, training custom NER or text classifiers, or any task requiring structured understanding of natural language beyond simple string operations.
sktime-tsfresh
Time series machine learning layer (Tier 1): integration of **sktime** and **tsfresh** for building production-grade pipelines that transform raw time series into tabular feature representations suitable for classical machine-learning models. *sktime* provides a unified, sklearn-compatible interface for time-series data types, transformations, and pipelines, while *tsfresh* enables large-scale automated extraction of statistical, spectral, and autocorrelation features, with optional statistically grounded feature relevance selection (FRESH).
simpy
A process-based discrete-event simulation framework. Use for modeling queuing systems, supply chains, manufacturing processes, network simulation, project management, and any system where events occur at specific points in time. Load when working with discrete event simulation, process modeling, resource allocation, virtual time, simpy.Environment, simpy.Resource, or event-driven simulation.