delete forward function in shapley_cam.py

Author: cai2-huaiguang

pytorch_grad_cam/base_cam.py

@@ -107,7 +107,13 @@ def forward(
         if self.uses_gradients:
             self.model.zero_grad()
             loss = sum([target(output) for target, output in zip(targets, outputs)])
-            loss.backward(retain_graph=True)
+            if self.detach:
+                loss.backward(retain_graph=True)
+            else:
+                # keep the computational graph, create_graph = True is needed for hvp
+                torch.autograd.grad(loss, input_tensor,  retain_graph = True, create_graph = True)
+                # When using the following loss.backward() method, a warning is raised: "UserWarning: Using backward() with create_graph=True will create a reference cycle"
+                # loss.backward(retain_graph=True, create_graph=True)
             if 'hpu' in str(self.device):
                 self.__htcore.mark_step()
 

pytorch_grad_cam/shapley_cam.py

@@ -10,46 +10,16 @@
 """
 class ShapleyCAM(BaseCAM):
     def __init__(self, model, target_layers,
-                 reshape_transform=None, detach=False):
+                 reshape_transform=None):
         super(
             ShapleyCAM,
             self).__init__(
-            model,
-            target_layers,
-            reshape_transform,
-            detach = detach)
-
-    def forward(
-        self, input_tensor: torch.Tensor, targets: List[torch.nn.Module], eigen_smooth: bool = False
-    ) -> np.ndarray:
-        input_tensor = input_tensor.to(self.device)
-
-        input_tensor = torch.autograd.Variable(input_tensor, requires_grad=True)
-
-        self.outputs = outputs = self.activations_and_grads(input_tensor)
-
-        if targets is None:
-            target_categories = np.argmax(outputs.cpu().data.numpy(), axis=-1)
-            targets = [ClassifierOutputTarget(category) for category in target_categories]
-
-        if self.uses_gradients:
-            self.model.zero_grad()
-            loss = sum([target(output) for target, output in zip(targets, outputs)])
-            # keep the graph, create_graph = True is needed for hvp
-            torch.autograd.grad(loss, input_tensor,  retain_graph = True, create_graph = True)
-
-        # In most of the saliency attribution papers, the saliency is
-        # computed with a single target layer.
-        # Commonly it is the last convolutional layer.
-        # Here we support passing a list with multiple target layers.
-        # It will compute the saliency image for every image,
-        # and then aggregate them (with a default mean aggregation).
-        # This gives you more flexibility in case you just want to
-        # use all conv layers for example, all Batchnorm layers,
-        # or something else.
-        cam_per_layer = self.compute_cam_per_layer(input_tensor, targets, eigen_smooth)
-        return self.aggregate_multi_layers(cam_per_layer)
-
+            model = model,
+            target_layers = target_layers,
+            reshape_transform = reshape_transform,
+            compute_input_gradient = True,
+            uses_gradients = True,
+            detach = False)
 
     def get_cam_weights(self,
                         input_tensor,