batching Newtonfool

Author: minhitbk

art/attacks/newtonfool.py

@@ -5,6 +5,7 @@
 import numpy as np
 
 from art.attacks.attack import Attack
+from art.utils import to_categorical
 
 logger = logging.getLogger(__name__)
 
@@ -13,9 +14,9 @@ class NewtonFool(Attack):
     """
     Implementation of the attack from Uyeong Jang et al. (2017). Paper link: http://doi.acm.org/10.1145/3134600.3134635
     """
-    attack_params = Attack.attack_params + ["max_iter", "eta"]
+    attack_params = Attack.attack_params + ["max_iter", "eta", "batch_size"]
 
-    def __init__(self, classifier, max_iter=100, eta=0.01):
+    def __init__(self, classifier, max_iter=1000, eta=0.01, batch_size=128):
         """
         Create a NewtonFool attack instance.
 
@@ -25,9 +26,11 @@ def __init__(self, classifier, max_iter=100, eta=0.01):
         :type max_iter: `int`
         :param eta: The eta coefficient.
         :type eta: `float`
+        :param batch_size: Batch size
+        :type batch_size: `int`
         """
         super(NewtonFool, self).__init__(classifier)
-        params = {"max_iter": max_iter, "eta": eta}
+        params = {"max_iter": max_iter, "eta": eta, "batch_size": batch_size}
         self.set_params(**params)
 
     def generate(self, x, **kwargs):
@@ -42,39 +45,43 @@ def generate(self, x, **kwargs):
         :rtype: `np.ndarray`
         """
         self.set_params(**kwargs)
-        nb_classes = self.classifier.nb_classes
         x_adv = x.copy()
 
         # Initialize variables
         clip_min, clip_max = self.classifier.clip_values
         y_pred = self.classifier.predict(x, logits=False)
         pred_class = np.argmax(y_pred, axis=1)
 
-        # Main algorithm for each example
-        for j, ex in enumerate(x_adv):
-            norm_x0 = np.linalg.norm(np.reshape(ex, [-1]))
-            l = pred_class[j]
+        # Compute perturbation with implicit batching
+        for batch_id in range(int(np.ceil(x_adv.shape[0] / float(self.batch_size)))):
+            batch_index_1, batch_index_2 = batch_id * self.batch_size, (batch_id + 1) * self.batch_size
+            batch = x_adv[batch_index_1:batch_index_2]
+
+            # Main algorithm for each batch
+            norm_batch = np.linalg.norm(np.reshape(batch, (batch.shape[0], -1)), axis=1)
+            l = pred_class[batch_index_1:batch_index_2]
+            l_b = to_categorical(l, self.classifier.nb_classes).astype(bool)
 
             # Main loop of the algorithm
             for i in range(self.max_iter):
                 # Compute score
-                score = self.classifier.predict(np.array([ex]), logits=False)[0][l]
+                score = self.classifier.predict(batch, logits=False)[l_b]
 
                 # Compute the gradients and norm
-                grads = self.classifier.class_gradient(np.array([ex]), logits=False)[0][l]
-                norm_grad = np.linalg.norm(np.reshape(grads, [-1]))
+                grads = self.classifier.class_gradient(batch, label=l, logits=False)
+                norm_grad = np.linalg.norm(np.reshape(grads, (batch.shape[0], -1)), axis=1)
 
                 # Theta
-                theta = self._compute_theta(norm_x0, score, norm_grad, nb_classes)
+                theta = self._compute_theta(norm_batch, score, norm_grad)
 
                 # Pertubation
-                di = self._compute_pert(theta, grads, norm_grad)
+                di_batch = self._compute_pert(theta, grads, norm_grad)
 
                 # Update xi and pertubation
-                ex += di
+                batch += di_batch
 
             # Apply clip
-            x_adv[j] = np.clip(ex, clip_min, clip_max)
+            x_adv[batch_index_1:batch_index_2] = np.clip(batch, clip_min, clip_max)
 
         preds = np.argmax(self.classifier.predict(x), axis=1)
         preds_adv = np.argmax(self.classifier.predict(x_adv), axis=1)
@@ -99,21 +106,27 @@ def set_params(self, **kwargs):
         if type(self.eta) is not float or self.eta <= 0:
             raise ValueError("The eta coefficient must be a positive float.")
 
+        if self.batch_size <= 0:
+            raise ValueError('The batch size `batch_size` has to be positive.')
+
         return True
 
-    def _compute_theta(self, norm_x0, score, norm_grad, nb_classes):
+    def _compute_theta(self, norm_batch, score, norm_grad):
         """
         Function to compute the theta at each step.
 
-        :param norm_x0: norm of x0
+        :param norm_batch: norm of a batch.
+        :type norm_batch: `np.ndarray`
         :param score: softmax value at the attacked class.
+        :type score: `np.ndarray`
         :param norm_grad: norm of gradient values at the attacked class.
-        :param nb_classes: number of classes.
+        :type norm_grad: `np.ndarray`
         :return: theta value.
+        :rtype: `np.ndarray`
         """
-        equ1 = self.eta * norm_x0 * norm_grad
-        equ2 = score - 1.0/nb_classes
-        result = min(equ1, equ2)
+        equ1 = self.eta * norm_batch * norm_grad
+        equ2 = score - 1.0 / self.classifier.nb_classes
+        result = np.minimum.reduce([equ1, equ2])
 
         return result
 
@@ -123,14 +136,23 @@ def _compute_pert(theta, grads, norm_grad):
         Function to compute the pertubation at each step.
 
         :param theta: theta value at the current step.
+        :type theta: `np.ndarray`
         :param grads: gradient values at the attacked class.
+        :type grads: `np.ndarray`
         :param norm_grad: norm of gradient values at the attacked class.
+        :type norm_grad: `np.ndarray`
         :return: pertubation.
+        :rtype: `np.ndarray`
         """
         # Pick a small scalar to avoid division by 0
         tol = 10e-8
-        nom = -theta * grads
-        denom = norm_grad**2 if norm_grad > tol else tol
-        result = nom / float(denom)
+        nom = -theta[:, None, None, None] * grads
+        denom = norm_grad**2
+        denom[denom < tol] = tol
+        result = nom / denom[:, None, None, None]
 
         return result
+
+
+
+