signal-grad-cam 0.1.0__tar.gz → 0.1.2__tar.gz

{signal_grad_cam-0.1.0 → signal_grad_cam-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: signal_grad_cam
-Version: 0.1.0
+Version: 0.1.2
 Summary: SignalGrad-CAM aims at generalising Grad-CAM to one-dimensional applications, while enhancing usability and efficiency.
 Home-page: https://github.com/samuelepe11/signal_grad_cam
 Author: Samuele Pe

{signal_grad_cam-0.1.0 → signal_grad_cam-0.1.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as f:
 
 setup(
     name="signal_grad_cam",
-    version="0.1.0",
+    version="0.1.2",
     description="SignalGrad-CAM aims at generalising Grad-CAM to one-dimensional applications, while enhancing usability"
                 " and efficiency.",
     keywords="XAI, class activation maps, CNN, time series",

{signal_grad_cam-0.1.0 → signal_grad_cam-0.1.2}/signal_grad_cam/cam_builder.py

@@ -21,7 +21,7 @@ class CamBuilder:
                        "HiResCAM": "High-Resolution Class Activation Mapping"}
 
     def __init__(self, model: torch.nn.Module | tf.keras.Model | Any,
-                 transform_fn: Callable[[np.ndarray, Optional[List[Any]]], torch.Tensor | tf.Tensor] = None,
+                 transform_fn: Callable[[np.ndarray, *tuple[Any, ...]], torch.Tensor | tf.Tensor] = None,
                  class_names: List[str] = None, time_axs: int = 1, input_transposed: bool = False,
                  ignore_channel_dim: bool = False, model_output_index: int = None, extend_search: bool = False,
                  padding_dim: int = None, seed: int = 11):
@@ -103,7 +103,7 @@ class CamBuilder:
                 explainer_types: str | List[str], target_layers: str | List[str], softmax_final: bool,
                 data_names: List[str] = None, data_sampling_freq: float = None, dt: float = 10,
                 channel_names: List[str | float] = None, results_dir_path: str = None, aspect_factor: float = 100,
-                data_shape_list: List[Tuple[int, int]] = None, extra_preprocess_inputs_list: List[Any] = None,
+                data_shape_list: List[Tuple[int, int]] = None, extra_preprocess_inputs_list: List[List[Any]] = None,
                 extra_inputs_list: List[Any] = None, time_names: List[str | float] = None,
                 axes_names: Tuple[str | None, str | None] | List[str | None] = None) \
             -> Tuple[Dict[str, List[np.ndarray]], Dict[str, np.ndarray],  Dict[str, Tuple[np.ndarray, np.ndarray]]]:
@@ -139,9 +139,9 @@ class CamBuilder:
             one-dimensional CAM.
         :param data_shape_list: (optional, default is None) A list of integer tuples storing the original input sizes,
             used to set the CAM shape after resizing during preprocessing. The expected format is number of rows x
-             number of columns.
-        :param extra_preprocess_inputs_list: (optional, defaults is None) A list of additional input objects required by
-            the preprocessing method.
+            number of columns.
+        :param extra_preprocess_inputs_list: (optional, defaults is None) A list of lists, where the i-th sub-list
+            represents the additional input objects required by the preprocessing method for the i-th input.
         :param extra_inputs_list: (optional, default is None) A list of additional input objects required by the model's
             forward method.
         :param time_names: (optional, default is None) A list of strings representing tick names for the time axis.
@@ -448,9 +448,9 @@ class CamBuilder:
         txt = " - " + addon + f"{name}:\t{type(layer).__name__}"
         print(txt)
 
-    def _create_raw_batched_cams(self, data_list: List[np.ndarray], target_class: int, target_layer: str,
-                                 explainer_type: str, softmax_final: bool, extra_inputs_list: List[Any] = None) \
-            -> Tuple[List[np.ndarray], np.ndarray]:
+    def _create_raw_batched_cams(self, data_list: List[np.ndarray | torch.Tensor | tf.Tensor], target_class: int,
+                                 target_layer: str, explainer_type: str, softmax_final: bool,
+                                 extra_inputs_list: List[Any] = None) -> Tuple[List[np.ndarray], np.ndarray]:
         """
         Retrieves raw CAMs from an input data list based on the specified settings (defined by algorithm, target layer,
         and target class). Additionally, it returns the class probabilities predicted by the model.
@@ -511,7 +511,7 @@ class CamBuilder:
 
     def __create_batched_cams(self, data_list: List[np.ndarray], target_class: int, target_layer: str,
                               explainer_type: str, softmax_final: bool, data_shape_list: List[Tuple[int, int]] = None,
-                              extra_preprocess_inputs_list: List[Any] = None, extra_inputs_list: List[Any] = None) \
+                              extra_preprocess_inputs_list: List[List[Any]] = None, extra_inputs_list: List[Any] = None) \
             -> Tuple[List[np.ndarray], np.ndarray, Tuple[np.ndarray, np.ndarray]]:
         """
         Prepares the input data list and retrieves CAMs based on the specified settings (defined by algorithm, target
@@ -530,11 +530,11 @@ class CamBuilder:
         :param data_shape_list: (optional, default is None) A list of integer tuples storing the original input sizes,
             used to set the CAM shape after resizing during preprocessing. The expected format is number of rows x
             number of columns.
-        :param extra_preprocess_inputs_list: (optional, defaults is None) A list of additional input objects required by
-            the preprocessing method.
+        :param extra_preprocess_inputs_list: (optional, defaults is None) A list of lists, where the i-th sub-list
+            represents the additional input objects required by the preprocessing method for the i-th input.
         :param extra_inputs_list: (optional, default is None) A list of additional input objects required by the model's
             forward method.
-
+0
         :return:
             - cam_list: A list of np.ndarray containing CAMs for each item in the input data list, corresponding to the
                 given setting (defined by algorithm, target layer, and target class).
@@ -552,8 +552,11 @@ class CamBuilder:
         if data_shape_list is None:
             data_shape_list = [data_element.shape for data_element in data_list]
         if self.transform_fn is not None:
-            extra_preprocess_inputs_list = extra_preprocess_inputs_list or []
-            data_list = [self.transform_fn(data_element, *extra_preprocess_inputs_list) for data_element in data_list]
+            if extra_preprocess_inputs_list is not None:
+                data_list = [self.transform_fn(data_element, *extra_preprocess_inputs_list[i]) for i, data_element in
+                             enumerate(data_list)]
+            else:
+                data_list = [self.transform_fn(data_element) for data_element in data_list]
 
         # Ensure data have consistent size for batching
         if len(data_list) > 1 and self.padding_dim is None:

{signal_grad_cam-0.1.0 → signal_grad_cam-0.1.2}/signal_grad_cam/pytorch_cam_builder.py

@@ -13,7 +13,7 @@ class TorchCamBuilder(CamBuilder):
     Represents a PyTorch Class Activation Map (CAM) builder, supporting multiple methods such as Grad-CAM and HiResCAM.
     """
 
-    def __init__(self, model: nn.Module | Any, transform_fn: Callable[[np.ndarray, Optional[List[Any]]], torch.Tensor]
+    def __init__(self, model: nn.Module | Any, transform_fn: Callable[[np.ndarray, *tuple[Any, ...]], torch.Tensor]
                  = None, class_names: List[str] = None, time_axs: int = 1, input_transposed: bool = False,
                  ignore_channel_dim: bool = False, model_output_index: int = None, extend_search: bool = False,
                  use_gpu: bool = False, padding_dim: int = None, seed: int = 11):
@@ -68,7 +68,8 @@ class TorchCamBuilder(CamBuilder):
         else:
             print("Your PyTorch model has no 'eval' method. Please verify that the networks has been set to "
                   "evaluation mode before the TorchCamBuilder initialization.")
-        self.use_gpu = use_gpu
+        self.use_gpu = use_gpu and torch.cuda.is_available()
+        self.device = "cuda" if self.use_gpu else "cpu"
 
         # Assign the default transform function
         if transform_fn is None:
@@ -117,9 +118,9 @@ class TorchCamBuilder(CamBuilder):
                 isinstance(layer, nn.Softmax) or isinstance(layer, nn.Sigmoid)):
             super()._show_layer(name, layer, potential=potential)
 
-    def _create_raw_batched_cams(self, data_list: List[np.array], target_class: int, target_layer: nn.Module,
-                                 explainer_type: str, softmax_final: bool, extra_inputs_list: List[Any] = None) \
-            -> Tuple[List[np.ndarray], np.ndarray]:
+    def _create_raw_batched_cams(self, data_list: List[np.ndarray | torch.Tensor], target_class: int,
+                                 target_layer: nn.Module, explainer_type: str, softmax_final: bool,
+                                 extra_inputs_list: List[Any] = None)  -> Tuple[List[np.ndarray], np.ndarray]:
         """
         Retrieves raw CAMs from an input data list based on the specified settings (defined by algorithm, target layer,
         and target class). Additionally, it returns the class probabilities predicted by the model.
@@ -168,6 +169,10 @@ class TorchCamBuilder(CamBuilder):
             data_list = [x.unsqueeze(0) for x in data_list]
         data_batch = torch.stack(data_list)
 
+        # Set device
+        self.model = self.model.to(self.device)
+        data_batch = data_batch.to(self.device)
+
         extra_inputs_list = extra_inputs_list or []
         outputs = self.model(data_batch, *extra_inputs_list)
         if isinstance(outputs, tuple):
@@ -178,9 +183,26 @@ class TorchCamBuilder(CamBuilder):
             # during derivation
             target_scores = torch.log(outputs)
             target_probs = outputs
+
+            # Adjust results for binary network
+            if len(outputs.shape) == 1:
+                target_scores = torch.stack([-target_scores, target_scores], dim=1)
+                target_probs = torch.stack([1 - target_probs, target_probs], dim=1)
+            elif len(outputs.shape) == 2 and outputs.shape[1] == 1:
+                target_scores = torch.cat([-target_scores, target_scores], dim=1)
+                target_probs = torch.cat([1 - target_probs, target_probs], dim=1)
         else:
+            if len(outputs.shape) == 1:
+                outputs = torch.stack([-outputs, outputs], dim=1)
+            elif len(outputs.shape) == 2 and outputs.shape[1] == 1:
+                outputs = torch.cat([-outputs, outputs], dim=1)
             target_scores = outputs
-            target_probs = torch.softmax(target_scores, dim=1)
+
+            if len(outputs.shape) == 2 and outputs.shape[1] > 1:
+                target_probs = torch.softmax(target_scores, dim=1)
+            else:
+                tmp = torch.sigmoid(target_scores[:, 1])
+                target_probs = torch.stack([1 - tmp, tmp], dim=1)
 
         target_probs = target_probs[:, target_class].cpu().detach().numpy()
 

{signal_grad_cam-0.1.0 → signal_grad_cam-0.1.2}/signal_grad_cam/tensorflow_cam_builder.py

@@ -18,7 +18,7 @@ class TfCamBuilder(CamBuilder):
     HiResCAM.
     """
 
-    def __init__(self, model: tf.keras.Model | Any, transform_fn: Callable[[np.ndarray, Optional[List[Any]]], tf.Tensor]
+    def __init__(self, model: tf.keras.Model | Any, transform_fn: Callable[[np.ndarray, *tuple[Any, ...]], tf.Tensor]
                  = None, class_names: List[str] = None, time_axs: int = 1, input_transposed: bool = False,
                  ignore_channel_dim: bool = False, model_output_index: int = None, extend_search: bool = False,
                  padding_dim: int = None, seed: int = 11):
@@ -142,7 +142,7 @@ class TfCamBuilder(CamBuilder):
                 isinstance(layer, keras.layers.Softmax) or isinstance(layer, keras.Sequential)):
             super()._show_layer(name, layer, potential=potential)
 
-    def _create_raw_batched_cams(self, data_list: List[np.array], target_class: int,
+    def _create_raw_batched_cams(self, data_list: List[np.ndarray | tf.Tensor], target_class: int,
                                  target_layer: tf.keras.layers.Layer, explainer_type: str, softmax_final: bool,
                                  extra_inputs_list: List[Any] = None) -> Tuple[List[np.ndarray], np.ndarray]:
         """
@@ -189,7 +189,7 @@ class TfCamBuilder(CamBuilder):
 
         grad_model = keras.models.Model(self.model.inputs, [target_layer.output, self.model.output])
         extra_inputs_list = extra_inputs_list or []
-        with tf.GradientTape() as tape:
+        with (tf.GradientTape() as tape):
             self.activations, outputs = grad_model([data_batch] + extra_inputs_list)
 
             if softmax_final:
@@ -197,9 +197,26 @@ class TfCamBuilder(CamBuilder):
                 # during derivation
                 target_scores = tf.math.log(outputs)
                 target_probs = outputs
+
+                # Adjust results for binary network
+                if len(outputs.shape) == 1:
+                    target_scores = tf.stack([-target_scores, target_scores], axis=1)
+                    target_probs = tf.stack([1 - target_probs, target_probs], axis=1)
+                elif len(outputs.shape) == 2 and outputs.shape[1] == 1:
+                    target_scores = tf.concat([-target_scores, target_scores], axis=1)
+                    target_probs = tf.concat([1 - target_probs, target_probs], axis=1)
             else:
+                if len(outputs.shape) == 1:
+                    outputs = tf.stack([-outputs, outputs], axis=1)
+                elif len(outputs.shape) == 2 and outputs.shape[1] == 1:
+                    outputs = tf.concat([-outputs, outputs], axis=1)
                 target_scores = outputs
-                target_probs = tf.nn.softmax(target_scores, axis=1)
+
+                if len(outputs.shape) == 2 and outputs.shape[1] > 1:
+                    target_probs = tf.nn.softmax(target_scores, axis=1)
+                else:
+                    tmp = tf.math.sigmoid(target_scores[:, 1])
+                    target_probs = tf.stack([1 - tmp, tmp], axis=1)
 
             target_scores = target_scores[:, target_class]
             target_probs = target_probs[:, target_class]

{signal_grad_cam-0.1.0 → signal_grad_cam-0.1.2}/signal_grad_cam.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: signal-grad-cam
-Version: 0.1.0
+Version: 0.1.2
 Summary: SignalGrad-CAM aims at generalising Grad-CAM to one-dimensional applications, while enhancing usability and efficiency.
 Home-page: https://github.com/samuelepe11/signal_grad_cam
 Author: Samuele Pe