• Attribution Methods: Getting started

• Attribution Methods: Sanity checks paper
• Attribution Methods: Tabular data and Regression
• Attribution Methods: Object Detection
• Attribution Methods: Semantic Segmentation
• FORGRad: Gradient strikes back with FORGrad
• Attribution Methods: Metrics

• PyTorch models: Getting started

• Concepts Methods: Testing with Concept Activation Vectors

• Concepts Methods: CRAFT: Getting started on Tensorflow
• Concepts Methods: CRAFT: Getting started on Pytorch

• Feature Visualization: Getting started
• Modern Feature Visualization with MaCo: Getting started

You can find a certain number of other practical tutorials just here. This section is actively developed and more contents will be included. We will try to cover all the possible usage of the library, feel free to contact us if you have any suggestions or recommendations towards tutorials you would like to see.

from xplique.attributions import GradCAM

# load images, labels and model
# ...

explainer = GradCAM(model)
explanations = explainer.explain(images, labels)
# or just `explainer(images, labels)`

All attributions methods share a common API described in the attributions API documentation.

In order to measure if the explanations provided by our method are faithful (it reflects well the functioning of the model) we can use a fidelity metric such as Deletion

from xplique.attributions import GradCAM
from xplique.metrics import Deletion

# load images, labels and model
# ...

explainer = GradCAM(model)
explanations = explainer(inputs, labels)
metric = Deletion(model, inputs, labels)

score_grad_cam = metric(explanations)

All attributions metrics share a common API. You can find out more about it here.

Concerning the concept-based methods, we can for example extract a concept vector from a layer of a model. In order to do this, we use two datasets, one containing inputs containing the concept: positive_samples, the other containing other entries which do not contain the concept: negative_samples.

from xplique.concepts import Cav

# load a model, samples that contain a concept
# (positive) and samples who don't (negative)
# ...

extractor = Cav(model, 'mixed3')
concept_vector = extractor(positive_samples,
                           negative_samples)

More information on CAV here and on TCAV here.

Use Craft to investigate a single class.

from xplique.concepts import CraftTf as Craft

# Cut the model in two parts: g and h
# Create a Craft concept extractor from these 2 models
craft = Craft(input_to_latent_model = g,
              latent_to_logit_model = h)

# Use Craft to compute the concepts for a specific class
craft.fit(images_preprocessed, class_id=rabbit_class_id)

# Compute Sobol indices to understand which concept matters
importances = craft.estimate_importance()

# Display those concepts by showing the 10 best crops for each concept
craft.plot_concepts_crops(nb_crops=10)

More information in the CRAFT documentation.

Finally, in order to find an image that maximizes a neuron and at the same time a layer, we build two objectives that we combine together. We then call the optimizer which returns our images

from xplique.features_visualizations import Objective
from xplique.features_visualizations import optimize

# load a model...

neuron_obj = Objective.neuron(model, "logits", 200)
channel_obj = Objective.layer(model, "mixed3", 10)

obj = neuron_obj + 2.0 * channel_obj
images, obj_names = optimize(obj)

Want to know more ? Check the Feature Viz documentation

Even though the library was mainly designed to be a Tensorflow toolbox we have been working on a very practical wrapper to facilitate the integration of your PyTorch models into Xplique's framework!

import torch

from xplique.wrappers import TorchWrapper
from xplique.attributions import Saliency
from xplique.metrics import Deletion

# load images, targets and model
# ...

device = 'cuda' if torch.cuda.is_available() else 'cpu'
wrapped_model = TorchWrapper(torch_model, device)

explainer = Saliency(wrapped_model)
explanations = explainer(inputs, targets)

metric = Deletion(wrapped_model, inputs, targets)
score_saliency = metric(explanations)

Want to know more ? Check the PyTorch documentation

Attribution Method	Type of Model	Source	Images	Time Series and Tabular Data	Tutorial
Deconvolution	TF	Paper	C✔️ OD❌ SS❌	C✔️ R✔️
Grad-CAM	TF	Paper	C✔️ OD❌ SS❌	❌
Grad-CAM++	TF	Paper	C✔️ OD❌ SS❌	❌
Gradient Input	TF, PyTorch**	Paper	C✔️ OD✔️ SS✔️	C✔️ R✔️
Guided Backprop	TF	Paper	C✔️ OD❌ SS❌	C✔️ R✔️
Integrated Gradients	TF, PyTorch**	Paper	C✔️ OD✔️ SS✔️	C✔️ R✔️
Kernel SHAP	TF, PyTorch**, Callable*	Paper	C✔️ OD✔️ SS✔️	C✔️ R✔️
Lime	TF, PyTorch**, Callable*	Paper	C✔️ OD✔️ SS✔️	C✔️ R✔️
Occlusion	TF, PyTorch**, Callable*	Paper	C✔️ OD✔️ SS✔️	C✔️ R✔️
Rise	TF, PyTorch**, Callable*	Paper	C✔️ OD✔️ SS✔️	C✔️ R✔️
Saliency	TF, PyTorch**	Paper	C✔️ OD✔️ SS✔️	C✔️ R✔️
SmoothGrad	TF, PyTorch**	Paper	C✔️ OD✔️ SS✔️	C✔️ R✔️
SquareGrad	TF, PyTorch**	Paper	C✔️ OD✔️ SS✔️	C✔️ R✔️
VarGrad	TF, PyTorch**	Paper	C✔️ OD✔️ SS✔️	C✔️ R✔️
Sobol Attribution	TF, PyTorch**	Paper	C✔️ OD✔️ SS✔️	🔵
Hsic Attribution	TF, PyTorch**	Paper	C✔️ OD✔️ SS✔️	🔵
FORGrad enhancement	TF, PyTorch**	Paper	C✔️ OD✔️ SS✔️	❌

TF : Tensorflow compatible

C : Classification | R : Regression | OD : Object Detection | SS : Semantic Segmentation (SS)

* : See the Callable documentation

** : See the Xplique for PyTorch documentation, and the PyTorch models: Getting started notebook.

✔️ : Supported by Xplique | ❌ : Not applicable | 🔵 : Work in Progress

TF : Tensorflow compatible

** : See the Xplique for PyTorch documentation, and the PyTorch models: Getting started notebook.

Concepts method	Type of Model	Source	Tutorial
Concept Activation Vector (CAV)	TF	Paper
Testing CAV (TCAV)	TF	Paper
CRAFT Tensorflow	TF	Paper
CRAFT PyTorch	PyTorch**	Paper
(WIP) Robust TCAV
(WIP) Automatic Concept Extraction (ACE)

TF : Tensorflow compatible

** : See the Xplique for Pytorch documentation, and the PyTorch's model: Getting started notebook

TF : Tensorflow compatible

• Lucid the wonderful library specialized in feature visualization from OpenAI.
• Captum the PyTorch library for Interpretability research
• Tf-explain that implement multiples attribution methods and propose callbacks API for tensorflow.
• Alibi Explain for model inspection and interpretation
• SHAP a very popular library to compute local explanations using the classic Shapley values from game theory and their related extensions

• Interpretable Machine Learning by Christophe Molnar.
• Interpretability Beyond Feature Attribution by Been Kim.
• Explaining ML Predictions: State-of-the-art, Challenges, and Opportunities by Himabindu Lakkaraju, Julius Adebayo and Sameer Singh.
• A Roadmap for the Rigorous Science of Interpretability by Finale Doshi-Velez.
• DEEL White paper a summary of the DEEL team on the challenges of certifiable AI and the role of explainability for this purpose

• deel-lip a Python library for training k-Lipschitz neural networks on TF.
• deel-torchlip a Python library for training k-Lipschitz neural networks on PyTorch.
• Influenciae Python toolkit dedicated to computing influence values for the discovery of potentially problematic samples in a dataset.
• LARD Landing Approach Runway Detection (LARD) is a dataset of aerial front view images of runways designed for aircraft landing phase
• PUNCC Puncc (Predictive uncertainty calibration and conformalization) is an open-source Python library that integrates a collection of state-of-the-art conformal prediction algorithms and related techniques for regression and classification problems
• OODEEL OODeel is a library that performs post-hoc deep OOD detection on already trained neural network image classifiers. The philosophy of the library is to favor quality over quantity and to foster easy adoption
• DEEL White paper a summary of the DEEL team on the challenges of certifiable AI and the role of data quality, representativity and explainability for this purpose.