Classification Demonstration¶
This notebook show case what can be done with interpreto for classification.
author: Antonin Poché
0. Imports and model loading¶
import os
import datasets
import torch
import transformers
import interpreto
from interpreto import Lime, plot_attributions, plot_concepts
from interpreto.attributions.metrics import Insertion
from interpreto.commons.llm_interface import OpenAILLM
from interpreto.concepts import LLMLabels, SemiNMFConcepts
from interpreto.concepts.interpretations import TopKInputs
from interpreto.concepts.metrics import FID, SparsityRatio
1. Attribution Demonstration¶
1.1 Obtain the attributions¶
# instantiate Lime
attribution_explainer = Lime(model, tokenizer)
# compute attributions
attributions = attribution_explainer(
model_inputs="Love and hate are two sides of the same coin.",
targets=torch.tensor([[0, 1, 2, 3, 4, 5]]),
)
# visualize attributions
plot_attributions(attributions[0], classes_names=classes_names)
1.2 Evaluate the attributions¶
2. Concepts Demonstration¶
2.1 Split model and get a dataset of activations¶
2.2 Learn concepts as patterns in the activations¶
2.3 Interpret the concepts¶
# instantiate the interpretation method with the concept explainer
interpretation_method = TopKInputs(
concept_explainer=concept_explainer,
k=5,
use_unique_words=True,
unique_words_kwargs={"count_min_threshold": 20, "lemmatize": True},
)
# interpret the concepts via top-k words
topk_words = interpretation_method.interpret(
inputs=dataset,
concepts_indices="all",
)
2.4 Estimate concepts importance to classes¶
# estimate the importance of concepts for each class using the gradient
gradients = concept_explainer.concept_output_gradient(
inputs=activations,
batch_size=32,
)
# stack gradients on samples and average them over samples
mean_gradients = torch.stack(gradients).abs().squeeze().mean(0) # (num_classes, num_concepts)
# for each class, sort the importance scores
order = torch.argsort(mean_gradients, descending=True)
> Tip: The above visualization is interactive, you should click on the classes.
2.5.2 Inputs-to-concepts attributions¶
sample = "Love and hate are two sides of the same coin."
# Use the same class as attributions
concepts_attribution = Lime(concept_explainer.get_inputs_to_concepts_model(), tokenizer)
outputs = concepts_attribution(sample)[0]
plot_concepts(
sample=outputs.elements,
classes_names=classes_names,
concepts_activations=outputs.attributions.T,
concepts_importances=mean_gradients,
concepts_labels={k: list(v.keys()) for k, v in topk_words.items()},
)
2.6 Evaluate concepts¶
2.7 Class-wise and LLM-labels¶
# set the LLM interface used to generate labels based on the constructed prompts
llm_interface = OpenAILLM(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-4.1-nano")
# iterate over classes
concepts_interpretations = {}
concepts_importances = {}
for target, class_name in enumerate(classes_names):
# ----------------------------------------------------------------------------------------------
# 1. construct the dataset of activations (extract the ones related to the class)
indices = (predictions == target).nonzero(as_tuple=True)[0]
class_wise_inputs = [dataset[i] for i in indices]
class_wise_activations = activations[indices]
# ----------------------------------------------------------------------------------------------
# 2. train concept model
concept_explainer = SemiNMFConcepts(splitter, nb_concepts=20, device="cuda")
concept_explainer.fit(class_wise_activations)
# ----------------------------------------------------------------------------------------------
# 4. compute concepts importance (before interpretations to limit the number of concepts interpreted)
gradients = concept_explainer.concept_output_gradient(
inputs=class_wise_activations,
targets=[target],
concepts_x_gradients=True,
batch_size=32,
)
# stack gradients on samples and average them over samples
concepts_importances[target] = torch.stack(gradients, axis=0).squeeze().abs().mean(dim=0) # (num_concepts,)
# for each class, sort the importance scores
important_concept_indices = torch.argsort(concepts_importances[target], descending=True).tolist()
# ----------------------------------------------------------------------------------------------
# 3. interpret the important concepts concepts
llm_labels_method = LLMLabels(
concept_explainer=concept_explainer,
llm_interface=llm_interface,
k_examples=20,
)
concepts_interpretations[target] = llm_labels_method.interpret(
inputs=class_wise_inputs,
concepts_indices=important_concept_indices, # only the top 5 concepts for this class
)
print(f"\nClass: {class_name}")
for concept_id in important_concept_indices[:5]:
label = concepts_interpretations[target].get(concept_id, None)
importance = concepts_importances[target][concept_id].item()
if label is not None:
print(f"\timportance: {round(importance, 3)},\t{label}")