Change defenses to defences for consistency

Author: Irina Nicolae

art/attacks/carlini.py

@@ -12,7 +12,7 @@
 class CarliniL2Method(Attack):
     """
     The L_2 optimized attack of Carlini and Wagner (2016). This attack is the most efficient and should be used as the
-    primary attack to evaluate potential defenses (wrt the L_0 and L_inf attacks). This implementation is inspired by
+    primary attack to evaluate potential defences (wrt the L_0 and L_inf attacks). This implementation is inspired by
     the one in Cleverhans, which reproduces the authors' original code (https://github.com/carlini/nn_robust_attacks).
     Paper link: https://arxiv.org/pdf/1608.04644.pdf
     """
@@ -160,7 +160,7 @@ def generate(self, x, **kwargs):
 
         # No labels provided, use model prediction as correct class
         if y is None:
-            y = np.argmax(self.classifier.predict(inputs=x, logits=False), axis=1)
+            y = np.argmax(self.classifier.predict(x, logits=False), axis=1)
             y = to_categorical(y, self.classifier.nb_classes)
 
         # Images to be attacked:

art/attacks/carlini_unittest.py

@@ -46,7 +46,7 @@ def test_tfclassifier(self):
         self._sess.run(tf.global_variables_initializer())
 
         # Get MNIST
-        batch_size, nb_train, nb_test = 100, 1000, 10
+        batch_size, nb_train, nb_test = 100, 500, 5
         (x_train, y_train), (x_test, y_test), _, _ = load_mnist()
         x_train, y_train = x_train[:nb_train], y_train[:nb_train]
         x_test, y_test = x_test[:nb_test], y_test[:nb_test]
@@ -57,7 +57,7 @@ def test_tfclassifier(self):
         tfc.fit(x_train, y_train, batch_size=batch_size, nb_epochs=2)
 
         # First attack
-        cl2m = CarliniL2Method(classifier=tfc, targeted=True, max_iter=100, binary_search_steps=10,
+        cl2m = CarliniL2Method(classifier=tfc, targeted=True, max_iter=10, binary_search_steps=10,
                                learning_rate=2e-2, initial_const=3, decay=1e-2)
         params = {'y': random_targets(y_test, tfc.nb_classes)}
         x_test_adv = cl2m.generate(x_test, **params)
@@ -67,7 +67,7 @@ def test_tfclassifier(self):
         self.assertTrue((target == y_pred_adv).all())
 
         # Second attack
-        cl2m = CarliniL2Method(classifier=tfc, targeted=False, max_iter=100, binary_search_steps=10,
+        cl2m = CarliniL2Method(classifier=tfc, targeted=False, max_iter=10, binary_search_steps=10,
                                learning_rate=2e-2, initial_const=3, decay=1e-2)
         params = {'y': random_targets(y_test, tfc.nb_classes)}
         x_test_adv = cl2m.generate(x_test, **params)
@@ -77,7 +77,7 @@ def test_tfclassifier(self):
         self.assertTrue((target != y_pred_adv).all())
 
         # Third attack
-        cl2m = CarliniL2Method(classifier=tfc, targeted=False, max_iter=100, binary_search_steps=10,
+        cl2m = CarliniL2Method(classifier=tfc, targeted=False, max_iter=10, binary_search_steps=10,
                                learning_rate=2e-2, initial_const=3, decay=1e-2)
         params = {}
         x_test_adv = cl2m.generate(x_test, **params)
@@ -96,7 +96,7 @@ def test_krclassifier(self):
         k.set_session(session)
 
         # Get MNIST
-        batch_size, nb_train, nb_test = 100, 1000, 10
+        batch_size, nb_train, nb_test = 100, 500, 5
         (x_train, y_train), (x_test, y_test), _, _ = load_mnist()
         x_train, y_train = x_train[:nb_train], y_train[:nb_train]
         x_test, y_test = x_test[:nb_test], y_test[:nb_test]
@@ -116,7 +116,7 @@ def test_krclassifier(self):
         krc.fit(x_train, y_train, batch_size=batch_size, nb_epochs=2)
 
         # First attack
-        cl2m = CarliniL2Method(classifier=krc, targeted=True, max_iter=100, binary_search_steps=10,
+        cl2m = CarliniL2Method(classifier=krc, targeted=True, max_iter=10, binary_search_steps=10,
                                learning_rate=2e-2, initial_const=3, decay=1e-2)
         params = {'y': random_targets(y_test, krc.nb_classes)}
         x_test_adv = cl2m.generate(x_test, **params)
@@ -126,7 +126,7 @@ def test_krclassifier(self):
         self.assertTrue((target == y_pred_adv).any())
 
         # Second attack
-        cl2m = CarliniL2Method(classifier=krc, targeted=False, max_iter=100, binary_search_steps=10,
+        cl2m = CarliniL2Method(classifier=krc, targeted=False, max_iter=10, binary_search_steps=10,
                                learning_rate=2e-2, initial_const=3, decay=1e-2)
         params = {'y': random_targets(y_test, krc.nb_classes)}
         x_test_adv = cl2m.generate(x_test, **params)
@@ -136,7 +136,7 @@ def test_krclassifier(self):
         self.assertTrue((target != y_pred_adv).all())
 
         # Third attack
-        cl2m = CarliniL2Method(classifier=krc, targeted=False, max_iter=100, binary_search_steps=10,
+        cl2m = CarliniL2Method(classifier=krc, targeted=False, max_iter=10, binary_search_steps=10,
                                learning_rate=2e-2, initial_const=3, decay=1e-2)
         params = {}
         x_test_adv = cl2m.generate(x_test, **params)

art/defences/__init__.py

@@ -1,5 +1,5 @@
 """
-Module implementing multiple types of defenses against adversarial attacks.
+Module implementing multiple types of defences against adversarial attacks.
 """
 from art.defences.adversarial_trainer import AdversarialTrainer
 from art.defences.feature_squeezing import FeatureSqueezing

art/defences/feature_squeezing.py

@@ -45,7 +45,7 @@ def fit(self, x, y=None, **kwargs):
         pass
 
     def set_params(self, **kwargs):
-        """Take in a dictionary of parameters and applies defense-specific checks before saving them as attributes.
+        """Take in a dictionary of parameters and applies defence-specific checks before saving them as attributes.
 
         Defense-specific parameters:
         :param bit_depth: The number of bits to encode data on

art/defences/gaussian_augmentation.py

@@ -72,7 +72,7 @@ def fit(self, x, y=None, **kwargs):
 
     def set_params(self, **kwargs):
         """
-        Take in a dictionary of parameters and applies defense-specific checks before saving them as attributes.
+        Take in a dictionary of parameters and applies defence-specific checks before saving them as attributes.
 
         :param sigma: Standard deviation of Gaussian noise to be added.
         :type sigma: `float`

art/defences/label_smoothing.py

@@ -50,7 +50,7 @@ def fit(self,  x, y=None, **kwargs):
         pass
 
     def set_params(self, **kwargs):
-        """Take in a dictionary of parameters and applies defense-specific checks before saving them as attributes.
+        """Take in a dictionary of parameters and applies defence-specific checks before saving them as attributes.
 
         Defense-specific parameters:
         :param max_value: Value to affect to correct label

art/defences/preprocessor.py

@@ -12,7 +12,7 @@
 
 class Preprocessor(ABC):
     """
-    Abstract base class for defenses performing model hardening by preprocessing data.
+    Abstract base class for defences performing model hardening by preprocessing data.
     """
     params = []
 

art/defences/spatial_smoothing.py

@@ -49,8 +49,7 @@ def fit(self, x, y=None, **kwargs):
 
     def set_params(self, **kwargs):
         """
-        Take in a dictionary of parameters and applies defense-specific checks
-        before saving them as attributes.
+        Take in a dictionary of parameters and applies defence-specific checks before saving them as attributes.
 
         :param window_size: The size of the sliding window.
         :type window_size: `int`