running backward on a loss function which contain explanation

Hello,

I am trying to run a backward pass on an objective function that contains an explanation. The goal is to run a manipulate attack on explanations. However, it is strange that the explanation attained by the attribute method from captum does not require gradient even though the input for which the explanation is being computed requires gradient. For example in the following code snippet:

sm = Saliency(vgg_model)
expl = sm.attribute(x_adv, target=17)

The expl tensor is a leaf tensor and doesn’t require gradient.

There’s further another issue with “LRP” in this application. When computing backward pass, I encounter this error:

RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.cuda.FloatTensor [4096, 1000]], which is output 0 of TBackward, is at version 7; expected version 6 instead. Hint: enable anomaly detection to find the operation that failed to compute its gradient, with torch.autograd.set_detect_anomaly(True).

I would really appreciate it if you could help me with these issues.

Best, -Ahmad

[vivekmig]

Hi @ahmadajal , here is a workaround to obtain explanations that require gradient. We essentially need to override the default gradient function, to add an additional parameter create_graph=True, which enables higher order derivatives.

from captum._utils.common import _run_forward
from typing import Any, Callable, Union, Tuple
from torch import Tensor
import torch

# This is the same as the default compute_gradients
# function in captum._utils.gradient, except
# setting create_graph=True when calling
# torch.autograd.grad
def compute_gradients(
    forward_fn: Callable,
    inputs: Union[Tensor, Tuple[Tensor, ...]],
    target_ind = None,
    additional_forward_args: Any = None,
) -> Tuple[Tensor, ...]:
    with torch.autograd.set_grad_enabled(True):
        # runs forward pass
        outputs = _run_forward(forward_fn, inputs, target_ind, additional_forward_args)
        assert outputs[0].numel() == 1, (
            "Target not provided when necessary, cannot"
            " take gradient with respect to multiple outputs."
        )
        grads = torch.autograd.grad(torch.unbind(outputs), inputs, create_graph=True)
    return grads

from captum.attr import Saliency
sal = Saliency(model)
sal.gradient_func = compute_gradients
attr = sal.attribute(inp, target=1)

We will look into approaches to expose this option more easily, but this approach should work in the meantime, with attr requiring gradients here.

We will also look into the LRP issue further, would you be able to provide an example to reproduce this? It seems this may be related to inplace operations, would you also be able to try with replacing any inplace operations (e.g. set inplace to False on ReLUs if applicable) in your model and see if that resolves the issue?

[tangli0305]

Do we have any solution now? I also have exactly the same error when trying backward loss containing LRP explanations.