Merge pull request #968 from Trusted-AI/development_maintenance_160

General format updates for dev_1.6.0

Author: beat-buesser

art/attacks/evasion/adversarial_asr.py

@@ -47,6 +47,8 @@ class CarliniWagnerASR(ImperceptibleASR):
         "learning_rate",
         "max_iter",
         "batch_size",
+        "decrease_factor_eps",
+        "num_iter_decrease_eps",
     ]
 
     def __init__(
@@ -55,6 +57,8 @@ def __init__(
         eps: float = 2000.0,
         learning_rate: float = 100.0,
         max_iter: int = 1000,
+        decrease_factor_eps: float = 0.8,
+        num_iter_decrease_eps: int = 10,
         batch_size: int = 16,
     ):
         """
@@ -64,6 +68,8 @@ def __init__(
         :param eps: Initial max norm bound for adversarial perturbation.
         :param learning_rate: Learning rate of attack.
         :param max_iter: Number of iterations.
+        :param decrease_factor_eps: Decrease factor for epsilon (Paper default: 0.8).
+        :param num_iter_decrease_eps: Iterations after which to decrease epsilon if attack succeeds (Paper default: 10).
         :param batch_size: Batch size.
         """
         # pylint: disable=W0231
@@ -76,14 +82,14 @@ def __init__(
         self.max_iter_1 = max_iter
         self.max_iter_2 = 0
         self._targeted = True
+        self.decrease_factor_eps = decrease_factor_eps
+        self.num_iter_decrease_eps = num_iter_decrease_eps
         self.batch_size = batch_size
 
         # set remaining stage 2 params to some random values
         self.alpha = 0.1
         self.learning_rate_2 = 0.1
         self.loss_theta_min = 0.0
-        self.decrease_factor_eps: float = 1.0
-        self.num_iter_decrease_eps: int = 1
         self.increase_factor_alpha: float = 1.0
         self.num_iter_increase_alpha: int = 1
         self.decrease_factor_alpha: float = 1.0

art/attacks/evasion/adversarial_patch/adversarial_patch_pytorch.py

@@ -86,7 +86,7 @@ def __init__(
         :param scale_min: The minimum scaling applied to random patches. The value should be in the range `[0, 1]`,
                but less than `scale_max`.
         :param scale_max: The maximum scaling applied to random patches. The value should be in the range `[0, 1]`, but
-               larger than `scale_min.`
+               larger than `scale_min`.
         :param distortion_scale_max: The maximum distortion scale for perspective transformation in range `[0, 1]`. If
                distortion_scale_max=0.0 the perspective transformation sampling will be disabled.
         :param learning_rate: The learning rate of the optimization.

art/attacks/evasion/adversarial_patch/utils.py

@@ -15,6 +15,9 @@
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
+"""
+This module implements utility functions for adversarial patch attacks.
+"""
 import numpy as np
 
 
@@ -56,14 +59,14 @@ def insert_transformed_patch(x: np.ndarray, patch: np.ndarray, image_coords: np.
         )
 
     # calculate homography
-    h, status = cv2.findHomography(patch_coords, image_coords)
+    height, _ = cv2.findHomography(patch_coords, image_coords)
 
     # warp patch to destination coordinates
-    x_out = cv2.warpPerspective(patch, h, (x.shape[1], x.shape[0]), cv2.INTER_CUBIC)
+    x_out = cv2.warpPerspective(patch, height, (x.shape[1], x.shape[0]), cv2.INTER_CUBIC)
 
     # mask to aid with insertion
     mask = np.ones(patch.shape)
-    mask_out = cv2.warpPerspective(mask, h, (x.shape[1], x.shape[0]), cv2.INTER_CUBIC)
+    mask_out = cv2.warpPerspective(mask, height, (x.shape[1], x.shape[0]), cv2.INTER_CUBIC)
 
     # save image before adding shadows
     x_neg_patch = np.copy(x)

art/attacks/evasion/auto_projected_gradient_descent.py

@@ -384,7 +384,7 @@ def _check_params(self) -> None:
             raise ValueError("The first element of the brightness range must be less or equal to the second one.")
 
         if not isinstance(self.rotation_weights, (tuple, list)) or not all(
-            isinstance(s, float) or isinstance(s, int) for s in self.rotation_weights
+            isinstance(s, (float, int)) for s in self.rotation_weights
         ):
             raise ValueError("The rotation sampling weights must be provided as tuple or list of float or int values.")
         if len(self.rotation_weights) != 4:

art/attacks/evasion/dpatch_robust.py

@@ -112,8 +112,8 @@ def generate(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> n
         if self.method == "one_shot":
             if y is None:
                 return self.attacker.generate(x)
-            else:
-                return self.attacker.generate(x, y)
+
+            return self.attacker.generate(x, y)
 
         if y is None:
             # Throw error if attack is targeted, but no targets are provided