Updates for BaseEstimator.set_params

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

Author: Beat Buesser

art/estimators/estimator.py

@@ -72,55 +72,64 @@ def __init__(
                used for data preprocessing. The first value will be subtracted from the input and the results will be
                divided by the second value.
         """
-        from art.defences.postprocessor.postprocessor import Postprocessor
         from art.defences.preprocessor.preprocessor import Preprocessor
 
         self._model = model
         self._clip_values = clip_values
 
-        self.preprocessing: List["Preprocessor"] = []
+        self.preprocessing = preprocessing
+        self.preprocessing_defences = self._set_preprocessing_defences(preprocessing_defences)
+        self.postprocessing_defences = self._set_postprocessing_defences(postprocessing_defences)
+        self.preprocessing_operations: List["Preprocessor"] = []
+        self._update_preprocessing_operations()
+        self._check_params()
+
+    def _update_preprocessing_operations(self):
+        from art.defences.preprocessor.preprocessor import Preprocessor
+
+        self.preprocessing_operations.clear()
+
+        if self.preprocessing_defences is None:
+            pass
+        elif isinstance(self.preprocessing_defences, Preprocessor):
+            self.preprocessing_operations.append(self.preprocessing_defences)
+        else:
+            self.preprocessing_operations += self.preprocessing_defences
 
-        # preprocessing
-        self._preprocessing_argument = None
-        if preprocessing is None:
+        if self.preprocessing is None:
             pass
-        elif isinstance(preprocessing, tuple):
+        elif isinstance(self.preprocessing, tuple):
             from art.preprocessing.standardisation_mean_std.standardisation_mean_std import StandardisationMeanStd
 
-            self._preprocessing_argument = StandardisationMeanStd(mean=preprocessing[0], std=preprocessing[1])
-        elif isinstance(preprocessing, Preprocessor):
-            self._preprocessing_argument = preprocessing
+            self.preprocessing_operations.append(
+                StandardisationMeanStd(mean=self.preprocessing[0], std=self.preprocessing[1])
+            )
+        elif isinstance(self.preprocessing, Preprocessor):
+            self.preprocessing_operations.append(self.preprocessing)
         else:
             raise ValueError("Preprocessing argument not recognised.")
 
-        # preprocessing_defences
-        self._set_preprocessing_defences(preprocessing_defences)
-
-        # postprocessing_defences
-        self.postprocessing_defences: Optional[List["Postprocessor"]]
-        self._set_postprocessing_defences(postprocessing_defences)
-
-        self._check_params()
-
-    def _set_preprocessing_defences(self, preprocessing_defences):
+    @staticmethod
+    def _set_preprocessing_defences(
+        preprocessing_defences: Optional[Union["Preprocessor", List["Preprocessor"]]]
+    ) -> Optional[List["Preprocessor"]]:
         from art.defences.preprocessor.preprocessor import Preprocessor
 
-        if preprocessing_defences is None:
-            self.preprocessing = [self._preprocessing_argument]
-        elif isinstance(preprocessing_defences, Preprocessor):
-            self.preprocessing = [preprocessing_defences] + [self._preprocessing_argument]
+        if isinstance(preprocessing_defences, Preprocessor):
+            return [preprocessing_defences]
         else:
-            self.preprocessing = preprocessing_defences + [self._preprocessing_argument]
-
-        self.preprocessing_defences = preprocessing_defences
+            return preprocessing_defences
 
-    def _set_postprocessing_defences(self, postprocessing_defences):
+    @staticmethod
+    def _set_postprocessing_defences(
+        postprocessing_defences: Optional[Union["Postprocessor", List["Postprocessor"]]]
+    ) -> Optional[List["Postprocessor"]]:
         from art.defences.postprocessor.postprocessor import Postprocessor
 
         if isinstance(postprocessing_defences, Postprocessor):
-            self.postprocessing_defences = [postprocessing_defences]
+            return [postprocessing_defences]
         else:
-            self.postprocessing_defences = postprocessing_defences
+            return postprocessing_defences
 
     def set_params(self, **kwargs) -> None:
         """
@@ -141,6 +150,7 @@ def set_params(self, **kwargs) -> None:
                         setattr(self, key, value)
             else:
                 raise ValueError("Unexpected parameter `{}` found in kwargs.".format(key))
+        self._update_preprocessing_operations()
         self._check_params()
 
     def get_params(self) -> Dict[str, Any]:
@@ -171,8 +181,8 @@ def _check_params(self) -> None:
             else:
                 self._clip_values = np.array(self._clip_values, dtype=ART_NUMPY_DTYPE)
 
-        if isinstance(self.preprocessing, list):
-            for preprocess in self.preprocessing:
+        if isinstance(self.preprocessing_operations, list):
+            for preprocess in self.preprocessing_operations:
                 if not isinstance(preprocess, Preprocessor):
                     raise ValueError(
                         "All preprocessing defences have to be instance of "
@@ -265,7 +275,7 @@ def _apply_preprocessing(self, x, y, fit: bool) -> Tuple[Any, Any]:
         :rtype: Format as expected by the `model`
         """
         if self.preprocessing:
-            for preprocess in self.preprocessing:
+            for preprocess in self.preprocessing_operations:
                 if fit:
                     if preprocess.apply_fit:
                         x, y = preprocess(x, y)
@@ -341,8 +351,8 @@ def _apply_preprocessing_gradient(self, x, gradients, fit=False):
         :return: Gradients after backward pass through normalization and preprocessing defences.
         :rtype: Format as expected by the `model`
         """
-        if self.preprocessing:
-            for preprocess in self.preprocessing[::-1]:
+        if self.preprocessing_operations:
+            for preprocess in self.preprocessing_operations[::-1]:
                 if fit:
                     if preprocess.apply_fit:
                         gradients = preprocess.estimate_gradient(x, gradients)

art/estimators/pytorch.py

@@ -123,7 +123,9 @@ def _check_params(self) -> None:
         from art.defences.preprocessor.preprocessor import PreprocessorPyTorch
 
         super()._check_params()
-        self.all_framework_preprocessing = all([isinstance(p, PreprocessorPyTorch) for p in self.preprocessing])
+        self.all_framework_preprocessing = all(
+            [isinstance(p, PreprocessorPyTorch) for p in self.preprocessing_operations]
+        )
 
     def _apply_preprocessing(self, x, y, fit: bool = False, no_grad=True) -> Tuple[Any, Any]:
         """
@@ -153,7 +155,7 @@ def _apply_preprocessing(self, x, y, fit: bool = False, no_grad=True) -> Tuple[A
             StandardisationMeanStdPyTorch,
         )
 
-        if not self.preprocessing:
+        if not self.preprocessing_operations:
             return x, y
 
         if isinstance(x, torch.Tensor):
@@ -169,7 +171,7 @@ def _apply_preprocessing(self, x, y, fit: bool = False, no_grad=True) -> Tuple[A
                     y = torch.tensor(y, device=self._device)
 
             def chain_processes(x, y):
-                for preprocess in self.preprocessing:
+                for preprocess in self.preprocessing_operations:
                     if fit:
                         if preprocess.apply_fit:
                             x, y = preprocess.forward(x, y)
@@ -190,12 +192,12 @@ def chain_processes(x, y):
                 if y is not None:
                     y = y.cpu().numpy()
 
-        elif len(self.preprocessing) == 1 or (
-            len(self.preprocessing) == 2
-            and isinstance(self.preprocessing[-1], (StandardisationMeanStd, StandardisationMeanStdPyTorch))
+        elif len(self.preprocessing_operations) == 1 or (
+            len(self.preprocessing_operations) == 2
+            and isinstance(self.preprocessing_operations[-1], (StandardisationMeanStd, StandardisationMeanStdPyTorch))
         ):
             # Compatible with non-PyTorch defences if no chaining.
-            for preprocess in self.preprocessing:
+            for preprocess in self.preprocessing_operations:
                 x, y = preprocess(x, y)
 
         else:
@@ -229,7 +231,7 @@ def _apply_preprocessing_gradient(self, x, gradients, fit=False):
             StandardisationMeanStdPyTorch,
         )
 
-        if not self.preprocessing:
+        if not self.preprocessing_operations:
             return gradients
 
         if isinstance(x, torch.Tensor):
@@ -243,7 +245,7 @@ def _apply_preprocessing_gradient(self, x, gradients, fit=False):
             gradients = torch.tensor(gradients, device=self._device)
             x_orig = x
 
-            for preprocess in self.preprocessing:
+            for preprocess in self.preprocessing_operations:
                 if fit:
                     if preprocess.apply_fit:
                         x = preprocess.estimate_forward(x)
@@ -260,13 +262,18 @@ def _apply_preprocessing_gradient(self, x, gradients, fit=False):
                     "The input shape is {} while the gradient shape is {}".format(x.shape, gradients.shape)
                 )
 
-        elif len(self.preprocessing) == 1 or (
-            len(self.preprocessing) == 2
+        elif len(self.preprocessing_operations) == 1 or (
+            len(self.preprocessing_operations) == 2
             and isinstance(self.preprocessing[-1], (StandardisationMeanStd, StandardisationMeanStdPyTorch))
         ):
             # Compatible with non-PyTorch defences if no chaining.
-            defence = self.preprocessing[0]
-            gradients = defence.estimate_gradient(x, gradients)
+            for preprocess in self.preprocessing_operations[::-1]:
+                if fit:
+                    if preprocess.apply_fit:
+                        gradients = preprocess.estimate_gradient(x, gradients)
+                else:
+                    if preprocess.apply_predict:
+                        gradients = preprocess.estimate_gradient(x, gradients)
 
         else:
             raise NotImplementedError("The current combination of preprocessing types is not supported.")

art/estimators/tensorflow.py

@@ -169,7 +169,9 @@ def _check_params(self) -> None:
         from art.defences.preprocessor.preprocessor import PreprocessorTensorFlowV2
 
         super()._check_params()
-        self.all_framework_preprocessing = all([isinstance(p, PreprocessorTensorFlowV2) for p in self.preprocessing])
+        self.all_framework_preprocessing = all(
+            [isinstance(p, PreprocessorTensorFlowV2) for p in self.preprocessing_operations]
+        )
 
     def _apply_preprocessing(self, x, y, fit: bool = False) -> Tuple[Any, Any]:
         """
@@ -197,7 +199,7 @@ def _apply_preprocessing(self, x, y, fit: bool = False) -> Tuple[Any, Any]:
             StandardisationMeanStdTensorFlowV2,
         )
 
-        if not self.preprocessing:
+        if not self.preprocessing_operations:
             return x, y
 
         if isinstance(x, tf.Tensor):
@@ -212,7 +214,7 @@ def _apply_preprocessing(self, x, y, fit: bool = False) -> Tuple[Any, Any]:
                 if y is not None:
                     y = tf.convert_to_tensor(y)
 
-            for preprocess in self.preprocessing:
+            for preprocess in self.preprocessing_operations:
                 if fit:
                     if preprocess.apply_fit:
                         x, y = preprocess.forward(x, y)
@@ -226,12 +228,14 @@ def _apply_preprocessing(self, x, y, fit: bool = False) -> Tuple[Any, Any]:
                 if y is not None:
                     y = y.numpy()
 
-        elif len(self.preprocessing) == 1 or (
-            len(self.preprocessing) == 2
-            and isinstance(self.preprocessing[-1], (StandardisationMeanStd, StandardisationMeanStdTensorFlowV2))
+        elif len(self.preprocessing_operations) == 1 or (
+            len(self.preprocessing_operations) == 2
+            and isinstance(
+                self.preprocessing_operations[-1], (StandardisationMeanStd, StandardisationMeanStdTensorFlowV2)
+            )
         ):
             # Compatible with non-TensorFlow defences if no chaining.
-            for preprocess in self.preprocessing:
+            for preprocess in self.preprocessing_operations:
                 x, y = preprocess(x, y)
 
         else:
@@ -265,7 +269,7 @@ def _apply_preprocessing_gradient(self, x, gradients, fit=False):
             StandardisationMeanStdTensorFlowV2,
         )
 
-        if not self.preprocessing:
+        if not self.preprocessing_operations:
             return gradients
 
         if isinstance(x, tf.Tensor):
@@ -281,7 +285,7 @@ def _apply_preprocessing_gradient(self, x, gradients, fit=False):
                 gradients = tf.convert_to_tensor(gradients, dtype=config.ART_NUMPY_DTYPE)
                 x_orig = x
 
-                for preprocess in self.preprocessing:
+                for preprocess in self.preprocessing_operations:
                     if fit:
                         if preprocess.apply_fit:
                             x = preprocess.estimate_forward(x)
@@ -298,13 +302,18 @@ def _apply_preprocessing_gradient(self, x, gradients, fit=False):
                     "The input shape is {} while the gradient shape is {}".format(x.shape, gradients.shape)
                 )
 
-        elif len(self.preprocessing) == 1 or (
-            len(self.preprocessing) == 2
+        elif len(self.preprocessing_operations) == 1 or (
+            len(self.preprocessing_operations) == 2
             and isinstance(self.preprocessing[-1], (StandardisationMeanStd, StandardisationMeanStdTensorFlowV2))
         ):
             # Compatible with non-TensorFlow defences if no chaining.
-            defence = self.preprocessing[0]
-            gradients = defence.estimate_gradient(x, gradients)
+            for preprocess in self.preprocessing_operations[::-1]:
+                if fit:
+                    if preprocess.apply_fit:
+                        gradients = preprocess.estimate_gradient(x, gradients)
+                else:
+                    if preprocess.apply_predict:
+                        gradients = preprocess.estimate_gradient(x, gradients)
 
         else:
             raise NotImplementedError("The current combination of preprocessing types is not supported.")

tests/estimators/classification/test_deeplearning_common.json

@@ -392,7 +392,7 @@
         "train_step=<function get_image_classifier_tf_v2.<locals>.train_step",
         "channels_first=False, ",
         "clip_values=array([0., 1.], dtype=float32), ",
-        "preprocessing_defences=None, postprocessing_defences=None, preprocessing=[StandardisationMeanStdTensorFlowV2(mean=0, std=1, apply_fit=True, apply_predict=True)]"
+        "preprocessing_defences=None, postprocessing_defences=None, preprocessing=StandardisationMeanStdTensorFlowV2(mean=0, std=1, apply_fit=True, apply_predict=True)"
     ],
     "test_repr_tensorflow1": [
         "TensorFlowClassifier",
@@ -406,7 +406,7 @@
         "channels_first=False",
         "clip_values=array([0., 1.], dtype=float32)",
         "preprocessing_defences=None, postprocessing_defences=None",
-        "preprocessing=[StandardisationMeanStd(mean=0, std=1, apply_fit=True, apply_predict=True)]"
+        "preprocessing=StandardisationMeanStd(mean=0, std=1, apply_fit=True, apply_predict=True)"
     ],
     "test_repr_pytorch": [
         "art.estimators.classification.pytorch.PyTorchClassifier",
@@ -416,15 +416,15 @@
         "loss=CrossEntropyLoss(), optimizer=Adam",
         "input_shape=(1, 28, 28), nb_classes=10, channel_index",
         "clip_values=array([0., 1.], dtype=float32",
-        "preprocessing_defences=None, postprocessing_defences=None, preprocessing=[StandardisationMeanStdPyTorch(mean=0, std=1, apply_fit=True, apply_predict=True, device=cpu)]"
+        "preprocessing_defences=None, postprocessing_defences=None, preprocessing=StandardisationMeanStdPyTorch(mean=0, std=1, apply_fit=True, apply_predict=True, device=cpu)"
     ],
     "test_repr_keras": [
         "art.estimators.classification.keras.KerasClassifier",
         "use_logits=True",
         "channels_first=False",
         "clip_values=array([0., 1.], dtype=float32)",
         "preprocessing_defences=None",
-        "preprocessing=[StandardisationMeanStd(mean=0, std=1, apply_fit=True, apply_predict=True)]",
+        "preprocessing=[(mean=0, std=1, apply_fit=True, apply_predict=True)",
         "input_layer=0, output_layer=0"
     ],
     "test_repr_kerastf": [
@@ -433,14 +433,14 @@
         "channels_first=False",
         "clip_values=array([0., 1.], dtype=float32)",
         "preprocessing_defences=None",
-        "preprocessing=[StandardisationMeanStd(mean=0, std=1, apply_fit=True, apply_predict=True)]",
+        "preprocessing=StandardisationMeanStd(mean=0, std=1, apply_fit=True, apply_predict=True)",
         "input_layer=0, output_layer=0"
     ],
     "test_repr_mxnet": [
         "art.estimators.classification.mxnet.MXClassifier",
         "input_shape=(1, 28, 28), nb_classes=10",
         "channels_first=True, clip_values=array([0., 1.], dtype=float32)",
-        "defences=None, preprocessing=[StandardisationMeanStd(mean=0, std=1, apply_fit=True, apply_predict=True)]"
+        "defences=None, preprocessing=StandardisationMeanStd(mean=0, std=1, apply_fit=True, apply_predict=True)"
     ],
     "test_predict_mxnet": [
         [