signal-grad-cam 0.1.3__tar.gz → 0.1.4__tar.gz

{signal_grad_cam-0.1.3 → signal_grad_cam-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: signal_grad_cam
-Version: 0.1.3
+Version: 0.1.4
 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.3 → signal_grad_cam-0.1.4}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as f:
 
 setup(
     name="signal_grad_cam",
-    version="0.1.3",
+    version="0.1.4",
     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.3 → signal_grad_cam-0.1.4}/signal_grad_cam/cam_builder.py

@@ -110,7 +110,7 @@ class CamBuilder:
                 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[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) \
+                axes_names: Tuple[str | None, str | None] | List[str | None] = None, eps: float = 1e-6) \
             -> Tuple[Dict[str, List[np.ndarray]], Dict[str, np.ndarray],  Dict[str, Tuple[np.ndarray, np.ndarray]]]:
         """
         Allows the user to request Class Activation Maps (CAMs) for a given list of inputs, a set of algorithms,
@@ -153,6 +153,8 @@ class CamBuilder:
         :param time_names: (optional, default is None) A list of strings representing tick names for the time axis.
         :param axes_names: (optional, default is None) A tuple of strings representing names for X and Y axes,
             respectively.
+        :param eps: (optional, default is 1e-6) A float number used in probability clamping before logarithm application
+            to avoid null or None results.
 
         :return:
             - cams_dict: A dictionary storing a list of CAMs. Each list contains CAMs for each item in the input data
@@ -189,7 +191,8 @@ class CamBuilder:
                                                                                     data_shape_list=data_shape_list,
                                                                                     extra_preprocess_inputs_list=
                                                                                     extra_preprocess_inputs_list,
-                                                                                    extra_inputs_list=extra_inputs_list)
+                                                                                    extra_inputs_list=extra_inputs_list,
+                                                                                    esp=eps)
                     item_key = explainer_type + "_" + target_layer + "_class" + str(target_class)
                     cams_dict.update({item_key: cam_list})
                     predicted_probs_dict.update({item_key: output_probs})
@@ -456,7 +459,8 @@ class CamBuilder:
 
     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]:
+                                 extra_inputs_list: List[Any] = None, eps: float = 1e-6) \
+            -> 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.
@@ -472,6 +476,8 @@ class CamBuilder:
             activation function.
         :param extra_inputs_list: (optional, defaults is None) A list of additional input objects required by the
             model's forward method.
+        :param eps: (optional, default is 1e-6) A float number used in probability clamping before logarithm application
+            to avoid null or None results.
 
         :return:
             - cam_list: A list of np.ndarray containing CAMs for each item in the input data list, corresponding to the
@@ -517,7 +523,8 @@ 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[List[Any]] = None, extra_inputs_list: List[Any] = None) \
+                              extra_preprocess_inputs_list: List[List[Any]] = None, extra_inputs_list: List[Any] = None,
+                              eps: float = 1e-6) \
             -> 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
@@ -540,7 +547,9 @@ class CamBuilder:
             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
+        :param eps: (optional, default is 1e-6) A float number used in probability clamping before logarithm application
+            to avoid null or None results.
+
         :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).
@@ -574,7 +583,8 @@ class CamBuilder:
                                      "time.")
 
         cam_list, target_probs = self._create_raw_batched_cams(data_list, target_class, target_layer, explainer_type,
-                                                               softmax_final, extra_inputs_list=extra_inputs_list)
+                                                               softmax_final, extra_inputs_list=extra_inputs_list,
+                                                               eps=eps)
         self.activations = None
         self.gradients = None
         cams = np.stack(cam_list)
@@ -897,7 +907,7 @@ class CamBuilder:
             - is_2d_layer: A boolean indicating whether the target layers 2D-convolutional layer.
         """
 
-        raise ValueError(target_layer + " must be a 1D or 2D convolutional layer.")
+        raise ValueError(str(target_layer) + " must be a 1D or 2D convolutional layer.")
 
     @staticmethod
     def __normalize_cams(cams: np.ndarray, is_2d_layer: bool) -> Tuple[np.ndarray, Tuple[np.ndarray, np.ndarray]]:

{signal_grad_cam-0.1.3 → signal_grad_cam-0.1.4}/signal_grad_cam/pytorch_cam_builder.py

@@ -125,7 +125,8 @@ class TorchCamBuilder(CamBuilder):
 
     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]:
+                                 extra_inputs_list: List[Any] = None, eps: float = 1e-6) \
+            -> 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.
@@ -141,6 +142,8 @@ class TorchCamBuilder(CamBuilder):
             activation function.
         :param extra_inputs_list: (optional, defaults is None) A list of additional input objects required by the
             model's forward method.
+        :param eps: (optional, default is 1e-6) A float number used in probability clamping before logarithm application
+            to avoid null or None results.
 
         :return:
             - cam_list: A list of np.ndarray containing CAMs for each item in the input data list, corresponding to the
@@ -184,30 +187,32 @@ class TorchCamBuilder(CamBuilder):
             outputs = outputs[self.model_output_index]
 
         if softmax_final:
-            # Approximate Softmax inversion formula logit = log(prob) + constant, as the constant is negligible
-            # during derivation. Clamp probabilities before log application to avoid null maps for maximum confidence.
-            target_scores = torch.log(torch.clamp(outputs, min=0, max=1 - 1e-6))
             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)
+            if len(outputs.shape) == 2 and outputs.shape[1] > 1:
+                # Approximate Softmax inversion formula logit = log(prob) + constant, as the constant is negligible
+                # during derivation. Clamp probabilities before log application to avoid null maps for maximum
+                # confidence.
+                target_scores = torch.log(torch.clamp(outputs, min=eps, max=1 - eps))
+            else:
+                # Adjust results for binary networks
+                target_scores = torch.logit(outputs, eps=eps)
+                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)
+                else:
+                    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
-
             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)
+                if len(outputs.shape) == 1:
+                    target_scores = torch.stack([-outputs, outputs], dim=1)
+                elif len(outputs.shape) == 2 and outputs.shape[1] == 1:
+                    target_scores = torch.cat([-outputs, outputs], dim=1)
+                p = torch.sigmoid(outputs)
+                target_probs = torch.stack([1 - p, p], dim=1)
 
         target_probs = target_probs[:, target_class].cpu().detach().numpy()
 

{signal_grad_cam-0.1.3 → signal_grad_cam-0.1.4}/signal_grad_cam/tensorflow_cam_builder.py

@@ -150,7 +150,8 @@ class TfCamBuilder(CamBuilder):
 
     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]:
+                                 extra_inputs_list: List[Any] = None, eps: float = 1e-6) \
+            -> 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.
@@ -166,6 +167,8 @@ class TfCamBuilder(CamBuilder):
             activation function.
         :param extra_inputs_list: (optional, defaults is None) A list of additional input objects required by the
             model's forward method.
+        :param eps: (optional, default is 1e-6) A float number used in probability clamping before logarithm application
+            to avoid null or None results.
 
         :return:
             - cam_list: A list of np.ndarray containing CAMs for each item in the input data list, corresponding to the
@@ -199,31 +202,32 @@ class TfCamBuilder(CamBuilder):
             self.activations, outputs = grad_model([data_batch] + extra_inputs_list)
 
             if softmax_final:
-                # Approximate Softmax inversion formula logit = log(prob) + constant, as the constant is negligible
-                # during derivation. Clamp probabilities before log application to avoid null maps for maximum
-                # confidence.
-                target_scores = tf.math.log(tf.clip_by_value(outputs, 0, 1.0 - 1e-6))
                 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)
+                if len(outputs.shape) == 2 and outputs.shape[1] > 1:
+                    # Approximate Softmax inversion formula logit = log(prob) + constant, as the constant is negligible
+                    # during derivation. Clamp probabilities before log application to avoid null maps for maximum
+                    # confidence.
+                    target_scores = tf.math.log(tf.clip_by_value(outputs, eps, 1.0 - eps))
+                else:
+                    # Adjust results for binary network
+                    target_scores = tf.math.logit(outputs, eps=eps)
+                    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)
+                    else:
+                        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
-
                 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)
+                    if len(outputs.shape) == 1:
+                        target_scores = tf.stack([-outputs, outputs], axis=1)
+                    elif len(outputs.shape) == 2 and outputs.shape[1] == 1:
+                        target_scores = tf.concat([-outputs, outputs], axis=1)
+                    p = tf.math.sigmoid(outputs)
+                    target_probs = tf.stack([1 - p, p], axis=1)
 
             target_scores = target_scores[:, target_class]
             target_probs = target_probs[:, target_class]

{signal_grad_cam-0.1.3 → signal_grad_cam-0.1.4}/signal_grad_cam.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: signal-grad-cam
-Version: 0.1.3
+Version: 0.1.4
 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