Add Gaussian augmentation in preprocessing

Author: Irina Nicolae

art/defences/gaussian_augmentation.py

@@ -0,0 +1,88 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from art.defences.preprocessor import Preprocessor
+
+
+class GaussianAugmentation(Preprocessor):
+    """
+    Perform Gaussian augmentation on a dataset.
+    """
+    params = ['sigma', 'ratio']
+
+    def __init__(self, sigma=1., ratio=1.):
+        """
+        Initialize a Gaussian augmentation object.
+
+        :param sigma: Standard deviation of Gaussian noise to be added.
+        :type sigma: `float`
+        :param ratio: Percentage of data augmentation. E.g. for a rate of 1, the size of the dataset will double.
+        :type ratio: `float`
+        """
+        super(GaussianAugmentation, self).__init__()
+        self._is_fitted = True
+        self.set_params(sigma=sigma, ratio=ratio)
+
+    def __call__(self, x, y=None, sigma=None, ratio=None):
+        """
+        Augment the sample `(x, y)` with Gaussian noise. The result is an extended dataset containing the original
+        sample, as well as the newly created noisy samples.
+
+        :param x: Sample to augment with shape `(batch_size, width, height, depth)`.
+        :type x: `np.ndarray`
+        :param y: Labels for the sample. If this argument is provided, it will be augmented with the corresponded
+                  original labels of each sample point.
+        :param sigma: Standard deviation of Gaussian noise to be added.
+        :type sigma: `float`
+        :param ratio: Percentage of data augmentation. E.g. for a ratio of 1, the size of the dataset will double.
+        :type ratio: `float`
+        :return: The augmented dataset and (if provided) corresponding labels.
+        :rtype:
+        """
+        # Set params
+        params = {}
+        if sigma is not None:
+            params['sigma'] = sigma
+
+        if ratio is not None:
+            params['ratio'] = ratio
+
+        if params:
+            self.set_params(**params)
+
+        # Select indices to augment
+        import numpy as np
+        size = int(x.shape[0] * self.ratio)
+        indices = np.random.randint(0, x.shape[0], size=size)
+
+        # Generate noisy samples
+        x_aug = np.random.normal(x[indices], scale=self.sigma, size=(size,) + x[indices].shape[1:])
+        x_aug = np.vstack((x, x_aug))
+
+        if y is not None:
+            y_aug = np.concatenate((y, y[indices]))
+            return x_aug, y_aug
+        else:
+            return x_aug
+
+    def fit(self, x, y=None, **kwargs):
+        """
+        No parameters to learn for this method; do nothing.
+        """
+        pass
+
+    def set_params(self, **kwargs):
+        """
+        Take in a dictionary of parameters and applies defense-specific checks before saving them as attributes.
+
+        :param sigma: Standard deviation of Gaussian noise to be added.
+        :type sigma: `float`
+        :param ratio: Percentage of data augmentation. E.g. for a ratio of 1, the size of the dataset will double.
+        :type ratio: `float`
+        """
+        # Save attack-specific parameters
+        super(GaussianAugmentation, self).set_params(**kwargs)
+
+        if self.ratio <= 0:
+            raise ValueError("The augmentation ratio must be positive.")
+
+        return True

art/defences/gaussian_augmentation_unittest.py

@@ -0,0 +1,37 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import unittest
+
+import numpy as np
+
+from art.defences.gaussian_augmentation import GaussianAugmentation
+
+
+class TestGaussianAugmentation(unittest.TestCase):
+    def test_small_size(self):
+        x = np.arange(15).reshape((5, 3))
+        ga = GaussianAugmentation()
+        new_x = ga(x, ratio=.4)
+        self.assertTrue(new_x.shape == (7, 3))
+
+    def test_double_size(self):
+        x = np.arange(12).reshape((4, 3))
+        ga = GaussianAugmentation()
+        new_x = ga(x)
+        self.assertTrue(new_x.shape[0] == 2 * x.shape[0])
+
+    def test_multiple_size(self):
+        x = np.arange(12).reshape((4, 3))
+        ga = GaussianAugmentation(ratio=3.5)
+        new_x = ga(x)
+        self.assertTrue(int(4.5 * x.shape[0]) == new_x.shape[0])
+
+    def test_labels(self):
+        x = np.arange(12).reshape((4, 3))
+        y = np.arange(8).reshape((4, 2))
+
+        ga = GaussianAugmentation()
+        new_x, new_y = ga(x, y)
+        self.assertTrue(new_x.shape[0] == new_y.shape[0] == 8)
+        self.assertTrue(new_x.shape[1:] == x.shape[1:])
+        self.assertTrue(new_y.shape[1:] == y.shape[1:])