awesome-repositories.com
Blog
awesome-repositories.com

Descubre los mejores repositorios open-source con nuestra búsqueda potenciada por IA.

ExplorarBúsquedas curadasAlternativas open-sourceSoftware autohospedableBlogMapa del sitio
ProyectoAcerca deCómo clasificamosPrensaServidor MCP
Aviso legalPrivacidadTérminos
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

Herramientas de interpretabilidad para modelos de Machine Learning

Clasificación actualizada el 30 jun 2026

For un framework para interpretar modelos de machine learning, the strongest matches are shap/shap (SHAP is the definitive library for SHAP-based model interpretability), slundberg/shap (SHAP is a comprehensive explainable AI library that uses) and marcotcr/lime (marcotcr/lime is the original LIME library, providing model-agnostic local). interpretml/interpret and pytorch/captum round out the shortlist. Each is ranked by relevance to your query, popularity and recent activity.

Explora librerías y frameworks diseñados para explicar predicciones y visualizar los procesos de toma de decisiones en modelos de machine learning.

Herramientas de interpretabilidad para modelos de Machine Learning

Encuentra los mejores repositorios con IA.Buscaremos los repositorios que mejor coincidan usando IA.
  • shap/shapAvatar de shap

    shap/shap

    25,049Ver en 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
    Ver en GitHub↗25,049
  • slundberg/shapAvatar de slundberg

    slundberg/shap

    25,535Ver en 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
    Ver en GitHub↗25,535
  • marcotcr/limeAvatar de marcotcr

    marcotcr/lime

    12,142Ver en 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
    Ver en GitHub↗12,142
  • interpretml/interpretAvatar de interpretml

    interpretml/interpret

    6,881Ver en 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
    Ver en GitHub↗6,881
  • pytorch/captumAvatar de pytorch

    pytorch/captum

    5,652Ver en 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
    Ver en GitHub↗5,652
  • maif/shapashAvatar de MAIF

    MAIF/shapash

    3,223Ver en 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
    Ver en GitHub↗3,223
  • pair-code/litAvatar de PAIR-code

    PAIR-code/lit

    3,636Ver en 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
    Ver en GitHub↗3,636
  • transformerlensorg/transformerlensAvatar de TransformerLensOrg

    TransformerLensOrg/TransformerLens

    3,098Ver en 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
    Ver en GitHub↗3,098
  • albermax/innvestigateAvatar de albermax

    albermax/innvestigate

    1,305Ver en 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
    Ver en GitHub↗1,305
  • marcotcr/anchorAvatar de marcotcr

    marcotcr/anchor

    813Ver en 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
    Ver en GitHub↗813
  • cdpierse/transformers-interpretAvatar de cdpierse

    cdpierse/transformers-interpret

    1,412Ver en 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
    Ver en GitHub↗1,412
  • rexying/gnn-model-explainerAvatar de RexYing

    RexYing/gnn-model-explainer

    1,051Ver en 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
    Ver en GitHub↗1,051
  • jacobgil/vit-explainAvatar de jacobgil

    jacobgil/vit-explain

    1,090Ver en 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
    Ver en GitHub↗1,090
Compara los 10 mejores de un vistazo
RepositorioEstrellasLenguajeLicenciaÚltimo push
shap/shap25KJupyter Notebookmit19 feb 2026
slundberg/shap25.5KJupyter NotebookMIT15 jun 2026
marcotcr/lime12.1KJavaScriptBSD-2-Clause25 jul 2024
interpretml/interpret6.9KC++MIT22 jun 2026
pytorch/captum5.7KPythonBSD-3-Clause16 jun 2026
maif/shapash3.2KJupyter NotebookApache-2.015 jun 2026
pair-code/lit3.6KTypeScriptapache-2.020 feb 2026
transformerlensorg/transformerlens3.1KPythonmit20 feb 2026
albermax/innvestigate1.3KPythonNOASSERTION11 abr 2025
marcotcr/anchor813Jupyter NotebookBSD-2-Clause19 jul 2022

Related searches

  • un framework para trading basado en ML
  • un framework de machine learning para pronóstico de series temporales
  • un dashboard low-code para machine learning
  • un framework de machine learning automatizado para ajuste de modelos
  • herramienta para monitorizar el drift de modelos en producción
  • un framework para evaluar la calidad de salida de los LLMs
  • ruta estructurada hacia la ingeniería de ML
  • una librería de gradient boosting para datos tabulares