Implement Explainable AI Frameworks

This skill covers designing interpretable machine learning systems and implementing post-hoc explanation methods for AI model transparency. It distinguishes interpretability (how well humans understand a model's decisions without extra help) from explainability (the ability to give human-understandable reasons for outputs), and global explanations (overall model behavior) from local ones (individual predictions) and counterfactual explanations (what would need to change for a different outcome) - organized into a taxonomy of model-agnostic methods (LIME, SHAP, permutation importance), model-specific methods (attention maps, gradient-based techniques), ante-hoc interpretability (linear models, decision trees), and post-hoc methods (feature importance, example-based explanations).

It provides working implementations for SHAP (tree, kernel, and linear explainers, per-instance SHAP values, and a global feature-importance report), LIME (a tabular explainer with configurable feature counts and sample sizes), and a combined XAI framework that generates global explanations via permutation importance and partial dependence, local explanations by running SHAP and LIME together, and simplified counterfactual explanations through feature perturbation search. For deep learning specifically, it covers Integrated Gradients, GradientSHAP, and occlusion-based attribution via Captum.

It also covers evaluation: a faithfulness score that removes an explanation's top-k important features and measures how much the prediction changes, and a stability score that perturbs an instance with noise and measures correlation across the resulting explanations. Best-practice guidance spans implementation standards (validating findings across multiple explanation methods, involving domain experts, tailoring explanation complexity to the audience, monitoring explanation quality over time, and using explanations to detect model bias), deployment considerations (balancing explanation quality against inference speed, caching explanations, versioning them alongside models, and regulatory compliance), and named pitfalls (over-relying on a single method, cherry-picking favorable explanations, ignoring uncertainty, letting explanations go stale as models evolve, and leaving technical jargon untranslated for non-technical stakeholders).

def initialize_explainer(self, explainer_type='tree'):
    """Initialize appropriate SHAP explainer"""
    if explainer_type == 'tree':
        self.explainer = shap.TreeExplainer(self.model)
    elif explainer_type == 'kernel':
        self.explainer = shap.KernelExplainer(
            self.model.predict_proba, self.background_data
        )
    elif explainer_type == 'linear':
        self.explainer = shap.LinearExplainer(
            self.model, self.background_data
        )

Use this skill when you need to make an ML model's predictions interpretable - implementing SHAP, LIME, counterfactual, or deep-learning attribution explanations, evaluating explanation faithfulness and stability, or building explanation caching and versioning into a production deployment.

It is not a fit for choosing or training the underlying model itself - the guidance assumes a trained model already exists and focuses entirely on explaining its behavior, not on model selection or training.

Inputs are a trained model, training/background data, and the instances you need explained (for local explanations) or the full dataset (for global explanations). Outputs are SHAP values and global feature importance, LIME explanations, counterfactual instances, deep-learning attribution maps, and faithfulness/stability scores for evaluating the explanations themselves.

Built on SHAP, LIME (lime.lime_tabular), scikit-learn's permutation importance and partial dependence utilities, and Captum (Integrated Gradients, GradientSHAP, Occlusion) for PyTorch-based deep learning models.

ML engineers and data scientists who need to add interpretability to a deployed or soon-to-deploy model - for regulatory compliance, bias detection, or stakeholder trust - and want concrete, working explainer implementations plus a way to evaluate whether the explanations themselves are trustworthy, rather than assembling XAI tooling from separate library docs.