def test_basics(self, rng_ctor):
random = RandomStream(seed=utt.fetch_seed(), rng_ctor=rng_ctor)
with pytest.raises(ValueError):
random.uniform(0, 1, size=(2, 2), rng=np.random.default_rng(23))
with pytest.raises(AttributeError):
random.blah
assert hasattr(random, "standard_normal")
with pytest.raises(AttributeError):
np_random = RandomStream(namespace=np, rng_ctor=rng_ctor)
np_random.ndarray
fn = function([],
random.uniform(0, 1, size=(2, 2)),
updates=random.updates())
fn_val0 = fn()
fn_val1 = fn()
rng_seed = np.random.SeedSequence(utt.fetch_seed())
(rng_seed, ) = rng_seed.spawn(1)
rng = random.rng_ctor(rng_seed)
numpy_val0 = rng.uniform(0, 1, size=(2, 2))
numpy_val1 = rng.uniform(0, 1, size=(2, 2))
assert np.allclose(fn_val0, numpy_val0)
assert np.allclose(fn_val1, numpy_val1)
def test_basics(self):
random = RandomStream(seed=utt.fetch_seed())
with pytest.raises(TypeError):
random.uniform(0, 1, size=(2, 2), rng=np.random.RandomState(23))
with pytest.raises(AttributeError):
random.blah
with pytest.raises(AttributeError):
np_random = RandomStream(namespace=np)
np_random.ndarray
fn = function([],
random.uniform(0, 1, size=(2, 2)),
updates=random.updates())
fn_val0 = fn()
fn_val1 = fn()
rng_seed = np.random.RandomState(utt.fetch_seed()).randint(2**30)
rng = np.random.RandomState(int(rng_seed)) # int() is for 32bit
numpy_val0 = rng.uniform(0, 1, size=(2, 2))
numpy_val1 = rng.uniform(0, 1, size=(2, 2))
assert np.allclose(fn_val0, numpy_val0)
assert np.allclose(fn_val1, numpy_val1)
def test_default_updates(self, rng_ctor):
# Basic case: default_updates
random_a = RandomStream(utt.fetch_seed(), rng_ctor=rng_ctor)
out_a = random_a.uniform(0, 1, size=(2, 2))
fn_a = function([], out_a)
fn_a_val0 = fn_a()
fn_a_val1 = fn_a()
assert not np.all(fn_a_val0 == fn_a_val1)
nearly_zeros = function([], out_a + out_a - 2 * out_a)
assert np.all(abs(nearly_zeros()) < 1e-5)
# Explicit updates #1
random_b = RandomStream(utt.fetch_seed(), rng_ctor=rng_ctor)
out_b = random_b.uniform(0, 1, size=(2, 2))
fn_b = function([], out_b, updates=random_b.updates())
fn_b_val0 = fn_b()
fn_b_val1 = fn_b()
assert np.all(fn_b_val0 == fn_a_val0)
assert np.all(fn_b_val1 == fn_a_val1)
# Explicit updates #2
random_c = RandomStream(utt.fetch_seed(), rng_ctor=rng_ctor)
out_c = random_c.uniform(0, 1, size=(2, 2))
fn_c = function([], out_c, updates=random_c.state_updates)
fn_c_val0 = fn_c()
fn_c_val1 = fn_c()
assert np.all(fn_c_val0 == fn_a_val0)
assert np.all(fn_c_val1 == fn_a_val1)
# No updates at all
random_d = RandomStream(utt.fetch_seed(), rng_ctor=rng_ctor)
out_d = random_d.uniform(0, 1, size=(2, 2))
fn_d = function([], out_d, no_default_updates=True)
fn_d_val0 = fn_d()
fn_d_val1 = fn_d()
assert np.all(fn_d_val0 == fn_a_val0)
assert np.all(fn_d_val1 == fn_d_val0)
# No updates for out
random_e = RandomStream(utt.fetch_seed(), rng_ctor=rng_ctor)
out_e = random_e.uniform(0, 1, size=(2, 2))
fn_e = function([],
out_e,
no_default_updates=[random_e.state_updates[0][0]])
fn_e_val0 = fn_e()
fn_e_val1 = fn_e()
assert np.all(fn_e_val0 == fn_a_val0)
assert np.all(fn_e_val1 == fn_e_val0)
def test_tutorial(self):
srng = RandomStream(seed=234)
rv_u = srng.uniform(0, 1, size=(2, 2))
rv_n = srng.normal(0, 1, size=(2, 2))
f = function([], rv_u)
# Disabling `default_updates` means that we have to pass
# `srng.state_updates` to `function` manually, if we want the shared
# state to change
g = function([], rv_n, no_default_updates=True)
nearly_zeros = function([], rv_u + rv_u - 2 * rv_u)
assert np.all(f() != f())
assert np.all(g() == g())
assert np.all(abs(nearly_zeros()) < 1e-5)
def test_uniform(self):
# Test that RandomStream.uniform generates the same results as numpy
# Check over two calls to see if the random state is correctly updated.
random = RandomStream(utt.fetch_seed())
fn = function([], random.uniform(-1, 1, size=(2, 2)))
fn_val0 = fn()
fn_val1 = fn()
rng_seed = np.random.RandomState(utt.fetch_seed()).randint(2**30)
rng = np.random.RandomState(int(rng_seed)) # int() is for 32bit
numpy_val0 = rng.uniform(-1, 1, size=(2, 2))
numpy_val1 = rng.uniform(-1, 1, size=(2, 2))
assert np.allclose(fn_val0, numpy_val0)
assert np.allclose(fn_val1, numpy_val1)
def test_uniform(self, rng_ctor):
# Test that RandomStream.uniform generates the same results as numpy
# Check over two calls to see if the random state is correctly updated.
random = RandomStream(utt.fetch_seed(), rng_ctor=rng_ctor)
fn = function([], random.uniform(-1, 1, size=(2, 2)))
fn_val0 = fn()
fn_val1 = fn()
rng_seed = np.random.SeedSequence(utt.fetch_seed())
(rng_seed, ) = rng_seed.spawn(1)
rng = random.rng_ctor(rng_seed)
numpy_val0 = rng.uniform(-1, 1, size=(2, 2))
numpy_val1 = rng.uniform(-1, 1, size=(2, 2))
assert np.allclose(fn_val0, numpy_val0)
assert np.allclose(fn_val1, numpy_val1)
def test_connection_pattern(self, cls_ofg):
# Basic case
x, y, z = matrices("xyz")
out1 = x * y
out2 = y * z
op1 = cls_ofg([x, y, z], [out1, out2])
results = op1.connection_pattern(None)
expect_result = [[True, False], [True, True], [False, True]]
assert results == expect_result
# Graph with ops that don't have a 'full' connection pattern
# and with ops that have multiple outputs
m, n, p, q = matrices("mnpq")
o1, o2 = op1(m, n, p)
out1, out2 = op1(o1, q, o2)
op2 = cls_ofg([m, n, p, q], [out1, out2])
results = op2.connection_pattern(None)
expect_result = [[True, False], [True, True], [False, True],
[True, True]]
assert results == expect_result
# Inner graph where some computation doesn't rely on explicit inputs
srng = RandomStream(seed=234)
rv_u = srng.uniform((2, 2))
x, y = matrices("xy")
out1 = x + rv_u
out2 = y + 3
out3 = 3 + rv_u
op3 = cls_ofg([x, y], [out1, out2, out3])
results = op3.connection_pattern(None)
expect_result = [
[True, False, False],
[False, True, False],
[True, False, True],
]
assert results == expect_result
class Graph:
def __init__(self, seed=123):
self.rng = RandomStream(seed, rng_ctor=rng_ctor)
self.y = self.rng.uniform(0, 1, size=(1, ))
def test_uniform():
# TODO: test param low, high
# TODO: test size=None
# TODO: test ndim!=size.ndim
# TODO: test bad seed
# TODO: test size=Var, with shape that change from call to call
if (config.mode in ("DEBUG_MODE", "DebugMode", "FAST_COMPILE")
or config.mode == "Mode" and config.linker in ["py"]):
sample_size = (10, 100)
steps = 50
else:
sample_size = (500, 50)
steps = int(1e3)
x = matrix()
for size, const_size, var_input, input in [
(sample_size, sample_size, [], []),
(x.shape, sample_size, [x],
[np.zeros(sample_size, dtype=config.floatX)]),
(
(x.shape[0], sample_size[1]),
sample_size,
[x],
[np.zeros(sample_size, dtype=config.floatX)],
),
# test empty size (scalar)
((), (), [], []),
]:
# TEST CPU IMPLEMENTATION
# The python and C implementation are tested with DebugMode
x = matrix()
R = MRG_RandomStream(234)
# Note: we specify `nstreams` to avoid a warning.
# TODO Look for all occurrences of `guess_n_streams` and `30 * 256`
# for such situations: it would be better to instead filter the
# warning using the warning module.
u = R.uniform(size=size,
nstreams=rng_mrg.guess_n_streams(size, warn=False))
f = function(var_input, u)
assert any(
isinstance(node.op, mrg_uniform)
for node in f.maker.fgraph.toposort())
f(*input)
# Increase the number of steps if sizes implies only a few samples
if np.prod(const_size) < 10:
steps_ = steps * 100
else:
steps_ = steps
check_basics(f, steps_, const_size, prefix="mrg cpu", inputs=input)
RR = RandomStream(234)
uu = RR.uniform(size=size)
ff = function(var_input, uu)
# It's not our problem if numpy generates 0 or 1
check_basics(ff,
steps_,
const_size,
prefix="numpy",
allow_01=True,
inputs=input)
