Skip to content

GuidedGradCam

GuidedGradCam

Bases: Explainer

GuidedGradCam explainer.

Supported Modules: Convolution

Parameters:

Name Type Description Default
model Module

The PyTorch model for which attribution is to be computed.

 required
interpolate_mode Optional[str]

The interpolation mode used by the explainer. Available methods are: "bilinear" and "bicubic"

 'nearest'
**kwargs

Keyword arguments that are forwarded to the base implementation of the Explainer

 required
Reference

Ramprasaath R. Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, Dhruv Batra. Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization.

Source code in pnpxai/explainers/guided_grad_cam.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
class GuidedGradCam(Explainer):
    """
    GuidedGradCam explainer.

    Supported Modules: `Convolution`

    Parameters:
        model (Module): The PyTorch model for which attribution is to be computed.
        interpolate_mode (Optional[str]): The interpolation mode used by the explainer. Available methods are: `"bilinear"` and `"bicubic"`
        **kwargs: Keyword arguments that are forwarded to the base implementation of the Explainer

    Reference:
        Ramprasaath R. Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, Dhruv Batra. Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization.
    """

    SUPPORTED_MODULES = [Convolution]

    def __init__(
        self,
        model: Module,
        layer: Optional[Module] = None,
        interpolate_mode: str = "nearest",
    ) -> None:
        super().__init__(model)
        self._layer = layer
        self.interpolate_mode = interpolate_mode

    @property
    def layer(self):
        try:
            return self._layer or find_cam_target_layer(self.model)
        except:
            raise NoCamTargetLayerAndNotTraceableError(
                'You did not set cam target layer and',
                'it does not automatically determined.',
                'Please manually set the cam target layer by:',
                '`Explainer.set_target_layer(layer: nn.Module)`',
                'before attribute.'
            )

    def set_target_layer(self, layer: Module):
        return self.set_kwargs(_layer=layer)

    def attribute(self, inputs: Tensor, targets: Tensor) -> Tensor:
        """
        Computes attributions for the given inputs and targets.

        Args:
            inputs (torch.Tensor): The input data.
            targets (torch.Tensor): The target labels for the inputs.

        Returns:
            torch.Tensor: The result of the explanation.
        """
        forward_args, additional_forward_args = self._extract_forward_args(
            inputs)
        forward_args = format_into_tuple(forward_args)
        additional_forward_args = format_into_tuple(additional_forward_args)
        assert len(
            forward_args) == 1, 'GuidedGradCam for multiple inputs is not supported yet.'
        explainer = CaptumGuidedGradCam(model=self.model, layer=self.layer)
        attrs = explainer.attribute(
            inputs=forward_args[0],
            target=targets,
            interpolate_mode=self.interpolate_mode,
        )
        return attrs

    def get_tunables(self) -> Dict[str, Tuple[type, dict]]:
        """
        Provides Tunable parameters for the optimizer

        Tunable parameters:
            `interpolate_mode` (str): Value can be selected of `"bilinear"` and `"bicubic"`
        """
        return {
            'interpolate_mode': (list, {'choices': ['nearest', 'area']}),
        }

attribute(inputs, targets)

Computes attributions for the given inputs and targets.

Parameters:

Name Type Description Default
inputs Tensor

The input data.

 required
targets Tensor

The target labels for the inputs.

 required

Returns:

Type Description
Tensor

torch.Tensor: The result of the explanation.
Source code in pnpxai/explainers/guided_grad_cam.py 
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
def attribute(self, inputs: Tensor, targets: Tensor) -> Tensor:
    """
    Computes attributions for the given inputs and targets.

    Args:
        inputs (torch.Tensor): The input data.
        targets (torch.Tensor): The target labels for the inputs.

    Returns:
        torch.Tensor: The result of the explanation.
    """
    forward_args, additional_forward_args = self._extract_forward_args(
        inputs)
    forward_args = format_into_tuple(forward_args)
    additional_forward_args = format_into_tuple(additional_forward_args)
    assert len(
        forward_args) == 1, 'GuidedGradCam for multiple inputs is not supported yet.'
    explainer = CaptumGuidedGradCam(model=self.model, layer=self.layer)
    attrs = explainer.attribute(
        inputs=forward_args[0],
        target=targets,
        interpolate_mode=self.interpolate_mode,
    )
    return attrs

get_tunables()

Provides Tunable parameters for the optimizer

Tunable parameters

interpolate_mode (str): Value can be selected of "bilinear" and "bicubic"

Source code in pnpxai/explainers/guided_grad_cam.py 
81
82
83
84
85
86
87
88
89
90
def get_tunables(self) -> Dict[str, Tuple[type, dict]]:
    """
    Provides Tunable parameters for the optimizer

    Tunable parameters:
        `interpolate_mode` (str): Value can be selected of `"bilinear"` and `"bicubic"`
    """
    return {
        'interpolate_mode': (list, {'choices': ['nearest', 'area']}),
    }