Merge pull request #592 from Trusted-AI/development_maintenance_140

General code maintenance updates

Author: beat-buesser

.travis.yml

@@ -17,7 +17,7 @@ jobs:
     - python: 3.7
       env: TENSORFLOW_V=2.2.0 KERAS_V=2.3.1
       script:
-        - (pycodestyle --max-line-length=120 art || exit 0)
+        - (pycodestyle --ignore=C0330,C0415,E203,E231,W503 --max-line-length=120 art || exit 0)
         - (pylint --disable=C0330,C0415,E203,E1136 -rn art || exit 0)
         - (mypy art || exit 0)
         - py.test --pep8 -m pep8
@@ -32,6 +32,3 @@ install:
   - pip install -q pylint pycodestyle
   - pip install -q -r requirements.txt
   - pip list
-
-#script:
-#  - ./run_tests.sh

art/attacks/attack.py

@@ -22,14 +22,14 @@
 
 import abc
 import logging
-from typing import List, Optional, Tuple, TYPE_CHECKING
+from typing import Any, List, Optional, Tuple, Union, TYPE_CHECKING
 
 import numpy as np
 
 from art.exceptions import EstimatorError
 
 if TYPE_CHECKING:
-    from art.estimators.classification.classifier import Classifier
+    from art.utils import CLASSIFIER_TYPE
 
 logger = logging.getLogger(__name__)
 
@@ -90,11 +90,15 @@ class Attack(abc.ABC, metaclass=input_filter):
     """
 
     attack_params: List[str] = list()
+    _estimator_requirements: Optional[Union[Tuple[Any, ...], Tuple[()]]] = None
 
     def __init__(self, estimator):
         """
         :param estimator: An estimator.
         """
+        if self.estimator_requirements is None:
+            raise ValueError("Estimator requirements have not been defined in `_estimator_requirements`.")
+
         if not all(t in type(estimator).__mro__ for t in self.estimator_requirements):
             raise EstimatorError(self.__class__, self.estimator_requirements, estimator)
 
@@ -129,8 +133,8 @@ class EvasionAttack(Attack):
     """
 
     def __init__(self, **kwargs) -> None:
-        self._targeted = None
-        super(EvasionAttack, self).__init__(**kwargs)
+        self._targeted = False
+        super().__init__(**kwargs)
 
     @abc.abstractmethod
     def generate(  # lgtm [py/inheritance/incorrect-overridden-signature]
@@ -148,7 +152,7 @@ def generate(  # lgtm [py/inheritance/incorrect-overridden-signature]
         raise NotImplementedError
 
     @property
-    def targeted(self) -> Optional[bool]:
+    def targeted(self) -> bool:
         """
         Return Boolean if attack is targeted. Return None if not applicable.
         """
@@ -164,7 +168,7 @@ class PoisoningAttack(Attack):
     Abstract base class for poisoning attack classes
     """
 
-    def __init__(self, classifier: Optional["Classifier"]) -> None:
+    def __init__(self, classifier: Optional["CLASSIFIER_TYPE"]) -> None:
         """
         :param classifier: A trained classifier (or none if no classifier is needed)
         """
@@ -189,10 +193,9 @@ class PoisoningAttackTransformer(PoisoningAttack):
     These attacks have an additional method, `poison_estimator`, that returns the poisoned classifier.
     """
 
-    def __init__(self, classifier: Optional["Classifier"], **kwargs) -> None:
+    def __init__(self, classifier: Optional["CLASSIFIER_TYPE"], **kwargs) -> None:
         """
         :param classifier: A trained classifier (or none if no classifier is needed)
-        :type classifier: `art.estimators.classification.Classifier` or `None`
         """
         super().__init__(classifier)
 
@@ -210,7 +213,7 @@ def poison(self, x: np.ndarray, y=Optional[np.ndarray], **kwargs) -> Tuple[np.nd
         raise NotImplementedError
 
     @abc.abstractmethod
-    def poison_estimator(self, x: np.ndarray, y: np.ndarray, **kwargs) -> "Classifier":
+    def poison_estimator(self, x: np.ndarray, y: np.ndarray, **kwargs) -> "CLASSIFIER_TYPE":
         """
         Returns a poisoned version of the classifier used to initialize the attack
         :param x: Training data
@@ -269,7 +272,7 @@ class ExtractionAttack(Attack):
     """
 
     @abc.abstractmethod
-    def extract(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> "Classifier":
+    def extract(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> "CLASSIFIER_TYPE":
         """
         Extract models and return them as an ART classifier. This method should be overridden by all concrete extraction
         attack implementations.
@@ -340,7 +343,7 @@ def set_params(self, **kwargs) -> None:
         Take in a dictionary of parameters and applies attack-specific checks before saving them as attributes.
         """
         # Save attack-specific parameters
-        super(AttributeInferenceAttack, self).set_params(**kwargs)
+        super().set_params(**kwargs)
         self._check_params()
 
     def _check_params(self) -> None:

art/attacks/evasion/adversarial_patch/adversarial_patch.py

@@ -24,21 +24,21 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 
 import logging
-from typing import Optional, Tuple, Union
+from typing import Optional, Tuple, Union, TYPE_CHECKING
 
 import numpy as np
 
 from art.attacks.evasion.adversarial_patch.adversarial_patch_numpy import AdversarialPatchNumpy
 from art.attacks.evasion.adversarial_patch.adversarial_patch_tensorflow import AdversarialPatchTensorFlowV2
 from art.estimators.estimator import BaseEstimator, NeuralNetworkMixin
-from art.estimators.classification.classifier import (
-    ClassifierMixin,
-    ClassifierNeuralNetwork,
-    ClassifierGradients,
-)
+from art.estimators.classification.classifier import ClassifierMixin
+
 from art.estimators.classification import TensorFlowV2Classifier
 from art.attacks.attack import EvasionAttack
 
+if TYPE_CHECKING:
+    from art.utils import CLASSIFIER_NEURALNETWORK_TYPE
+
 logger = logging.getLogger(__name__)
 
 
@@ -62,7 +62,7 @@ class AdversarialPatch(EvasionAttack):
 
     def __init__(
         self,
-        classifier: Union[ClassifierNeuralNetwork, ClassifierGradients],
+        classifier: "CLASSIFIER_NEURALNETWORK_TYPE",
         rotation_max: float = 22.5,
         scale_min: float = 0.1,
         scale_max: float = 1.0,
@@ -88,7 +88,7 @@ def __init__(
                             Currently only supported for `TensorFlowV2Classifier`. For classifiers of other frameworks
                             the `patch_shape` is set to the shape of the input samples.
         """
-        super(AdversarialPatch, self).__init__(estimator=classifier)
+        super().__init__(estimator=classifier)
         if self.estimator.clip_values is None:
             raise ValueError("Adversarial Patch attack requires a classifier with clip_values.")
 

art/attacks/evasion/adversarial_patch/adversarial_patch_numpy.py

@@ -25,7 +25,7 @@
 
 import logging
 import math
-from typing import Optional, Union, Tuple
+from typing import Optional, Union, Tuple, TYPE_CHECKING
 
 import random
 import numpy as np
@@ -34,13 +34,12 @@
 
 from art.attacks.attack import EvasionAttack
 from art.estimators.estimator import BaseEstimator, NeuralNetworkMixin
-from art.estimators.classification.classifier import (
-    ClassifierMixin,
-    ClassifierNeuralNetwork,
-    ClassifierGradients,
-)
+from art.estimators.classification.classifier import ClassifierMixin
 from art.utils import check_and_transform_label_format
 
+if TYPE_CHECKING:
+    from art.utils import CLASSIFIER_NEURALNETWORK_TYPE
+
 logger = logging.getLogger(__name__)
 
 
@@ -64,7 +63,7 @@ class AdversarialPatchNumpy(EvasionAttack):
 
     def __init__(
         self,
-        classifier: Union[ClassifierNeuralNetwork, ClassifierGradients],
+        classifier: "CLASSIFIER_NEURALNETWORK_TYPE",
         target: int = 0,
         rotation_max: float = 22.5,
         scale_min: float = 0.1,
@@ -91,7 +90,7 @@ def __init__(
                [(float, float), (float, float), (float, float)].
         :param batch_size: The size of the training batch.
         """
-        super(AdversarialPatchNumpy, self).__init__(estimator=classifier)
+        super().__init__(estimator=classifier)
 
         self.target = target
         self.rotation_max = rotation_max
@@ -222,17 +221,17 @@ def _check_params(self) -> None:
 
         if not isinstance(self.learning_rate, float):
             raise ValueError("The learning rate must be of type float.")
-        if not self.learning_rate > 0.0:
+        if self.learning_rate <= 0.0:
             raise ValueError("The learning rate must be greater than 0.0.")
 
         if not isinstance(self.max_iter, int):
             raise ValueError("The number of optimization steps must be of type int.")
-        if not self.max_iter > 0:
+        if self.max_iter <= 0:
             raise ValueError("The number of optimization steps must be greater than 0.")
 
         if not isinstance(self.batch_size, int):
             raise ValueError("The batch size must be of type int.")
-        if not self.batch_size > 0:
+        if self.batch_size <= 0:
             raise ValueError("The batch size must be greater than 0.")
 
     def _get_circular_patch_mask(self, sharpness: int = 40) -> np.ndarray:
@@ -261,14 +260,14 @@ def _get_circular_patch_mask(self, sharpness: int = 40) -> np.ndarray:
 
         if self.estimator.channels_first:
             if self.nb_dims == 3:
-                pad_width = ((0, 0), (pad_h_before, pad_h_after), (pad_w_before, pad_w_after))
+                pad_width = ((0, 0), (pad_h_before, pad_h_after), (pad_w_before, pad_w_after))  # type: ignore
             elif self.nb_dims == 4:
-                pad_width = ((0, 0), (0, 0), (pad_h_before, pad_h_after), (pad_w_before, pad_w_after))
+                pad_width = ((0, 0), (0, 0), (pad_h_before, pad_h_after), (pad_w_before, pad_w_after))  # type: ignore
         else:
             if self.nb_dims == 3:
-                pad_width = ((pad_h_before, pad_h_after), (pad_w_before, pad_w_after), (0, 0))
+                pad_width = ((pad_h_before, pad_h_after), (pad_w_before, pad_w_after), (0, 0))  # type: ignore
             elif self.nb_dims == 4:
-                pad_width = ((0, 0), (pad_h_before, pad_h_after), (pad_w_before, pad_w_after), (0, 0))
+                pad_width = ((0, 0), (pad_h_before, pad_h_after), (pad_w_before, pad_w_after), (0, 0))  # type: ignore
 
         mask = np.pad(mask, pad_width=pad_width, mode="constant", constant_values=(0, 0),)
 

art/attacks/evasion/adversarial_patch/adversarial_patch_tensorflow.py

@@ -32,16 +32,14 @@
 
 from art.attacks.attack import EvasionAttack
 from art.estimators.estimator import BaseEstimator, NeuralNetworkMixin
-from art.estimators.classification.classifier import (
-    ClassifierMixin,
-    ClassifierNeuralNetwork,
-    ClassifierGradients,
-)
+from art.estimators.classification.classifier import ClassifierMixin
 from art.utils import check_and_transform_label_format
 
 if TYPE_CHECKING:
     import tensorflow as tf
 
+    from art.utils import CLASSIFIER_NEURALNETWORK_TYPE
+
 logger = logging.getLogger(__name__)
 
 
@@ -66,7 +64,7 @@ class AdversarialPatchTensorFlowV2(EvasionAttack):
 
     def __init__(
         self,
-        classifier: Union[ClassifierNeuralNetwork, ClassifierGradients],
+        classifier: "CLASSIFIER_NEURALNETWORK_TYPE",
         rotation_max: float = 22.5,
         scale_min: float = 0.1,
         scale_max: float = 1.0,
@@ -92,14 +90,17 @@ def __init__(
         """
         import tensorflow as tf  # lgtm [py/repeated-import]
 
-        super(AdversarialPatchTensorFlowV2, self).__init__(estimator=classifier)
+        super().__init__(estimator=classifier)
         self.rotation_max = rotation_max
         self.scale_min = scale_min
         self.scale_max = scale_max
         self.learning_rate = learning_rate
         self.max_iter = max_iter
         self.batch_size = batch_size
-        self.patch_shape = patch_shape
+        if patch_shape is None:
+            self.patch_shape = self.estimator.input_shape
+        else:
+            self.patch_shape = patch_shape
         self.image_shape = classifier.input_shape
         self._check_params()
 
@@ -117,9 +118,6 @@ def __init__(
             self.i_h = 1
             self.i_w = 2
 
-        if self.patch_shape is None:
-            self.patch_shape = self.estimator.input_shape
-
         if self.patch_shape[0] != self.patch_shape[1]:
             raise ValueError("Patch height and width need to be the same.")
 
@@ -144,7 +142,7 @@ def __init__(
             learning_rate=self.learning_rate, momentum=0.0, nesterov=False, name="SGD"
         )
 
-    def _train_step(self, images: Optional[np.ndarray] = None, target: Optional[np.ndarray] = None) -> "tf.Tensor":
+    def _train_step(self, images: "tf.Tensor", target: Optional["tf.Tensor"] = None) -> "tf.Tensor":
         import tensorflow as tf  # lgtm [py/repeated-import]
 
         if target is None:
@@ -211,7 +209,12 @@ def _get_circular_patch_mask(self, nb_samples: int, sharpness: int = 40) -> "tf.
         image_mask = tf.stack([image_mask] * nb_samples)
         return image_mask
 
-    def _random_overlay(self, images: np.ndarray, patch: np.ndarray, scale: Optional[float] = None) -> "tf.Tensor":
+    def _random_overlay(
+        self,
+        images: Union[np.ndarray, "tf.Tensor"],
+        patch: Union[np.ndarray, "tf.Variable"],
+        scale: Optional[float] = None,
+    ) -> "tf.Tensor":
         import tensorflow as tf  # lgtm [py/repeated-import]
         import tensorflow_addons as tfa
 
@@ -271,7 +274,7 @@ def _random_overlay(self, images: np.ndarray, patch: np.ndarray, scale: Optional
 
         transform_vectors = list()
 
-        for i in range(nb_samples):
+        for _ in range(nb_samples):
             if scale is None:
                 im_scale = np.random.uniform(low=self.scale_min, high=self.scale_max)
             else:
@@ -292,8 +295,8 @@ def _random_overlay(self, images: np.ndarray, patch: np.ndarray, scale: Optional
 
             # Scale
             xform_matrix = rotation_matrix * (1.0 / im_scale)
-            a0, a1 = xform_matrix[0]
-            b0, b1 = xform_matrix[1]
+            a_0, a_1 = xform_matrix[0]
+            b_0, b_1 = xform_matrix[1]
 
             x_origin = float(self.image_shape[self.i_w]) / 2
             y_origin = float(self.image_shape[self.i_h]) / 2
@@ -303,10 +306,10 @@ def _random_overlay(self, images: np.ndarray, patch: np.ndarray, scale: Optional
             x_origin_delta = x_origin - x_origin_shifted
             y_origin_delta = y_origin - y_origin_shifted
 
-            a2 = x_origin_delta - (x_shift / (2 * im_scale))
-            b2 = y_origin_delta - (y_shift / (2 * im_scale))
+            a_2 = x_origin_delta - (x_shift / (2 * im_scale))
+            b_2 = y_origin_delta - (y_shift / (2 * im_scale))
 
-            transform_vectors.append(np.array([a0, a1, a2, b0, b1, b2, 0, 0]).astype(np.float32))
+            transform_vectors.append([a_0, a_1, a_2, b_0, b_1, b_2, 0, 0])
 
         image_mask = tfa.image.transform(image_mask, transform_vectors, "BILINEAR",)
         padded_patch = tfa.image.transform(padded_patch, transform_vectors, "BILINEAR",)
@@ -318,7 +321,7 @@ def _random_overlay(self, images: np.ndarray, patch: np.ndarray, scale: Optional
             padded_patch = tf.stack([padded_patch] * images.shape[1], axis=1)
             padded_patch = tf.cast(padded_patch, images.dtype)
 
-        inverted_mask = 1 - image_mask
+        inverted_mask = tf.constant(1, dtype=image_mask.dtype) - image_mask
 
         return images * inverted_mask + padded_patch * image_mask
 
@@ -336,21 +339,21 @@ def generate(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> T
 
         shuffle = kwargs.get("shuffle", True)
         if shuffle:
-            ds = (
+            dataset = (
                 tf.data.Dataset.from_tensor_slices((x, y))
                 .shuffle(10000)
                 .batch(self.batch_size)
                 .repeat(math.ceil(x.shape[0] / self.batch_size))
             )
         else:
-            ds = (
+            dataset = (
                 tf.data.Dataset.from_tensor_slices((x, y))
                 .batch(self.batch_size)
                 .repeat(math.ceil(x.shape[0] / self.batch_size))
             )
 
         for _ in trange(self.max_iter, desc="Adversarial Patch TensorFlow v2"):
-            for images, target in ds:
+            for images, target in dataset:
                 _ = self._train_step(images=images, target=target)
 
         return (