HeinrichAD
commented
1 year ago Hi @chr5tphr
I will provide my feedback here instead of the issue itself.
I didn't check the attribution maps in detail, but your code example (here) seems to work fine. (My following examples are based on this example.)
There are some points I would like to mention:
- What if we do not use composites?
- Why not add the possibility to activate/deactivate the rule hooks in general? (Sometimes you need to do many other things before you calculate the second order gradient and you do not want to keep this always in mind.)
- Why does
composite.inactiveonly works inside the originalcomposite.context?Code Example 1
canonizers = None
composite = EpsilonGammaBox(low=-3., high=3., canonizers=canonizers)
def explain_LRP(model: torch.nn.Module, input: torch.Tensor, target: torch.Tensor):
with composite.context(model) as modified_model:
outputs = modified_model(input)
relevance, = torch.autograd.grad(outputs, input, target, create_graph=True)
return outputs, relevance
outputs, relevance = explain_LRP(model, input, target)
# create a target heatmap, rolled 12 pixels south east
target_heat = torch.roll(relevance.detach(), (12, 12), (2, 3))
loss = ((relevance - target_heat) ** 2).mean()
# deactivate the rule hooks in order to leave the second order gradient untouched
# version 1
with composite.inactive():
adv_grad, = torch.autograd.grad(loss, input) # <<-- error because `hook.active` is still True
# version 2
with composite.context(model):
with composite.inactive():
adv_grad, = torch.autograd.grad(loss, input) # <<-- error because `hook.active` is still True- Attributors are currently not supported?
Code Example 2
```python canonizers = None composite = EpsilonGammaBox(low=-3., high=3., canonizers=canonizers) with Gradient(model=model, composite=composite) as attributor: outputs, relevance = attributor(inputs, torch.eye(1000)[targets]) # create a target heatmap, rolled 12 pixels south east target_heat = torch.roll(relevance.detach(), (12, 12), (2, 3)) loss = ((relevance - target_heat) ** 2).mean() # deactivate the rule hooks in order to leave the second order gradient untouched with attributor.composite.inactive(): adv_grad, = torch.autograd.grad(loss, inputs) # <<-- Error # RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn ```- What do you think should be the default behavour? (Maybe the most important question 😄) Would it not be more plausible if the default is inactive and only if you enter a attributor or composite it would be active? In my optinion the following should be possible by default:
Code Example 3
```python def explain_LRP(model: torch.nn.Module, input: torch.Tensor, target: torch.Tensor): canonizers = None composite = EpsilonGammaBox(low=-3., high=3., canonizers=canonizers) with Gradient(model=model, composite=composite) as attributor: outputs, attributions = attributor(input, target) return outputs, attributions outputs, relevance = explain_LRP(model, input, target) # create a target heatmap, rolled 12 pixels south east target_heat = torch.roll(relevance.detach(), (12, 12), (2, 3)) loss = ((relevance - target_heat) ** 2).mean() # now the gradient calculation should be possible by default without any futher deactivation etc. adv_grad, = torch.autograd.grad(loss, input) # <<-- this should work by default ```Code Example 4
```python def explain_LRP(model: torch.nn.Module, input: torch.Tensor, target: torch.Tensor): canonizers = None composite = EpsilonGammaBox(low=-3., high=3., canonizers=canonizers) with composite.context(model) as modified_model: outputs = modified_model(input) relevance, = torch.autograd.grad(outputs, input, target, create_graph=True) return outputs, relevance outputs, relevance = explain_LRP(model, input, target) # create a target heatmap, rolled 12 pixels south east target_heat = torch.roll(relevance.detach(), (12, 12), (2, 3)) loss = ((relevance - target_heat) ** 2).mean() # now the gradient calculation should be possible by default without any futher deactivation etc. adv_grad, = torch.autograd.grad(loss, input) # <<-- this should work by default ```Edit: To be honest I expected something like this to be the default:
chr5tphr
support computing the gradient of the modified gradient via second order gradients
for this, the second gradient pass must be done without hooks
this is supported by either removing the hooks before computing the second order gradients, or setting for each hook
hook.active = Falseby e.g. using the contextmanagercomposite.inactive()before computing the second order gradientsmake SmoothGrad and IntegratedGradients inherit from Gradient
add
create_graphandretain_grapharguments for Gradient-Attributorsadd
.gradfunction to Gradient, which is used by its subclasses to compute the gradientfix attributor docstrings
recognize in BasicHook.backward whether to use
create_graph=Truefor the backward pass in order to compute the relevance by checking whethergrad_outputrequires a gradientadd the ReLUBetaSmooth rule, which transforms the gradient of ReLU to the gradient of softplus (i.e. sigmoid); this is used as a surrogate to compute meaningful gradients of ReLU
add test to check effect of hook.active
add test to check whether the second order gradient of Hook is computed as expected
add second order gradient tests for gradient attributors
add test for attributor.inactive
add test for Composite.inactive
add test for ReLUBetaSmooth
add How-To for computing second order gradients
Implements #142 and fixes #125