Add more tests for RandomState and RandomState.uniform

antonwolfy · antonwolfy · commit 039780a5ee9d · 2022-08-11T13:38:39.000-05:00
diff --git a/dpnp/random/dpnp_algo_random.pyx b/dpnp/random/dpnp_algo_random.pyx
@@ -34,8 +34,12 @@ and the rest of the library
 
 
 import numpy
-import dpnp.config as config
 import dpctl
+import numbers
+
+import dpnp.config as config
+from dpnp.dpnp_array import dpnp_array
+
 from libc.stdlib cimport free, malloc
 from libc.stdint cimport uint32_t
 
@@ -312,27 +316,39 @@ cdef class MT19937:
             raise ValueError("SyclQueue copy failed")
 
         # get a scalar seed value or a vector of seeds
-        if isinstance(seed, int) and seed >= 0:
-            scalar_seed = <uint32_t> seed
-        elif isinstance(seed, (list, tuple)):
-            is_vector_seed = True
-            vector_seed_len = len(seed)
-            if vector_seed_len > 3:
-                raise ValueError(
-                    f"{vector_seed_len} length of seed vector isn't supported, "
-                    "the length is limited by 3")
-
-            vector_seed = <uint32_t *> malloc(vector_seed_len * sizeof(uint32_t))
-            if (not vector_seed):
-                raise MemoryError(f"Could not allocate memory for seed vector of length {vector_seed_len}")
-
-            # convert input seed's type to uint32_t one (expected in MKL function)
-            try:
-                for i in range(vector_seed_len):
-                    vector_seed[i] = <uint32_t> seed[i]
-            except (ValueError, TypeError) as e:
-                free(vector_seed)
-                raise e
+        if self.is_integer(seed):
+            if self.is_uint_range(seed):
+                scalar_seed = <uint32_t> seed
+            else:
+                raise ValueError("Seed must be between 0 and 2**32 - 1")
+        elif isinstance(seed, (list, tuple, range, numpy.ndarray, dpnp_array)):
+            if len(seed) == 0:
+                raise ValueError("Seed must be non-empty")
+            elif numpy.ndim(seed) > 1:
+                raise ValueError("Seed array must be 1-d")
+            elif not all([self.is_integer(item) for item in seed]):
+                raise TypeError("Seed must be a sequence of unsigned int elements")
+            elif not all([self.is_uint_range(item) for item in seed]):
+                raise ValueError("Seed must be between 0 and 2**32 - 1")
+            else:
+                is_vector_seed = True
+                vector_seed_len = len(seed)
+                if vector_seed_len > 3:
+                    raise ValueError(
+                        f"{vector_seed_len} length of seed vector isn't supported, "
+                        "the length is limited by 3")
+
+                vector_seed = <uint32_t *> malloc(vector_seed_len * sizeof(uint32_t))
+                if (not vector_seed):
+                    raise MemoryError(f"Could not allocate memory for seed vector of length {vector_seed_len}")
+
+                # convert input seed's type to uint32_t one (expected in MKL function)
+                try:
+                    for i in range(vector_seed_len):
+                        vector_seed[i] = <uint32_t> seed[i]
+                except (ValueError, TypeError) as e:
+                    free(vector_seed)
+                    raise e
         else:
             raise TypeError("Seed must be an unsigned int, or a sequence of unsigned int elements")
 
@@ -346,6 +362,15 @@ cdef class MT19937:
         MT19937_Delete(&self.mt19937)
         c_dpctl.DPCTLQueue_Delete(self.q_ref)
 
+    cdef bint is_integer(self, value):
+        if isinstance(value, numbers.Number):
+            return isinstance(value, int) or isinstance(value, (numpy.int32, numpy.uint32))
+        # cover an element of dpnp array:
+        return numpy.ndim(value) == 0 and hasattr(value, "dtype") and numpy.issubdtype(value, (numpy.int32, numpy.uint32))
+
+    cdef bint is_uint_range(self, value):
+        return value >= 0 and value <= numpy.iinfo(numpy.uint32).max
+
     cdef mt19937_struct * get_mt19937(self):
         return &self.mt19937
 
diff --git a/dpnp/random/dpnp_iface_random.py b/dpnp/random/dpnp_iface_random.py
@@ -110,6 +110,7 @@ def __init__(self, seed=1, sycl_queue=None):
             seed = 1
 
         self.random_state = MT19937(seed, sycl_queue)
+        self.fallback_random_state = call_origin(numpy.random.RandomState, seed)
 
     def uniform(self, low=0.0, high=1.0, size=None, dtype=numpy.float64, usm_type="device"):
         """
@@ -119,6 +120,13 @@ def uniform(self, low=0.0, high=1.0, size=None, dtype=numpy.float64, usm_type="d
         In other words, any value within the given interval is equally likely to be drawn by uniform.
 
         For full documentation refer to :obj:`numpy.random.RandomState.uniform`.
+
+        Limitations
+        -----------
+        Parameters ``low`` and ``high`` are supported as scalar.
+        Otherwise, :obj:`numpy.random.uniform(low, high, size)` samples are drawn.
+        Parameter ``dtype`` is supported only for :obj:`dpnp.float32` or :obj:`dpnp.float64`.
+        Output array data type is the same as ``dtype``.
         """
 
         if not use_origin_backend(low):
@@ -129,9 +137,11 @@ def uniform(self, low=0.0, high=1.0, size=None, dtype=numpy.float64, usm_type="d
             else:
                 if low > high:
                     low, high = high, low
+                if not (dpnp.is_type_supported(dtype) and dtype in {dpnp.float32, dpnp.float64}):
+                    raise TypeError(f"{dtype} is unsupported.")
                 return self.random_state.uniform(low, high, size, dtype, usm_type).get_pyobj()
 
-        return call_origin(numpy.random.uniform, low, high, size)
+        return call_origin(self.fallback_random_state.uniform, low, high, size)
 
 def _check_dims(dims):
     for dim in dims:
@@ -1370,13 +1380,14 @@ def seed(seed=None):
             pass
         else:
             # TODO:
-            # migrate to a single approach with RandomState()
+            # migrate to a single approach with RandomState class
 
-            # update a mt19937 random number for both RandomState() class and legacy functionality
+            # update a mt19937 random number for both RandomState and legacy functionality
             global dpnp_random_state
             dpnp_random_state = RandomState(seed)
-            return dpnp_rng_srand(seed)
+            dpnp_rng_srand(seed)
 
+    # always reseed numpy engine also
     return call_origin(numpy.random.seed, seed)
 
 
@@ -1596,8 +1607,7 @@ def uniform(low=0.0, high=1.0, size=None, usm_type='device'):
     :obj:`dpnp.random.random` : Floats uniformly distributed over ``[0, 1)``.
 
     """
-    dtype = numpy.float64
-    return dpnp_random_state.uniform(low, high, size, dtype, usm_type)
+    return dpnp_random_state.uniform(low, high, size, dtype=numpy.float64, usm_type=usm_type)
 
 
 def vonmises(mu, kappa, size=None):
diff --git a/tests/test_randomstate.py b/tests/test_randomstate.py
@@ -0,0 +1,116 @@
+import pytest
+import unittest
+
+import dpnp
+import numpy
+
+from dpnp.random import RandomState
+from numpy.testing import (assert_allclose, assert_raises, assert_array_almost_equal)
+
+
+class TestSeed:
+    def test_scalar(self):
+        seed = 28041997
+        size = (3, 2, 4)
+        rs = RandomState(seed)
+        a1 = dpnp.asnumpy(rs.uniform(size=size))
+        rs = RandomState(seed)
+        a2 = dpnp.asnumpy(rs.uniform(size=size))
+        assert_allclose(a1, a2, rtol=1e-07, atol=0)
+
+    @pytest.mark.parametrize("seed",
+                             [range(3),
+                              numpy.arange(3, dtype=numpy.int32),
+                              dpnp.arange(3, dtype=numpy.int32),
+                              [0], [4294967295], [2, 7, 15], (1,), (85, 6, 17)],
+                             ids=['range(2)',
+                                  'numpy.arange(2)',
+                                  'dpnp.arange(2)',
+                                  '[0]', '[4294967295]', '[2, 7, 15]', '(1,)', '(85, 6, 17)'])
+    def test_array_range(self, seed):
+        size = 15
+        a1 = dpnp.asnumpy(RandomState(seed).uniform(size=size))
+        a2 = dpnp.asnumpy(RandomState(seed).uniform(size=size))
+        assert_allclose(a1, a2, rtol=1e-07, atol=0)
+
+    @pytest.mark.parametrize("seed",
+                             [0.5, -1.5, [-0.3], (1.7, 3),
+                              'text',
+                              numpy.arange(0, 1, 0.5),
+                              dpnp.arange(3),
+                              dpnp.arange(3, dtype=numpy.float32)],
+                             ids=['0.5', '-1.5', '[-0.3]', '(1.7, 3)',
+                                  'text',
+                                  'numpy.arange(0, 1, 0.5)',
+                                  'dpnp.arange(3)',
+                                  'dpnp.arange(3, dtype=numpy.float32)'])
+    def test_invalid_type(self, seed):
+        # seed must be an unsigned 32-bit integer
+        assert_raises(TypeError, RandomState, seed)
+
+    @pytest.mark.parametrize("seed",
+                             [-1, [-3, 7], (17, 3, -5), [4, 3, 2, 1], (7, 6, 5, 1),
+                              range(-1, -11, -1),
+                              numpy.arange(4, dtype=numpy.int32),
+                              dpnp.arange(-3, 3, dtype=numpy.int32),
+                              numpy.iinfo(numpy.uint32).max + 1,
+                              (1, 7, numpy.iinfo(numpy.uint32).max + 1)],
+                             ids=['-1', '[-3, 7]', '(17, 3, -5)', '[4, 3, 2, 1]', '(7, 6, 5, 1)',
+                                  'range(-1, -11, -1)',
+                                  'numpy.arange(4, dtype=numpy.int32)',
+                                  'dpnp.arange(-3, 3, dtype=numpy.int32)',
+                                  'numpy.iinfo(numpy.uint32).max + 1',
+                                  '(1, 7, numpy.iinfo(numpy.uint32).max + 1)'])
+    def test_invalid_value(self, seed):
+        # seed must be an unsigned 32-bit integer
+        assert_raises(ValueError, RandomState, seed)
+
+    @pytest.mark.parametrize("seed",
+                             [[], (),
+                              [[1, 2, 3]],
+                              [[1, 2, 3], [4, 5, 6]],
+                              numpy.array([], dtype=numpy.int64),
+                              dpnp.array([], dtype=numpy.int64)],
+                             ids=['[]', '()',
+                                  '[[1, 2, 3]]',
+                                  '[[1, 2, 3], [4, 5, 6]]',
+                                  'numpy.array([], dtype=numpy.int64)',
+                                  'dpnp.array([], dtype=numpy.int64)'])
+    def test_invalid_shape(self, seed):
+        # seed must be an unsigned or 1-D array
+        assert_raises(ValueError, RandomState, seed)
+
+class TestUniform:
+    @pytest.mark.parametrize("dtype",
+                             [dpnp.float32, dpnp.float64, numpy.float32, numpy.float64],
+                             ids=['dpnp.float32', 'dpnp.float64', 'numpy.float32', 'numpy.float64'])
+    @pytest.mark.parametrize("usm_type",
+                             ["host", "device", "shared"],
+                             ids=['host', 'device', 'shared'])
+    def test_uniform(self, dtype, usm_type):
+        seed = 28041997
+        actual = dpnp.asnumpy(RandomState(seed).uniform(low=1.23, high=10.54, size=(3, 2), dtype=dtype, usm_type=usm_type))
+        desired = numpy.array([[3.700744485249743, 8.390019132522866],
+                               [2.60340195777826,  4.473366308724508],
+                               [1.773701806552708, 4.193498786306009]])
+        assert_array_almost_equal(actual, desired, decimal=6)
+
+    @pytest.mark.parametrize("high",
+                             [dpnp.array([3]), numpy.array([3])],
+                             ids=['dpnp.array([3])', 'numpy.array([3])'])
+    @pytest.mark.parametrize("low",
+                             [[2], dpnp.array([2]), numpy.array([2])],
+                             ids=['[2]', 'dpnp.array([2])', 'numpy.array([2])'])
+    def test_fallback(self, low, high):
+        seed = 15
+        # dpnp accepts only scalar as low and/or high, in other case it will be a fallback to numpy
+        actual = dpnp.asnumpy(RandomState(seed).uniform(low=low, high=high, size=(3, 2, 5)))
+        desired = numpy.random.RandomState(seed).uniform(low=low, high=high, size=(3, 2, 5))
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    @pytest.mark.parametrize("dtype",
+                             [dpnp.float16, numpy.integer, dpnp.int, dpnp.bool, numpy.int64, dpnp.int32],
+                             ids=['dpnp.float16', 'numpy.integer', 'dpnp.int', 'dpnp.bool', 'numpy.int64', 'dpnp.int32'])
+    def test_invalid_dtype(self, dtype):
+        # dtype must be float32 or float64
+        assert_raises(TypeError, RandomState().uniform, dtype=dtype)
