def test_normal_vector(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
avg = tensor.vector()
std = tensor.vector()
out = m.random.normal(avg=avg, std=std)
assert out.ndim == 1
m.f = Method([avg, std], out)
# Specifying the size explicitly
m.g = Method([avg, std], m.random.normal(avg=avg, std=std, size=(3, )))
made = m.make()
made.random.initialize()
avg_val = [1, 2, 3]
std_val = numpy.asarray([.1, .2, .3], dtype=config.floatX)
seed_gen = numpy.random.RandomState(utt.fetch_seed())
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = made.f(avg_val, std_val)
numpy_val0 = numpy_rng.normal(loc=avg_val, scale=std_val)
assert numpy.allclose(val0, numpy_val0)
# arguments of size (2,)
val1 = made.f(avg_val[:-1], std_val[:-1])
numpy_val1 = numpy_rng.normal(loc=avg_val[:-1], scale=std_val[:-1])
assert numpy.allclose(val1, numpy_val1)
# Specifying the size explicitly
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
val2 = made.g(avg_val, std_val)
numpy_val2 = numpy_rng.normal(loc=avg_val, scale=std_val, size=(3, ))
assert numpy.allclose(val2, numpy_val2)
self.assertRaises(ValueError, made.g, avg_val[:-1], std_val[:-1])
def test_uniform_vector(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
low = tensor.vector()
high = tensor.vector()
out = m.random.uniform(low=low, high=high)
assert out.ndim == 1
m.f = Method([low, high], out)
# Specifying the size explicitly
m.g = Method([low, high],
m.random.uniform(low=low, high=high, size=(3, )))
made = m.make()
made.random.initialize()
low_val = numpy.asarray([.1, .2, .3], dtype=config.floatX)
high_val = numpy.asarray([1.1, 2.2, 3.3], dtype=config.floatX)
seed_gen = numpy.random.RandomState(utt.fetch_seed())
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = made.f(low_val, high_val)
numpy_val0 = numpy_rng.uniform(low=low_val, high=high_val)
assert numpy.allclose(val0, numpy_val0)
# arguments of size (2,)
val1 = made.f(low_val[:-1], high_val[:-1])
numpy_val1 = numpy_rng.uniform(low=low_val[:-1], high=high_val[:-1])
assert numpy.allclose(val1, numpy_val1)
# Specifying the size explicitly
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
val2 = made.g(low_val, high_val)
numpy_val2 = numpy_rng.uniform(low=low_val, high=high_val, size=(3, ))
assert numpy.allclose(val2, numpy_val2)
self.assertRaises(ValueError, made.g, low_val[:-1], high_val[:-1])
def test_binomial_vector(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
n = tensor.lvector()
prob = tensor.vector()
out = m.random.binomial(n=n, p=prob)
assert out.ndim == 1
m.f = Method([n, prob], out)
# Specifying the size explicitly
m.g = Method([n, prob], m.random.binomial(n=n, p=prob, size=(3, )))
made = m.make()
made.random.initialize()
n_val = [1, 2, 3]
prob_val = numpy.asarray([.1, .2, .3], dtype=config.floatX)
seed_gen = numpy.random.RandomState(utt.fetch_seed())
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = made.f(n_val, prob_val)
numpy_val0 = numpy_rng.binomial(n=n_val, p=prob_val)
assert numpy.all(val0 == numpy_val0)
# arguments of size (2,)
val1 = made.f(n_val[:-1], prob_val[:-1])
numpy_val1 = numpy_rng.binomial(n=n_val[:-1], p=prob_val[:-1])
assert numpy.all(val1 == numpy_val1)
# Specifying the size explicitly
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
val2 = made.g(n_val, prob_val)
numpy_val2 = numpy_rng.binomial(n=n_val, p=prob_val, size=(3, ))
assert numpy.all(val2 == numpy_val2)
self.assertRaises(ValueError, made.g, n_val[:-1], prob_val[:-1])
def test_normal_vector(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
avg = tensor.vector()
std = tensor.vector()
out = m.random.normal(avg=avg, std=std)
assert out.ndim == 1
m.f = Method([avg, std], out)
# Specifying the size explicitly
m.g = Method([avg, std],
m.random.normal(avg=avg, std=std, size=(3,)))
made = m.make()
made.random.initialize()
avg_val = [1, 2, 3]
std_val = numpy.asarray([.1, .2, .3], dtype=config.floatX)
seed_gen = numpy.random.RandomState(utt.fetch_seed())
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = made.f(avg_val, std_val)
numpy_val0 = numpy_rng.normal(loc=avg_val, scale=std_val)
assert numpy.allclose(val0, numpy_val0)
# arguments of size (2,)
val1 = made.f(avg_val[:-1], std_val[:-1])
numpy_val1 = numpy_rng.normal(loc=avg_val[:-1], scale=std_val[:-1])
assert numpy.allclose(val1, numpy_val1)
# Specifying the size explicitly
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
val2 = made.g(avg_val, std_val)
numpy_val2 = numpy_rng.normal(loc=avg_val, scale=std_val, size=(3,))
assert numpy.allclose(val2, numpy_val2)
self.assertRaises(ValueError, made.g, avg_val[:-1], std_val[:-1])
def test_default_shape(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
m.f = Method([], m.random.uniform())
m.g = Method([], m.random.multinomial())
made = m.make()
made.random.initialize()
#seed_rng is generator for generating *seeds* for RandomStates
seed_rng = numpy.random.RandomState(utt.fetch_seed())
uniform_rng = numpy.random.RandomState(int(seed_rng.randint(2**30)))
multinomial_rng = numpy.random.RandomState(int(seed_rng.randint(
2**30)))
val0 = made.f()
val1 = made.f()
numpy_val0 = uniform_rng.uniform()
numpy_val1 = uniform_rng.uniform()
assert numpy.allclose(val0, numpy_val0)
assert numpy.allclose(val1, numpy_val1)
for i in range(
10
): # every test has 50% chance of passing even with non-matching random states
val2 = made.g()
numpy_val2 = multinomial_rng.multinomial(n=1, pvals=[.5, .5])
assert numpy.all(val2 == numpy_val2)
def test_binomial_vector(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
n = tensor.lvector()
prob = tensor.vector()
out = m.random.binomial(n=n, p=prob)
assert out.ndim == 1
m.f = Method([n, prob], out)
# Specifying the size explicitly
m.g = Method([n, prob],
m.random.binomial(n=n, p=prob, size=(3,)))
made = m.make()
made.random.initialize()
n_val = [1, 2, 3]
prob_val = numpy.asarray([.1, .2, .3], dtype=config.floatX)
seed_gen = numpy.random.RandomState(utt.fetch_seed())
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = made.f(n_val, prob_val)
numpy_val0 = numpy_rng.binomial(n=n_val, p=prob_val)
assert numpy.all(val0 == numpy_val0)
# arguments of size (2,)
val1 = made.f(n_val[:-1], prob_val[:-1])
numpy_val1 = numpy_rng.binomial(n=n_val[:-1], p=prob_val[:-1])
assert numpy.all(val1 == numpy_val1)
# Specifying the size explicitly
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
val2 = made.g(n_val, prob_val)
numpy_val2 = numpy_rng.binomial(n=n_val, p=prob_val, size=(3,))
assert numpy.all(val2 == numpy_val2)
self.assertRaises(ValueError, made.g, n_val[:-1], prob_val[:-1])
def test_uniform_vector(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
low = tensor.vector()
high = tensor.vector()
out = m.random.uniform(low=low, high=high)
assert out.ndim == 1
m.f = Method([low, high], out)
# Specifying the size explicitly
m.g = Method([low, high],
m.random.uniform(low=low, high=high, size=(3,)))
made = m.make()
made.random.initialize()
low_val = numpy.asarray([.1, .2, .3], dtype=config.floatX)
high_val = numpy.asarray([1.1, 2.2, 3.3], dtype=config.floatX)
seed_gen = numpy.random.RandomState(utt.fetch_seed())
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = made.f(low_val, high_val)
numpy_val0 = numpy_rng.uniform(low=low_val, high=high_val)
assert numpy.allclose(val0, numpy_val0)
# arguments of size (2,)
val1 = made.f(low_val[:-1], high_val[:-1])
numpy_val1 = numpy_rng.uniform(low=low_val[:-1], high=high_val[:-1])
assert numpy.allclose(val1, numpy_val1)
# Specifying the size explicitly
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
val2 = made.g(low_val, high_val)
numpy_val2 = numpy_rng.uniform(low=low_val, high=high_val, size=(3,))
assert numpy.allclose(val2, numpy_val2)
self.assertRaises(ValueError, made.g, low_val[:-1], high_val[:-1])
def test_multinomial_vector(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
n = tensor.lvector()
pvals = tensor.matrix()
out = m.random.multinomial(n=n, pvals=pvals)
assert out.ndim == 2
m.f = Method([n, pvals], out)
# Specifying the size explicitly
m.g = Method([n, pvals],
m.random.multinomial(n=n, pvals=pvals, size=(3, )))
made = m.make()
made.random.initialize()
n_val = [1, 2, 3]
pvals_val = numpy.asarray([[.1, .9], [.2, .8], [.3, .7]],
dtype=config.floatX)
seed_gen = numpy.random.RandomState(utt.fetch_seed())
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = made.f(n_val, pvals_val)
numpy_val0 = numpy.asarray([
numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val, pvals_val)
])
assert numpy.all(val0 == numpy_val0)
# arguments of size (2,)
val1 = made.f(n_val[:-1], pvals_val[:-1])
numpy_val1 = numpy.asarray([
numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val[:-1], pvals_val[:-1])
])
assert numpy.all(val1 == numpy_val1)
# Specifying the size explicitly
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
val2 = made.g(n_val, pvals_val)
numpy_val2 = numpy.asarray([
numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val, pvals_val)
])
assert numpy.all(val2 == numpy_val2)
self.assertRaises(ValueError, made.g, n_val[:-1], pvals_val[:-1])
def test_random_integers_vector(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
low = tensor.lvector()
high = tensor.lvector()
out = m.random.random_integers(low=low, high=high)
assert out.ndim == 1
m.f = Method([low, high], out)
# Specifying the size explicitly
m.g = Method([low, high],
m.random.random_integers(low=low, high=high, size=(3, )))
made = m.make()
made.random.initialize()
low_val = [100, 200, 300]
high_val = [110, 220, 330]
seed_gen = numpy.random.RandomState(utt.fetch_seed())
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = made.f(low_val, high_val)
numpy_val0 = numpy.asarray([
numpy_rng.random_integers(low=lv, high=hv)
for lv, hv in zip(low_val, high_val)
])
assert numpy.all(val0 == numpy_val0)
# arguments of size (2,)
val1 = made.f(low_val[:-1], high_val[:-1])
numpy_val1 = numpy.asarray([
numpy_rng.random_integers(low=lv, high=hv)
for lv, hv in zip(low_val[:-1], high_val[:-1])
])
assert numpy.all(val1 == numpy_val1)
# Specifying the size explicitly
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
val2 = made.g(low_val, high_val)
numpy_val2 = numpy.asarray([
numpy_rng.random_integers(low=lv, high=hv)
for lv, hv in zip(low_val, high_val)
])
assert numpy.all(val2 == numpy_val2)
self.assertRaises(ValueError, made.g, low_val[:-1], high_val[:-1])
def test_multinomial_vector(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
n = tensor.lvector()
pvals = tensor.matrix()
out = m.random.multinomial(n=n, pvals=pvals)
assert out.ndim == 2
m.f = Method([n, pvals], out)
# Specifying the size explicitly
m.g = Method([n, pvals],
m.random.multinomial(n=n, pvals=pvals, size=(3,)))
made = m.make()
made.random.initialize()
n_val = [1, 2, 3]
pvals_val = numpy.asarray([[.1, .9], [.2, .8], [.3, .7]],
dtype=config.floatX)
seed_gen = numpy.random.RandomState(utt.fetch_seed())
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = made.f(n_val, pvals_val)
numpy_val0 = numpy.asarray([numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val, pvals_val)])
assert numpy.all(val0 == numpy_val0)
# arguments of size (2,)
val1 = made.f(n_val[:-1], pvals_val[:-1])
numpy_val1 = numpy.asarray([numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val[:-1], pvals_val[:-1])])
assert numpy.all(val1 == numpy_val1)
# Specifying the size explicitly
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
val2 = made.g(n_val, pvals_val)
numpy_val2 = numpy.asarray([numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val, pvals_val)])
assert numpy.all(val2 == numpy_val2)
self.assertRaises(ValueError, made.g, n_val[:-1], pvals_val[:-1])
def test_random_integers_vector(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
low = tensor.lvector()
high = tensor.lvector()
out = m.random.random_integers(low=low, high=high)
assert out.ndim == 1
m.f = Method([low, high], out)
# Specifying the size explicitly
m.g = Method([low, high],
m.random.random_integers(low=low, high=high, size=(3,)))
made = m.make()
made.random.initialize()
low_val = [100, 200, 300]
high_val = [110, 220, 330]
seed_gen = numpy.random.RandomState(utt.fetch_seed())
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = made.f(low_val, high_val)
numpy_val0 = numpy.asarray([numpy_rng.random_integers(low=lv, high=hv)
for lv, hv in zip(low_val, high_val)])
assert numpy.all(val0 == numpy_val0)
# arguments of size (2,)
val1 = made.f(low_val[:-1], high_val[:-1])
numpy_val1 = numpy.asarray([numpy_rng.random_integers(low=lv, high=hv)
for lv, hv in zip(low_val[:-1], high_val[:-1])])
assert numpy.all(val1 == numpy_val1)
# Specifying the size explicitly
numpy_rng = numpy.random.RandomState(int(seed_gen.randint(2**30)))
val2 = made.g(low_val, high_val)
numpy_val2 = numpy.asarray([numpy_rng.random_integers(low=lv, high=hv)
for lv, hv in zip(low_val, high_val)])
assert numpy.all(val2 == numpy_val2)
self.assertRaises(ValueError, made.g, low_val[:-1], high_val[:-1])
def test_default_shape(self):
m = Module()
m.random = RandomStreams(utt.fetch_seed())
m.f = Method([], m.random.uniform())
m.g = Method([], m.random.multinomial())
made = m.make()
made.random.initialize()
#seed_rng is generator for generating *seeds* for RandomStates
seed_rng = numpy.random.RandomState(utt.fetch_seed())
uniform_rng = numpy.random.RandomState(int(seed_rng.randint(2**30)))
multinomial_rng = numpy.random.RandomState(int(seed_rng.randint(2**30)))
val0 = made.f()
val1 = made.f()
numpy_val0 = uniform_rng.uniform()
numpy_val1 = uniform_rng.uniform()
assert numpy.allclose(val0, numpy_val0)
assert numpy.allclose(val1, numpy_val1)
for i in range(10): # every test has 50% chance of passing even with non-matching random states
val2 = made.g()
numpy_val2 = multinomial_rng.multinomial(n=1, pvals=[.5, .5])
assert numpy.all(val2 == numpy_val2)
