Merge pull request #752 from davidslater/simplified-preprocessing

Simplified Preprocessor and Postprocessor Usage and Defaults

Author: beat-buesser

art/defences/postprocessor/class_labels.py

@@ -39,18 +39,7 @@ def __init__(self, apply_fit: bool = False, apply_predict: bool = True) -> None:
         :param apply_fit: True if applied during fitting/training.
         :param apply_predict: True if applied during predicting.
         """
-        super().__init__()
-        self._is_fitted = True
-        self._apply_fit = apply_fit
-        self._apply_predict = apply_predict
-
-    @property
-    def apply_fit(self) -> bool:
-        return self._apply_fit
-
-    @property
-    def apply_predict(self) -> bool:
-        return self._apply_predict
+        super().__init__(is_fitted=True, apply_fit=apply_fit, apply_predict=apply_predict)
 
     def __call__(self, preds: np.ndarray) -> np.ndarray:
         """
@@ -67,9 +56,3 @@ def __call__(self, preds: np.ndarray) -> np.ndarray:
             class_labels[preds > 0.5] = 1
 
         return class_labels
-
-    def fit(self, preds: np.ndarray, **kwargs) -> None:
-        """
-        No parameters to learn for this method; do nothing.
-        """
-        pass

art/defences/postprocessor/gaussian_noise.py

@@ -43,21 +43,10 @@ def __init__(self, scale: float = 0.2, apply_fit: bool = False, apply_predict: b
         :param apply_fit: True if applied during fitting/training.
         :param apply_predict: True if applied during predicting.
         """
-        super().__init__()
-        self._is_fitted = True
-        self._apply_fit = apply_fit
-        self._apply_predict = apply_predict
+        super().__init__(is_fitted=True, apply_fit=apply_fit, apply_predict=apply_predict)
         self.scale = scale
         self._check_params()
 
-    @property
-    def apply_fit(self) -> bool:
-        return self._apply_fit
-
-    @property
-    def apply_predict(self) -> bool:
-        return self._apply_predict
-
     def __call__(self, preds: np.ndarray) -> np.ndarray:
         """
         Perform model postprocessing and return postprocessed output.
@@ -87,12 +76,6 @@ def __call__(self, preds: np.ndarray) -> np.ndarray:
 
         return post_preds
 
-    def fit(self, preds: np.ndarray, **kwargs) -> None:
-        """
-        No parameters to learn for this method; do nothing.
-        """
-        pass
-
     def _check_params(self) -> None:
         if self.scale <= 0:
             raise ValueError("Standard deviation must be positive.")

art/defences/postprocessor/high_confidence.py

@@ -42,21 +42,10 @@ def __init__(self, cutoff: float = 0.25, apply_fit: bool = False, apply_predict:
         :param apply_fit: True if applied during fitting/training.
         :param apply_predict: True if applied during predicting.
         """
-        super().__init__()
-        self._is_fitted = True
-        self._apply_fit = apply_fit
-        self._apply_predict = apply_predict
+        super().__init__(is_fitted=True, apply_fit=apply_fit, apply_predict=apply_predict)
         self.cutoff = cutoff
         self._check_params()
 
-    @property
-    def apply_fit(self) -> bool:
-        return self._apply_fit
-
-    @property
-    def apply_predict(self) -> bool:
-        return self._apply_predict
-
     def __call__(self, preds: np.ndarray) -> np.ndarray:
         """
         Perform model postprocessing and return postprocessed output.
@@ -69,12 +58,6 @@ def __call__(self, preds: np.ndarray) -> np.ndarray:
 
         return post_preds
 
-    def fit(self, preds: np.ndarray, **kwargs) -> None:
-        """
-        No parameters to learn for this method; do nothing.
-        """
-        pass
-
     def _check_params(self) -> None:
         if self.cutoff <= 0:
             raise ValueError("Minimal value must be positive.")

art/defences/postprocessor/postprocessor.py

@@ -34,11 +34,15 @@ class Postprocessor(abc.ABC):
 
     params: List[str] = []
 
-    def __init__(self) -> None:
+    def __init__(self, is_fitted: bool = False, apply_fit: bool = True, apply_predict: bool = True) -> None:
         """
         Create a postprocessing object.
+
+        Optionally, set attributes.
         """
-        self._is_fitted = False
+        self._is_fitted = bool(is_fitted)
+        self._apply_fit = bool(apply_fit)
+        self._apply_predict = bool(apply_predict)
 
     @property
     def is_fitted(self) -> bool:
@@ -50,24 +54,22 @@ def is_fitted(self) -> bool:
         return self._is_fitted
 
     @property
-    @abc.abstractmethod
     def apply_fit(self) -> bool:
         """
         Property of the defence indicating if it should be applied at training time.
 
         :return: `True` if the defence should be applied when fitting a model, `False` otherwise.
         """
-        raise NotImplementedError
+        return self._apply_fit
 
     @property
-    @abc.abstractmethod
     def apply_predict(self) -> bool:
         """
         Property of the defence indicating if it should be applied at test time.
 
         :return: `True` if the defence should be applied at prediction time, `False` otherwise.
         """
-        raise NotImplementedError
+        return self._apply_predict
 
     @abc.abstractmethod
     def __call__(self, preds: np.ndarray) -> np.ndarray:
@@ -79,15 +81,14 @@ def __call__(self, preds: np.ndarray) -> np.ndarray:
         """
         raise NotImplementedError
 
-    @abc.abstractmethod
     def fit(self, preds: np.ndarray, **kwargs) -> None:
         """
         Fit the parameters of the postprocessor if it has any.
 
         :param preds: Training set to fit the postprocessor.
         :param kwargs: Other parameters.
         """
-        raise NotImplementedError
+        pass
 
     def set_params(self, **kwargs) -> None:
         """

art/defences/postprocessor/reverse_sigmoid.py

@@ -47,22 +47,11 @@ def __init__(
         :param apply_fit: True if applied during fitting/training.
         :param apply_predict: True if applied during predicting.
         """
-        super().__init__()
-        self._is_fitted = True
-        self._apply_fit = apply_fit
-        self._apply_predict = apply_predict
+        super().__init__(is_fitted=True, apply_fit=apply_fit, apply_predict=apply_predict)
         self.beta = beta
         self.gamma = gamma
         self._check_params()
 
-    @property
-    def apply_fit(self) -> bool:
-        return self._apply_fit
-
-    @property
-    def apply_predict(self) -> bool:
-        return self._apply_predict
-
     def __call__(self, preds: np.ndarray) -> np.ndarray:
         """
         Perform model postprocessing and return postprocessed output.
@@ -109,12 +98,6 @@ def sigmoid(var_z):
 
         return reverse_sigmoid
 
-    def fit(self, preds: np.ndarray, **kwargs) -> None:
-        """
-        No parameters to learn for this method; do nothing.
-        """
-        pass
-
     def _check_params(self) -> None:
         if self.beta <= 0:
             raise ValueError("Magnitude parameter must be positive.")

art/defences/postprocessor/rounded.py

@@ -42,21 +42,10 @@ def __init__(self, decimals: int = 3, apply_fit: bool = False, apply_predict: bo
         :param apply_fit: True if applied during fitting/training.
         :param apply_predict: True if applied during predicting.
         """
-        super().__init__()
-        self._is_fitted = True
-        self._apply_fit = apply_fit
-        self._apply_predict = apply_predict
+        super().__init__(is_fitted=True, apply_fit=apply_fit, apply_predict=apply_predict)
         self.decimals = decimals
         self._check_params()
 
-    @property
-    def apply_fit(self) -> bool:
-        return self._apply_fit
-
-    @property
-    def apply_predict(self) -> bool:
-        return self._apply_predict
-
     def __call__(self, preds: np.ndarray) -> np.ndarray:
         """
         Perform model postprocessing and return postprocessed output.
@@ -66,12 +55,6 @@ def __call__(self, preds: np.ndarray) -> np.ndarray:
         """
         return np.around(preds, decimals=self.decimals)
 
-    def fit(self, preds: np.ndarray, **kwargs) -> None:
-        """
-        No parameters to learn for this method; do nothing.
-        """
-        pass
-
     def _check_params(self) -> None:
         if not isinstance(self.decimals, (int, np.int)) or self.decimals <= 0:
             raise ValueError("Number of decimal places must be a positive integer.")

art/defences/preprocessor/feature_squeezing.py

@@ -62,22 +62,11 @@ def __init__(
         :param apply_fit: True if applied during fitting/training.
         :param apply_predict: True if applied during predicting.
         """
-        super().__init__()
-        self._is_fitted = True
-        self._apply_fit = apply_fit
-        self._apply_predict = apply_predict
+        super().__init__(is_fitted=True, apply_fit=apply_fit, apply_predict=apply_predict)
         self.clip_values = clip_values
         self.bit_depth = bit_depth
         self._check_params()
 
-    @property
-    def apply_fit(self) -> bool:
-        return self._apply_fit
-
-    @property
-    def apply_predict(self) -> bool:
-        return self._apply_predict
-
     def __call__(self, x: np.ndarray, y: Optional[np.ndarray] = None) -> Tuple[np.ndarray, Optional[np.ndarray]]:
         """
         Apply feature squeezing to sample `x`.
@@ -97,15 +86,6 @@ def __call__(self, x: np.ndarray, y: Optional[np.ndarray] = None) -> Tuple[np.nd
 
         return res, y
 
-    def estimate_gradient(self, x: np.ndarray, grad: np.ndarray) -> np.ndarray:
-        return grad
-
-    def fit(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> None:
-        """
-        No parameters to learn for this method; do nothing.
-        """
-        pass
-
     def _check_params(self) -> None:
         if not isinstance(self.bit_depth, (int, np.int)) or self.bit_depth <= 0 or self.bit_depth > 64:
             raise ValueError("The bit depth must be between 1 and 64.")

art/defences/preprocessor/gaussian_augmentation.py

@@ -73,31 +73,20 @@ def __init__(
         :param apply_fit: True if applied during fitting/training.
         :param apply_predict: True if applied during predicting.
         """
-        super().__init__()
-        self._is_fitted = True
+        super().__init__(is_fitted=True, apply_fit=apply_fit, apply_predict=apply_predict)
         if augmentation and not apply_fit and apply_predict:
             raise ValueError(
                 "If `augmentation` is `True`, then `apply_fit` must be `True` and `apply_predict` must be `False`."
             )
         if augmentation and not (apply_fit or apply_predict):
             raise ValueError("If `augmentation` is `True`, then `apply_fit` and `apply_predict` can't be both `False`.")
 
-        self._apply_fit = apply_fit
-        self._apply_predict = apply_predict
         self.sigma = sigma
         self.augmentation = augmentation
         self.ratio = ratio
         self.clip_values = clip_values
         self._check_params()
 
-    @property
-    def apply_fit(self) -> bool:
-        return self._apply_fit
-
-    @property
-    def apply_predict(self) -> bool:
-        return self._apply_predict
-
     def __call__(self, x: np.ndarray, y: Optional[np.ndarray] = None) -> Tuple[np.ndarray, Optional[np.ndarray]]:
         """
         Augment the sample `(x, y)` with Gaussian noise. The result is either an extended dataset containing the
@@ -134,15 +123,6 @@ def __call__(self, x: np.ndarray, y: Optional[np.ndarray] = None) -> Tuple[np.nd
 
         return x_aug, y_aug
 
-    def estimate_gradient(self, x: np.ndarray, grad: np.ndarray) -> np.ndarray:
-        return grad
-
-    def fit(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> None:
-        """
-        No parameters to learn for this method; do nothing.
-        """
-        pass
-
     def _check_params(self) -> None:
         if self.augmentation and self.ratio <= 0:
             raise ValueError("The augmentation ratio must be positive.")

art/defences/preprocessor/inverse_gan.py

@@ -68,11 +68,7 @@ def __init__(
         """
         import tensorflow as tf  # lgtm [py/repeated-import]
 
-        super().__init__()
-
-        self._is_fitted = True
-        self._apply_fit = apply_fit
-        self._apply_predict = apply_predict
+        super().__init__(is_fitted=True, apply_fit=apply_fit, apply_predict=apply_predict)
         self.gan = gan
         self.inverse_gan = inverse_gan
         self.sess = sess
@@ -164,14 +160,6 @@ def loss(self, z_encoding: np.ndarray, image_adv: np.ndarray) -> np.ndarray:
         loss = self.sess.run(self._loss, feed_dict={self.gan.input_ph: z_encoding, self._image_adv: image_adv})
         return loss
 
-    @property
-    def apply_fit(self) -> bool:
-        return self._apply_fit
-
-    @property
-    def apply_predict(self) -> bool:
-        return self._apply_predict
-
     def estimate_gradient(self, z_encoding: np.ndarray, y: np.ndarray) -> np.ndarray:
         """
         Compute the gradient of the loss function w.r.t. a `z_encoding` input within a GAN against a
@@ -186,12 +174,6 @@ def estimate_gradient(self, z_encoding: np.ndarray, y: np.ndarray) -> np.ndarray
         gradient = self.sess.run(self._grad, feed_dict={self._image_adv: y, self.gan.input_ph: z_encoding})
         return gradient
 
-    def fit(self, x, y=None, **kwargs):
-        """
-        No parameters to learn for this method; do nothing.
-        """
-        pass
-
     def _check_params(self) -> None:
         if self.inverse_gan is not None and self.gan.encoding_length != self.inverse_gan.encoding_length:
             raise ValueError("Both GAN and InverseGAN must use the same size encoding.")