XAI for HuggingFace vision models tutorial

Author: jacobgil

cam.py

@@ -14,7 +14,7 @@
     LayerCAM, \
     FullGrad, \
     GradCAMElementWise
-    
+
 
 from pytorch_grad_cam import GuidedBackpropReLUModel
 from pytorch_grad_cam.utils.image import show_cam_on_image, \
@@ -68,7 +68,7 @@ def get_args():
     args = get_args()
     methods = \
         {"gradcam": GradCAM,
-         "hirescam":HiResCAM,
+         "hirescam": HiResCAM,
          "scorecam": ScoreCAM,
          "gradcam++": GradCAMPlusPlus,
          "ablationcam": AblationCAM,
@@ -101,7 +101,6 @@ def get_args():
                                     mean=[0.485, 0.456, 0.406],
                                     std=[0.229, 0.224, 0.225])
 
-
     # We have to specify the target we want to generate
     # the Class Activation Maps for.
     # If targets is None, the highest scoring category (for every member in the batch) will be used.

pytorch_grad_cam/__init__.py

@@ -13,8 +13,8 @@
 from pytorch_grad_cam.fullgrad_cam import FullGrad
 from pytorch_grad_cam.guided_backprop import GuidedBackpropReLUModel
 from pytorch_grad_cam.activations_and_gradients import ActivationsAndGradients
-from pytorch_grad_cam.feature_factorization.deep_feature_factorization import DeepFeatureFactorization
+from pytorch_grad_cam.feature_factorization.deep_feature_factorization import DeepFeatureFactorization, run_dff_on_image
 import pytorch_grad_cam.utils.model_targets
 import pytorch_grad_cam.utils.reshape_transforms
 import pytorch_grad_cam.metrics.cam_mult_image
-import pytorch_grad_cam.metrics.road
+import pytorch_grad_cam.metrics.road

pytorch_grad_cam/feature_factorization/deep_feature_factorization.py

@@ -1,9 +1,10 @@
 import numpy as np
+from PIL import Image
 import torch
-from typing import Callable, List, Tuple
+from typing import Callable, List, Tuple, Optional
 from sklearn.decomposition import NMF
 from pytorch_grad_cam.activations_and_gradients import ActivationsAndGradients
-from pytorch_grad_cam.utils.image import scale_cam_image
+from pytorch_grad_cam.utils.image import scale_cam_image, create_labels_legend, show_factorization_on_image
 
 
 def dff(activations: np.ndarray, n_components: int = 5):
@@ -22,7 +23,7 @@ def dff(activations: np.ndarray, n_components: int = 5):
         reshaped_activations.shape[0], -1)
     offset = reshaped_activations.min(axis=-1)
     reshaped_activations = reshaped_activations - offset[:, None]
-        
+
     model = NMF(n_components=n_components, init='random', random_state=0)
     W = model.fit_transform(reshaped_activations)
     H = model.components_
@@ -60,11 +61,15 @@ def __call__(self,
                  n_components: int = 16):
         batch_size, channels, h, w = input_tensor.size()
         _ = self.activations_and_grads(input_tensor)
-        activations = self.activations_and_grads.activations[0].cpu().numpy()
+
+        with torch.no_grad():
+            activations = self.activations_and_grads.activations[0].cpu(
+            ).numpy()
+
         concepts, explanations = dff(activations, n_components=n_components)
 
         processed_explanations = []
-        
+
         for batch in explanations:
             processed_explanations.append(scale_cam_image(batch, (w, h)))
 
@@ -88,3 +93,39 @@ def __exit__(self, exc_type, exc_value, exc_tb):
             print(
                 f"An exception occurred in ActivationSummary with block: {exc_type}. Message: {exc_value}")
             return True
+
+
+def run_dff_on_image(model: torch.nn.Module,
+                     target_layer: torch.nn.Module,
+                     classifier: torch.nn.Module,
+                     img_pil: Image,
+                     img_tensor: torch.Tensor,
+                     reshape_transform=Optional[Callable],
+                     n_components: int = 5,
+                     top_k: int = 2) -> np.ndarray:
+    """ Helper function to create a Deep Feature Factorization visualization for a single image.
+        TBD: Run this on a batch with several images.
+    """
+    rgb_img_float = np.array(img_pil) / 255
+    dff = DeepFeatureFactorization(model=model,
+                                   reshape_transform=reshape_transform,
+                                   target_layer=target_layer,
+                                   computation_on_concepts=classifier)
+
+    concepts, batch_explanations, concept_outputs = dff(
+        img_tensor[None, :], n_components)
+
+    concept_outputs = torch.softmax(
+        torch.from_numpy(concept_outputs),
+        axis=-1).numpy()
+    concept_label_strings = create_labels_legend(concept_outputs,
+                                                 labels=model.config.id2label,
+                                                 top_k=top_k)
+    visualization = show_factorization_on_image(
+        rgb_img_float,
+        batch_explanations[0],
+        image_weight=0.3,
+        concept_labels=concept_label_strings)
+
+    result = np.hstack((np.array(img_pil), visualization))
+    return result

pytorch_grad_cam/utils/image.py

@@ -5,7 +5,8 @@
 import numpy as np
 import torch
 from torchvision.transforms import Compose, Normalize, ToTensor
-from typing import List
+from typing import List, Dict
+import math
 
 
 def preprocess_image(
@@ -63,6 +64,22 @@ def show_cam_on_image(img: np.ndarray,
     return np.uint8(255 * cam)
 
 
+def create_labels_legend(concept_scores: np.ndarray,
+                         labels: Dict[int, str],
+                         top_k=2):
+    concept_categories = np.argsort(concept_scores, axis=1)[:, ::-1][:, :top_k]
+    concept_labels_topk = []
+    for concept_index in range(concept_categories.shape[0]):
+        categories = concept_categories[concept_index, :]
+        concept_labels = []
+        for category in categories:
+            score = concept_scores[concept_index, category]
+            label = f"{','.join(labels[category].split(',')[:3])}:{score:.2f}"
+            concept_labels.append(label)
+        concept_labels_topk.append("\n".join(concept_labels))
+    return concept_labels_topk
+
+
 def show_factorization_on_image(img: np.ndarray,
                                 explanations: np.ndarray,
                                 colors: List[np.ndarray] = None,
@@ -118,7 +135,8 @@ def show_factorization_on_image(img: np.ndarray,
     if concept_labels is not None:
         px = 1 / plt.rcParams['figure.dpi']  # pixel in inches
         fig = plt.figure(figsize=(result.shape[1] * px, result.shape[0] * px))
-        plt.rcParams['legend.fontsize'] = 15 * result.shape[0] / 256
+        plt.rcParams['legend.fontsize'] = int(
+            14 * result.shape[0] / 256 / max(1, n_components / 6))
         lw = 5 * result.shape[0] / 256
         lines = [Line2D([0], [0], color=colors[i], lw=lw)
                  for i in range(n_components)]

setup.py

@@ -8,7 +8,7 @@
 
 setuptools.setup(
     name='grad-cam',
-    version='1.4.5',
+    version='1.4.6',
     author='Jacob Gildenblat',
     author_email='[email protected]',
     description='Many Class Activation Map methods implemented in Pytorch for classification, segmentation, object detection and more',
@@ -23,7 +23,7 @@
         'License :: OSI Approved :: MIT License',
         'Operating System :: OS Independent',
     ],
-    packages=setuptools.find_packages(exclude=["*tutorials*"]),
+    packages=setuptools.find_packages(
+        exclude=["*tutorials*"]),
     python_requires='>=3.6',
-    install_requires=requirements
-)
+    install_requires=requirements)

tests/test_context_release.py

@@ -52,7 +52,8 @@ def test_memory_usage_in_loop(numpy_image, batch_size, width, height,
     target_layers = []
     for layer in target_layer_names:
         target_layers.append(eval(f"model.{layer}"))
-    targets = [ClassifierOutputTarget(target_category) for _ in range(batch_size)]
+    targets = [ClassifierOutputTarget(target_category)
+               for _ in range(batch_size)]
     initial_memory = 0
     for i in range(100):
         with cam_method(model=model,

tests/test_one_channel.py

@@ -0,0 +1,49 @@
+import pytest
+import torchvision
+import torch
+import cv2
+import numpy as np
+from pytorch_grad_cam import GradCAM, \
+    ScoreCAM, \
+    GradCAMPlusPlus, \
+    AblationCAM, \
+    XGradCAM, \
+    EigenCAM, \
+    EigenGradCAM, \
+    LayerCAM, \
+    FullGrad
+from pytorch_grad_cam.utils.image import show_cam_on_image, \
+    preprocess_image
+
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+
+torch.manual_seed(0)
+
+
+@pytest.fixture
+def numpy_image():
+    return cv2.imread("examples/both.png")
+
+
+@pytest.mark.parametrize("cam_method",
+                         [GradCAM])
+def test_memory_usage_in_loop(numpy_image, cam_method):
+    model = torchvision.models.resnet18(pretrained=False)
+    model.conv1 = torch.nn.Conv2d(
+        1, 64, kernel_size=(
+            7, 7), stride=(
+            2, 2), padding=(
+                3, 3), bias=False)
+    target_layers = [model.layer4]
+    gray_img = numpy_image[:, :, 0]
+    input_tensor = torch.from_numpy(
+        np.float32(gray_img)).unsqueeze(0).unsqueeze(0)
+    input_tensor = input_tensor.repeat(16, 1, 1, 1)
+    print("input_tensor", input_tensor.shape)
+    targets = None
+    with cam_method(model=model,
+                    target_layers=target_layers,
+                    use_cuda=False) as cam:
+        grayscale_cam = cam(input_tensor=input_tensor,
+                            targets=targets)
+        print(grayscale_cam.shape)

tests/test_run_all_models.py

@@ -68,9 +68,10 @@ def test_all_cam_models_can_run(numpy_image, batch_size, width, height,
                      use_cuda=False)
     cam.batch_size = 4
     if target_category is None:
-      targets = None
+        targets = None
     else:
-      targets = [ClassifierOutputTarget(target_category) for _ in range(batch_size)]
+        targets = [ClassifierOutputTarget(target_category)
+                   for _ in range(batch_size)]
 
     grayscale_cam = cam(input_tensor=input_tensor,
                         targets=targets,