Apply Black formatter

Signed-off-by: Beat Buesser <[email protected]>

Author: Beat Buesser

art/attacks/evasion/boundary.py

@@ -204,8 +204,9 @@ def _perturb(
             return x
 
         # If an initial adversarial example found, then go with boundary attack
-        x_adv = self._attack(initial_sample[0], x, y_p, initial_sample[1], self.delta, self.epsilon, clip_min,
-                             clip_max,)
+        x_adv = self._attack(
+            initial_sample[0], x, y_p, initial_sample[1], self.delta, self.epsilon, clip_min, clip_max,
+        )
 
         return x_adv
 

art/attacks/evasion/imperceptible_asr/imperceptible_asr_pytorch.py

@@ -468,9 +468,7 @@ def _forward_1st_stage(
 
         # Transform data into the model input space
         inputs, targets, input_rates, target_sizes, batch_idx = self.estimator.preprocess_transform_model_input(
-            x=masked_adv_input.to(self.estimator.device),
-            y=original_output,
-            real_lengths=real_lengths,
+            x=masked_adv_input.to(self.estimator.device), y=original_output, real_lengths=real_lengths,
         )
 
         # Compute real input sizes
@@ -610,10 +608,7 @@ class only supports targeted attack.
         return result
 
     def _forward_2nd_stage(
-        self,
-        local_delta_rescale: "torch.Tensor",
-        theta_batch: np.ndarray,
-        original_max_psd_batch: np.ndarray,
+        self, local_delta_rescale: "torch.Tensor", theta_batch: np.ndarray, original_max_psd_batch: np.ndarray,
     ) -> "torch.Tensor":
         """
         The forward pass of the second stage of the attack.
@@ -671,7 +666,7 @@ def _compute_masking_threshold(self, x: np.ndarray) -> Tuple[np.ndarray, np.ndar
 
         psd = abs(transformed_x / win_length)
         original_max_psd = np.max(psd * psd)
-        with np.errstate(divide='ignore'):
+        with np.errstate(divide="ignore"):
             psd = (20 * np.log10(psd)).clip(min=-200)
         psd = 96 - np.max(psd) + psd
 

art/attacks/inference/attribute_inference/baseline.py

@@ -44,12 +44,11 @@ class AttributeInferenceBaseline(AttributeInferenceAttack):
     The idea is to train a simple neural network to learn the attacked feature from the rest of the features. Should
     be used to compare with other attribute inference results.
     """
+
     _estimator_requirements = ()
 
     def __init__(
-        self,
-        attack_model: Optional["CLASSIFIER_TYPE"] = None,
-        attack_feature: Union[int, slice] = 0,
+        self, attack_model: Optional["CLASSIFIER_TYPE"] = None, attack_feature: Union[int, slice] = 0,
     ):
         """
         Create an AttributeInferenceBaseline attack instance.

art/attacks/poisoning/clean_label_backdoor_attack.py

@@ -123,8 +123,12 @@ def poison(
 
         # Run untargeted PGD on selected points, making it hard to classify correctly
         perturbed_input = self.attack.generate(data[selected_indices])
-        no_change_detected = np.array([np.all(data[selected_indices][poison_idx] == perturbed_input[poison_idx])
-                                       for poison_idx in range(len(perturbed_input))])
+        no_change_detected = np.array(
+            [
+                np.all(data[selected_indices][poison_idx] == perturbed_input[poison_idx])
+                for poison_idx in range(len(perturbed_input))
+            ]
+        )
 
         if any(no_change_detected):
             logger.warning("Perturbed input is the same as original data after PGD. Check params.")

art/attacks/poisoning/perturbations/image_perturbations.py

@@ -86,15 +86,15 @@ def add_pattern_bd(x: np.ndarray, distance: int = 2, pixel_value: int = 1) -> np
 
 
 def insert_image(
-        x: np.ndarray,
-        backdoor_path: str = "../utils/data/backdoors/alert.png",
-        channels_first: bool = False,
-        random: bool = True,
-        x_shift: int = 0,
-        y_shift: int = 0,
-        size: Optional[Tuple[int, int]] = None,
-        mode: str = "L",
-        blend=0.8,
+    x: np.ndarray,
+    backdoor_path: str = "../utils/data/backdoors/alert.png",
+    channels_first: bool = False,
+    random: bool = True,
+    x_shift: int = 0,
+    y_shift: int = 0,
+    size: Optional[Tuple[int, int]] = None,
+    mode: str = "L",
+    blend=0.8,
 ) -> np.ndarray:
     """
     Augments a matrix by setting a checkboard-like pattern of values some `distance` away from the bottom-right
@@ -115,8 +115,11 @@ def insert_image(
     n_dim = len(x.shape)
     if n_dim == 4:
         return np.array(
-            [insert_image(single_img, backdoor_path, channels_first, random, x_shift, y_shift, size, mode, blend)
-             for single_img in x])
+            [
+                insert_image(single_img, backdoor_path, channels_first, random, x_shift, y_shift, size, mode, blend)
+                for single_img in x
+            ]
+        )
 
     if n_dim != 3:
         raise ValueError("Invalid array shape " + str(x.shape))
@@ -128,17 +131,17 @@ def insert_image(
     width, height, num_channels = x.shape
 
     no_color = num_channels == 1
-    orig_img = Image.new('RGBA', (width, height), 0)
-    backdoored_img = Image.new('RGBA', (width, height), 0)
+    orig_img = Image.new("RGBA", (width, height), 0)
+    backdoored_img = Image.new("RGBA", (width, height), 0)
 
     if no_color:
-        backdoored_input = Image.fromarray((data * 255).astype('uint8').squeeze(axis=2), mode=mode)
+        backdoored_input = Image.fromarray((data * 255).astype("uint8").squeeze(axis=2), mode=mode)
     else:
-        backdoored_input = Image.fromarray((data * 255).astype('uint8'), mode=mode)
+        backdoored_input = Image.fromarray((data * 255).astype("uint8"), mode=mode)
 
     orig_img.paste(backdoored_input)
 
-    trigger = Image.open(backdoor_path).convert('RGBA')
+    trigger = Image.open(backdoor_path).convert("RGBA")
     if size:
         trigger = trigger.resize(size)
 

art/estimators/classification/pytorch.py

@@ -440,7 +440,7 @@ def fit_generator(self, generator: "DataGenerator", nb_epochs: int = 20, **kwarg
             # Fit a generic data generator through the API
             super().fit_generator(generator, nb_epochs=nb_epochs)
 
-    def clone_for_refitting(self) -> 'PyTorchClassifier':  # lgtm [py/inheritance/incorrect-overridden-signature]
+    def clone_for_refitting(self) -> "PyTorchClassifier":  # lgtm [py/inheritance/incorrect-overridden-signature]
         """
         Create a copy of the classifier that can be refit from scratch. Will inherit same architecture, optimizer and
         initialization as cloned model, but without weights.

art/estimators/pytorch.py

@@ -60,9 +60,7 @@ def __init__(self, device_type: str = "gpu", **kwargs) -> None:
 
         preprocessing = kwargs.get("preprocessing")
         if isinstance(preprocessing, tuple):
-            from art.preprocessing.standardisation_mean_std.pytorch import (
-                StandardisationMeanStdPyTorch,
-            )
+            from art.preprocessing.standardisation_mean_std.pytorch import StandardisationMeanStdPyTorch
 
             kwargs["preprocessing"] = StandardisationMeanStdPyTorch(mean=preprocessing[0], std=preprocessing[1])
 
@@ -167,9 +165,7 @@ def _apply_preprocessing(self, x, y, fit: bool = False, no_grad=True) -> Tuple[A
         """
         import torch
         from art.preprocessing.standardisation_mean_std.numpy import StandardisationMeanStd
-        from art.preprocessing.standardisation_mean_std.pytorch import (
-            StandardisationMeanStdPyTorch,
-        )
+        from art.preprocessing.standardisation_mean_std.pytorch import StandardisationMeanStdPyTorch
 
         if not self.preprocessing_operations:
             return x, y
@@ -243,9 +239,7 @@ def _apply_preprocessing_gradient(self, x, gradients, fit=False):
         """
         import torch
         from art.preprocessing.standardisation_mean_std.numpy import StandardisationMeanStd
-        from art.preprocessing.standardisation_mean_std.pytorch import (
-            StandardisationMeanStdPyTorch,
-        )
+        from art.preprocessing.standardisation_mean_std.pytorch import StandardisationMeanStdPyTorch
 
         if not self.preprocessing_operations:
             return gradients

art/estimators/speech_recognition/pytorch_deep_speech.py

@@ -260,11 +260,7 @@ def __init__(
                 enabled = True
 
             self._model, self._optimizer = amp.initialize(
-                models=self._model,
-                optimizers=self._optimizer,
-                enabled=enabled,
-                opt_level=opt_level,
-                loss_scale=1.0,
+                models=self._model, optimizers=self._optimizer, enabled=enabled, opt_level=opt_level, loss_scale=1.0,
             )
 
     def predict(
@@ -526,10 +522,7 @@ def fit(self, x: np.ndarray, y: np.ndarray, batch_size: int = 128, nb_epochs: in
                 self._optimizer.step()
 
     def preprocess_transform_model_input(
-        self,
-        x: "torch.Tensor",
-        y: np.ndarray,
-        real_lengths: np.ndarray,
+        self, x: "torch.Tensor", y: np.ndarray, real_lengths: np.ndarray,
     ) -> Tuple["torch.Tensor", "torch.Tensor", "torch.Tensor", "torch.Tensor", List]:
         """
         Apply preprocessing and then transform the user input space into the model input space. This function is used
@@ -560,11 +553,7 @@ def preprocess_transform_model_input(
 
         # Transform the input space
         inputs, targets, input_rates, target_sizes, batch_idx = self._transform_model_input(
-            x=x,
-            y=y,
-            compute_gradient=False,
-            tensor_input=True,
-            real_lengths=real_lengths,
+            x=x, y=y, compute_gradient=False, tensor_input=True, real_lengths=real_lengths,
         )
 
         return inputs, targets, input_rates, target_sizes, batch_idx

art/estimators/tensorflow.py

@@ -114,9 +114,7 @@ def __init__(self, **kwargs):
         """
         preprocessing = kwargs.get("preprocessing")
         if isinstance(preprocessing, tuple):
-            from art.preprocessing.standardisation_mean_std.tensorflow import (
-                StandardisationMeanStdTensorFlow,
-            )
+            from art.preprocessing.standardisation_mean_std.tensorflow import StandardisationMeanStdTensorFlow
 
             kwargs["preprocessing"] = StandardisationMeanStdTensorFlow(mean=preprocessing[0], std=preprocessing[1])
 
@@ -200,9 +198,7 @@ def _apply_preprocessing(self, x, y, fit: bool = False) -> Tuple[Any, Any]:
         """
         import tensorflow as tf  # lgtm [py/repeated-import]
         from art.preprocessing.standardisation_mean_std.numpy import StandardisationMeanStd
-        from art.preprocessing.standardisation_mean_std.tensorflow import (
-            StandardisationMeanStdTensorFlow,
-        )
+        from art.preprocessing.standardisation_mean_std.tensorflow import StandardisationMeanStdTensorFlow
 
         if not self.preprocessing_operations:
             return x, y
@@ -270,9 +266,7 @@ def _apply_preprocessing_gradient(self, x, gradients, fit=False):
         """
         import tensorflow as tf  # lgtm [py/repeated-import]
         from art.preprocessing.standardisation_mean_std.numpy import StandardisationMeanStd
-        from art.preprocessing.standardisation_mean_std.tensorflow import (
-            StandardisationMeanStdTensorFlow,
-        )
+        from art.preprocessing.standardisation_mean_std.tensorflow import StandardisationMeanStdTensorFlow
 
         if not self.preprocessing_operations:
             return gradients