awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com

Machine Learning Model Interpretability Tools

Ranking updated Jun 30, 2026

For a framework for interpreting machine learning models, the first results are shap/shap, slundberg/shap (SHAP is a comprehensive explainable AI library that uses Shapley values to provide global and local feature importance for any model, with optimized explainers for trees, deep learning, and linear models, making it a leading tool for understanding model predictions) and marcotcr/lime. interpretml/interpret and pytorch/captum round out the shortlist. Compare the match explanations and check the project documentation against your requirements.

Explore libraries and frameworks designed to explain predictions and visualize decision-making processes in machine learning models.

Machine Learning Model Interpretability Tools

Find the best repos with AI.We'll search the best matching repositories with AI.
  • shap/shapshap avatar

    shap/shap

    25,049View on GitHub↗

    SHAP is an explainable AI toolkit that provides a game theoretic framework for interpreting machine learning model predictions. It functions as a feature attribution engine, decomposing model outputs into the sum of individual feature effects to clarify how specific input variables influence a final decision. By assigning importance values to these inputs, the library enables users to understand the logic behind complex predictive models. The project distinguishes itself through its versatility and specialized calculation methods. It operates as a model-agnostic diagnostic library, capable of

    SHAP is the definitive library for SHAP-based model interpretability, providing feature importance, visualization, and support for multiple model types with global and local explanations across scikit-learn, TensorFlow, and PyTorch — exactly the explainable AI toolkit this search asks for.

    Jupyter NotebookFeature Attribution EnginesFeature Attribution MethodsFeature Importance Attribution
    View on GitHub↗25,049
  • slundberg/shapslundberg avatar

    slundberg/shap

    25,535View on GitHub↗

    SHAP is a machine learning explainer that uses a game-theoretic framework to estimate the contribution of each feature to a model prediction. It provides a set of tools for quantifying how individual input features push a specific output away from a baseline value. The project includes specialized explainers for different architectures, including high-speed implementations for decision trees and ensemble models, linearization algorithms for deep learning networks, and covariance integration for linear models. It also features a model-agnostic interpretability tool that uses a kernel method to

    SHAP is a comprehensive explainable AI library that uses Shapley values to provide global and local feature importance for any model, with optimized explainers for trees, deep learning, and linear models, making it a leading tool for understanding model predictions.

    Jupyter NotebookFeature Importance AttributionSHAP Value ComputationsGame-Theoretic Explainers
    View on GitHub↗25,535
  • marcotcr/limemarcotcr avatar

    marcotcr/lime

    12,142View on GitHub↗

    This project is an agnostic model interpretability framework and explainability tool designed to provide local interpretable explanations for individual predictions. It functions as a local surrogate model that approximates the behavior of any machine learning classifier or regression model to identify the most influential features for a specific instance. The framework is designed to be model-agnostic, meaning it can explain predictions across tabular, text, and image data regardless of the underlying architecture. It employs local linear approximations and feature importance visualization t

    marcotcr/lime is the original LIME library, providing model-agnostic local explanations and feature importance for tabular, text, and image data, so it directly meets your need for understanding predictions, though it focuses on local interpretation and does not include SHAP support.

    JavaScriptFeature Importance AttributionLocal Surrogate ApproximationsLocal Interpretability Tools
    View on GitHub↗12,142
  • interpretml/interpretinterpretml avatar

    interpretml/interpret

    6,881View on GitHub↗

    Interpret is an interpretable machine learning library and glassbox model framework. It provides toolkits for training inherently transparent models and applying post-hoc explanation techniques to make machine learning predictions human-understandable. The framework distinguishes itself by integrating differential privacy into the training of interpretable models to prevent sensitive data from leaking through explanations. It also features a visualization tool for rendering interactive decision paths and model behavior. The library covers model explainability through feature importance calcu

    Interpret is a comprehensive library for model interpretability, offering built-in transparent models and post-hoc explanations including feature importance and interactive visualizations, which directly addresses the need to understand and explain ML predictions.

    C++Feature Importance AttributionModel Explanation Visualizations
    View on GitHub↗6,881
  • pytorch/captumpytorch avatar

    pytorch/captum

    5,652View on GitHub↗

    Captum is an open-source library for explaining model predictions by attributing them to input features, neurons, and layers using gradient-based and perturbation-based methods. It provides a modular framework for implementing, evaluating, and combining a range of explanation techniques, including gradient-based attribution, perturbation-based analysis, game-theoretic Shapley value approximation, and surrogate model explanations, with support for parallelization and noise stabilization. The library distinguishes itself through its breadth of attribution methods and its support for advanced in

    Captum is a model interpretability library for PyTorch that provides gradient-based, perturbation-based, and game-theoretic methods including Shapley value approximations and surrogate explanations (similar to LIME), making it a strong fit for explaining PyTorch models, though it does not directly integrate with scikit-learn or TensorFlow as requested.

    PythonFeature Attribution MethodsFeature Importance AttributionLocal Surrogate Explainers
    View on GitHub↗5,652
  • maif/shapashMAIF avatar

    MAIF/shapash

    3,223View on GitHub↗

    🔅 Shapash: User-friendly Explainability and Interpretability to Develop Reliable and Transparent Machine Learning Models

    Shapash is a dedicated Python library for model interpretability that bundles SHAP, LIME, and feature importance with rich visualizations, making it a strong fit for understanding ML model predictions across different model types.

    Jupyter NotebookExplainability and FairnessGeneral Machine LearningModel Interpretability
    View on GitHub↗3,223
  • pair-code/litPAIR-code avatar

    PAIR-code/lit

    3,636View on GitHub↗

    Lit is a machine learning interpretability framework and model debugging tool designed to analyze model behavior and performance. It serves as an interpretability dashboard for large language models and a general performance analyzer for text, image, and tabular datasets. The project distinguishes itself through a comprehensive suite of interpretability tools, including salience map generation for feature attribution, the creation of synthetic and counterfactual examples to test robustness, and the projection of high-dimensional embeddings into visual spaces via UMAP or PCA. It further enable

    LIT is a dedicated interpretability framework that offers salience maps, counterfactual generation, and embedding visualization for understanding model behavior across text, image, and tabular data, making it a solid choice for explainable AI even if it may not include SHAP or LIME implementations directly.

    TypeScriptFeature Importance AttributionModel Explanation VisualizationsModel Interpretability Frameworks
    View on GitHub↗3,636
  • transformerlensorg/transformerlensTransformerLensOrg avatar

    TransformerLensOrg/TransformerLens

    3,098View on GitHub↗

    TransformerLens is a library for mechanistic interpretability research designed to reverse engineer the learned algorithms within large language models. It provides a standardized framework for wrapping diverse transformer architectures, allowing researchers to extract, manipulate, and analyze internal activations and weights through a consistent interface. The project distinguishes itself through a comprehensive system of activation hooks that can capture, patch, and ablate internal tensors during the forward pass. It includes specialized utilities for decomposing fused projections, material

    TransformerLens is a library for mechanistic interpretability of transformer models, offering deep access to internal activations and weights—this matches the interpretability intent but is focused on a specific model architecture and does not include common model-agnostic methods like SHAP or LIME.

    PythonActivation and Gradient HookingActivation HookingInternal Activation Hooks
    View on GitHub↗3,098
  • albermax/innvestigatealbermax avatar

    albermax/innvestigate

    1,305View on GitHub↗

    A toolbox to iNNvestigate neural networks' predictions!

    albermax/innvestigate is a Python toolbox for investigating neural network predictions, directly fitting the search for explainable AI tools, though it is focused on deep neural networks and may not natively include SHAP/LIME or support for non-neural model types.

    PythonExplainable AI LibrariesModel Interpretability
    View on GitHub↗1,305
  • marcotcr/anchormarcotcr avatar

    marcotcr/anchor

    813View on GitHub↗

    Code for "High-Precision Model-Agnostic Explanations" paper

    Anchor implements the Anchor method for model-agnostic local explanations, directly serving the need to interpret individual predictions, though it is limited to this single approach and does not include SHAP, LIME, or global interpretation.

    Jupyter NotebookExplainable AI LibrariesModel Interpretation
    View on GitHub↗813
  • cdpierse/transformers-interpretcdpierse avatar

    cdpierse/transformers-interpret

    1,412View on GitHub↗

    Transformers-interpret is a diagnostic library designed for the interpretability of transformer-based machine learning models. It functions as an attribution framework that quantifies the contribution of individual input tokens to a model's final predictions, allowing users to audit decision patterns and debug natural language processing tasks. The library utilizes gradient-based analysis and hook-based introspection to trace how specific input features influence model outputs. By mapping abstract numerical attribution scores back to human-readable linguistic units, it provides a clear view o

    Transformers-Interpret is a dedicated model-explainability library for Hugging Face Transformer models, providing easy-to-use explanations for NLP tasks, though it focuses on this specific model family rather than the broader scope of tabular or image models or methods like SHAP and LIME.

    Jupyter NotebookFeature Importance AttributionModel Explanation VisualizationsModel Interpretability Frameworks
    View on GitHub↗1,412
  • rexying/gnn-model-explainerRexYing avatar

    RexYing/gnn-model-explainer

    1,051View on GitHub↗

    This toolkit serves as a framework for interpreting the decision-making processes of graph neural networks. It functions as a library for analyzing how these models process complex network data, providing methods to identify the specific node attributes and structural patterns that influence predictive outcomes. The project distinguishes itself by employing mask-optimized subgraph extraction and gradient-based attribution mapping to isolate the minimal components of a graph that preserve a model's original prediction. By separating graph processing layers from explanation logic, the architect

    This repository is a tool for explaining graph neural network (GNN) models, which fits the model interpretability category, but it is specialized to GNNs and does not offer the broader model-type support (tabular, text, image) or specific methods like SHAP and LIME that the search requests.

    PythonFeature Importance AttributionModel Explanation Visualizations
    View on GitHub↗1,051
  • jacobgil/vit-explainjacobgil avatar

    jacobgil/vit-explain

    1,090View on GitHub↗

    Vit-explain is a diagnostic framework designed to interpret the decision-making processes of vision transformer models. It functions as a toolkit for inspecting internal model states, allowing users to map visual attention and analyze how specific image features influence classification outcomes. The project distinguishes itself by providing post-hoc model interpretation, which enables the analysis of trained neural networks without requiring architectural modifications or retraining. It employs techniques such as hook-based feature extraction to intercept internal activations during the forw

    It is a specialized tool for explaining Vision Transformer predictions, so it fits the search for a model interpretability library, albeit limited to a single model type and lacking broader features like SHAP and LIME.

    PythonDeep Learning InterpretabilityTransformer ExplainabilityArchitecture Interpretation
    View on GitHub↗1,090
Compare the top 10 at a glance
RepositoryStarsLanguageLicenseLast push
shap/shap25KJupyter NotebookmitFeb 19, 2026
slundberg/shap25.5KJupyter NotebookMITJun 15, 2026
marcotcr/lime
12.1K
JavaScript
BSD-2-Clause
Jul 25, 2024
interpretml/interpret6.9KC++MITJun 22, 2026
pytorch/captum5.7KPythonBSD-3-ClauseJun 16, 2026
maif/shapash3.2KJupyter NotebookApache-2.0Jun 15, 2026
pair-code/lit3.6KTypeScriptapache-2.0Feb 20, 2026
transformerlensorg/transformerlens3.1KPythonmitFeb 20, 2026
albermax/innvestigate1.3KPythonNOASSERTIONApr 11, 2025
marcotcr/anchor813Jupyter NotebookBSD-2-ClauseJul 19, 2022

Related searches

  • a framework for ML-driven trading
  • a machine learning framework for time-series forecasting
  • a low code dashboard for machine learning
  • an automated machine learning framework for tuning
  • a tool for monitoring model drift in production
  • a framework for evaluating LLM output quality
  • a structured path into ML engineering
  • a gradient boosting library for tabular data