Merge pull request #2660 from Trusted-AI/dependabot/pip/mypy-1.16.0

Bump mypy from 1.11.1 to 1.16.0

Author: beat-buesser

art/attacks/evasion/adversarial_patch/adversarial_patch_pytorch.py

@@ -658,9 +658,10 @@ def __getitem__(self, idx):
 
             # Write summary
             if self.summary_writer is not None:  # pragma: no cover
+                mask_tensor = torch.from_numpy(mask).to(self.estimator.device)
                 x_patched = (
                     self._random_overlay(
-                        images=torch.from_numpy(x).to(self.estimator.device), patch=self._patch, mask=mask
+                        images=torch.from_numpy(x).to(self.estimator.device), patch=self._patch, mask=mask_tensor
                     )
                     .detach()
                     .cpu()

art/attacks/evasion/fast_gradient.py

@@ -126,7 +126,7 @@ def _check_compatibility_input_and_eps(self, x: np.ndarray):
             if self.eps.ndim > x.ndim:  # pragma: no cover
                 raise ValueError("The `eps` shape must be broadcastable to input shape.")
 
-    def _minimal_perturbation(self, x: np.ndarray, y: np.ndarray, mask: np.ndarray) -> np.ndarray:
+    def _minimal_perturbation(self, x: np.ndarray, y: np.ndarray, mask: np.ndarray | None) -> np.ndarray:
         """
         Iteratively compute the minimal perturbation necessary to make the class prediction change. Stop when the
         first adversarial example was found.
@@ -591,7 +591,7 @@ def _compute(
         return x_adv
 
     @staticmethod
-    def _get_mask(x: np.ndarray, **kwargs) -> np.ndarray:
+    def _get_mask(x: np.ndarray, **kwargs) -> np.ndarray | None:
         """
         Get the mask from the kwargs.
 
@@ -602,7 +602,7 @@ def _get_mask(x: np.ndarray, **kwargs) -> np.ndarray:
         :type mask: `np.ndarray`
         :return: The mask.
         """
-        mask = kwargs.get("mask")
+        mask: np.ndarray | None = kwargs.get("mask")
 
         if mask is not None:
             if mask.ndim > x.ndim:  # pragma: no cover

art/attacks/evasion/graphite/graphite_blackbox.py

@@ -245,6 +245,9 @@ def generate(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> np.n
         # target initialization image
         x_tar = kwargs.get("x_tar")
 
+        if x_tar is None:
+            raise ValueError("x_tar is None. Please provide x_tar as initial array to act as the example target image.")
+
         # Some initial setups
         x_adv = x.astype(ART_NUMPY_DTYPE)
 

art/attacks/evasion/shadow_attack.py

@@ -243,7 +243,7 @@ def _get_regularisation_loss_gradients(self, perturbation: np.ndarray) -> np.nda
             loss_c = perturbation_t.abs().mean([2, 3]).norm(dim=1) ** 2
             loss = torch.mean(self.lambda_tv * loss_tv + self.lambda_s * loss_s + self.lambda_c * loss_c)
             loss.backward()
-            gradients = perturbation_t.grad.numpy()
+            gradients = perturbation_t.grad.numpy()  # type: ignore
         else:
             raise NotImplementedError
 

art/attacks/poisoning/gradient_matching_attack.py

@@ -499,7 +499,7 @@ def __len__(self):
                 sum_loss += loss.clone().cpu().detach().numpy()
                 count += 1
             if self.verbose > 0:
-                epoch_iterator.set_postfix(loss=sum_loss / count)
+                epoch_iterator.set_postfix(loss=sum_loss / count)  # type: ignore
             self.lr_schedule.step()
 
         B_sum = 0  # pylint: disable=invalid-name

art/defences/trainer/certified_adversarial_trainer_pytorch.py

@@ -221,10 +221,11 @@ def fit(
         y = check_and_transform_label_format(y, nb_classes=self.classifier.nb_classes)
 
         # Apply preprocessing
+        y_preprocessed: np.ndarray
         x_preprocessed, y_preprocessed = self.classifier.apply_preprocessing(x, y, fit=True)
 
         # Check label shape
-        y_preprocessed = self.classifier.reduce_labels(y_preprocessed)
+        y_preprocessed = self.classifier.reduce_labels(y_preprocessed)  # type: ignore
 
         num_batch = int(np.ceil(len(x_preprocessed) / float(self.pgd_params["batch_size"])))
         ind = np.arange(len(x_preprocessed)).tolist()
@@ -268,8 +269,8 @@ def fit(
                 for i, (sample, label) in enumerate(zip(x_cert, y_cert)):
 
                     self.set_forward_mode("concrete")
-                    concrete_pred = self.classifier.model.forward(np.expand_dims(sample, axis=0))
-                    concrete_pred = torch.argmax(concrete_pred)
+                    concrete_pred_tensor = self.classifier.model.forward(np.expand_dims(sample, axis=0))
+                    concrete_pred = int(torch.argmax(concrete_pred_tensor).item())
 
                     if self.classifier.concrete_to_zonotope is None:
                         if sys.version_info >= (3, 8):

art/defences/trainer/ibp_certified_trainer_pytorch.py

@@ -378,7 +378,7 @@ def fit(
                         max_iter=self.pgd_params["max_iter"],
                         num_random_init=self.pgd_params["num_random_init"],
                     )
-                    i_batch = self.attack.generate(i_batch, y=o_batch)
+                    i_batch = self.attack.generate(i_batch, y=o_batch)  # type: ignore
                     self.classifier.model.zero_grad()
                 else:
                     i_batch = np.copy(x_preprocessed[ind[m * batch_size : (m + 1) * batch_size]]).astype("float32")

art/estimators/certification/interval/interval.py

@@ -201,7 +201,7 @@ def re_convert(self, device: str | "torch.device") -> None:
         if self.bias is not None:
             self.bias = self.bias.to(device)
 
-    def convert_to_dense(self, device: str | "torch.device") -> tuple["torch.Tensor", "torch.Tensor"]:
+    def convert_to_dense(self, device: str | "torch.device") -> tuple["torch.Tensor", "torch.Tensor" | None]:
         """
         Converts the initialised convolutional layer into an equivalent dense layer.
 
@@ -283,6 +283,9 @@ def forward(self, x: "torch.Tensor") -> "torch.Tensor":
         :param x: interval representation of the datapoint.
         :return: output of the convolutional layer on x
         """
+        if self.bias is None:
+            raise ValueError("self.bias is None, therefore this function cannot calculate the forward pass.")
+
         x = torch.reshape(x, (x.shape[0], 2, -1))
 
         center = (x[:, 1] + x[:, 0]) / 2

art/estimators/certification/object_seeker/pytorch.py

@@ -351,7 +351,7 @@ def loss_gradient(
         """
         return self.detector.loss_gradient(
             x=x,
-            y=y,
+            y=y,  # type: ignore
             **kwargs,
         )
 

art/estimators/certification/randomized_smoothing/pytorch.py

@@ -241,7 +241,7 @@ def predict(  # type: ignore
 
     def loss_gradient(  # type: ignore
         self, x: np.ndarray, y: np.ndarray, training_mode: bool = False, **kwargs
-    ) -> np.ndarray:
+    ) -> np.ndarray | "torch.Tensor":
         """
         Compute the gradient of the loss function w.r.t. `x`.