Merge pull request #1848 from Trusted-AI/development_nmegiddo_patch-1

Move new random sampling method to art.utils

Author: beat-buesser

art/utils.py

@@ -578,6 +578,78 @@ def random_sphere(
     return res
 
 
+def uniform_sample_from_sphere_or_ball(
+    nb_points: int,
+    nb_dims: int,
+    radius: Union[int, float, np.ndarray],
+    sample_space: str = "ball",
+    norm: Union[int, float, str] = 2,
+) -> np.ndarray:
+    """
+    Generate a sample of  <nb_points>  distributed independently and uniformly on the sphere (with respect to the given
+    norm) in dimension <nb_dims> with radius <radius> and centered at the origin.  Note that the sphere is the boundary
+    of the ball, i.e., every point on the sphere has the same distance to the origin.
+
+    :param nb_points: Number of random data points
+    :param nb_dims: Dimensionality of the sphere
+    :param radius: Radius of the sphere
+    :param sample_space: One of 'b', 's', 'sphere', 'ball'
+    :param norm: Current support: 1, 2, np.inf, "inf"
+    :return: The sampled points from the sphere (i.e., boundary of the ball)
+    """
+    assert sample_space in ["b", "s", "sphere", "ball"]
+
+    if norm == 1:
+        if sample_space in ["s", "sphere"]:
+            y = np.random.exponential(1, (nb_points, nb_dims))
+            sums = np.sum(y, axis=1)
+            scal = np.outer(sums, np.ones(nb_dims))
+            y = y / scal
+        else:
+            y = np.random.exponential(1, (nb_points, nb_dims + 1))
+            sums = np.sum(y, axis=1)
+            scal = np.outer(sums, np.ones(nb_dims + 1))
+            y = y / scal
+            y = y[:, :nb_dims]
+
+        y = y * np.random.choice([-1, 1], (nb_points, nb_dims))
+        if type(radius) in [int, float]:
+            res = y * radius
+        else:
+            radii = np.outer(radius, np.ones(nb_dims))
+            res = y * radii
+
+    elif norm == 2:
+        x = np.random.normal(0.0, 1.0, (nb_points, nb_dims))
+        scal = radius / np.sqrt(np.sum(x * x, axis=1))
+        scal = np.transpose(np.array(list(scal) * nb_dims).reshape((nb_dims, nb_points)))
+        res = x * scal
+        if sample_space in ["b", "ball"]:
+            rnd = np.random.rand(nb_points)
+            scal = np.float_power(rnd, 1 / nb_dims)
+            scal = np.outer(scal, np.ones(nb_dims))
+            res = res * scal
+
+    elif norm in [np.inf, "inf"]:
+        if sample_space in ["b", "ball"]:
+            x = np.random.uniform(-1.0, 1.0, (nb_points, nb_dims))
+        else:
+            x = np.random.uniform(0, 1.0, (nb_points, nb_dims))
+            rnd = np.random.random((nb_points, nb_dims))
+            maxes = np.max(rnd, axis=1)
+            maxes = np.outer(maxes, np.ones(nb_dims))
+            x = np.maximum((rnd >= maxes), x) * np.random.choice([-1, 1], (nb_points, nb_dims))
+        if type(radius) in [int, float]:
+            res = x * radius
+        else:
+            radii = np.outer(radius, np.ones(nb_dims))
+            res = x * radii
+    else:
+        raise NotImplementedError(f"Norm {norm} not supported")
+
+    return res
+
+
 def original_to_tanh(
     x_original: np.ndarray,
     clip_min: Union[float, np.ndarray],

tests/test_utils.py

@@ -23,10 +23,10 @@
 import numpy as np
 import tensorflow as tf
 
-from art.utils import projection, random_sphere, to_categorical, least_likely_class, check_and_transform_label_format
+from art.utils import projection, random_sphere, uniform_sample_from_sphere_or_ball, to_categorical, least_likely_class
 from art.utils import load_dataset, load_iris, load_mnist, load_nursery, load_cifar10
 from art.utils import second_most_likely_class, random_targets, get_label_conf, get_labels_np_array, preprocess
-from art.utils import compute_success_array, compute_success
+from art.utils import compute_success_array, compute_success, check_and_transform_label_format
 from art.utils import segment_by_class, performance_diff
 from art.utils import is_probability
 
@@ -179,6 +179,34 @@ def test_random_sphere(self):
         x = random_sphere(1, 10000, 1, np.inf)
         self.assertTrue(np.abs(np.max(np.abs(x), axis=1) - 1.0) < 1e-2)
 
+    def test_uniform_sample_from_sphere_or_ball(self):
+        x = uniform_sample_from_sphere_or_ball(nb_points=10, nb_dims=10, radius=1, sample_space="ball", norm=1)
+
+        self.assertEqual(x.shape, (10, 10))
+        self.assertTrue(np.all(np.sum(np.abs(x), axis=1) <= 1.0))
+
+        x = uniform_sample_from_sphere_or_ball(nb_points=10, nb_dims=10, radius=1, sample_space="ball", norm=np.inf)
+        self.assertEqual(x.shape, (10, 10))
+        self.assertTrue(np.all(np.abs(x) < 1.0))
+
+        x = uniform_sample_from_sphere_or_ball(nb_points=10, nb_dims=10, radius=0.5, sample_space="ball", norm=1)
+        self.assertTrue(np.all(np.sum(np.abs(x), axis=1) <= 0.5))
+
+        x = uniform_sample_from_sphere_or_ball(nb_points=10, nb_dims=10, radius=0.5, sample_space="ball", norm=2)
+        self.assertTrue(np.all(np.linalg.norm(x, axis=1) < 0.5))
+
+        x = uniform_sample_from_sphere_or_ball(nb_points=10, nb_dims=10, radius=0.5, sample_space="ball", norm=np.inf)
+        self.assertTrue(np.all(np.abs(x) < 0.5))
+
+        x = uniform_sample_from_sphere_or_ball(nb_points=1, nb_dims=10000, radius=1, sample_space="ball", norm=1)
+        self.assertTrue(np.abs(np.sum(np.abs(x), axis=1) - 1.0) < 1e-2)
+
+        x = uniform_sample_from_sphere_or_ball(nb_points=1, nb_dims=10000, radius=1, sample_space="ball", norm=2)
+        self.assertTrue(np.abs(np.linalg.norm(x, axis=1) - 1.0) < 1e-2)
+
+        x = uniform_sample_from_sphere_or_ball(nb_points=1, nb_dims=10000, radius=1, sample_space="ball", norm=np.inf)
+        self.assertTrue(np.abs(np.max(np.abs(x), axis=1) - 1.0) < 1e-2)
+
     def test_to_categorical(self):
         y = np.array([3, 1, 4, 1, 5, 9])
         y_ = to_categorical(y)