def test_normal(self):
# Test that raw_random.normal generates the same results as numpy.
# Check over two calls to see if the random state is correctly updated.
rng_R = random_state_type()
# Use non-default parameters
post_r, out = normal(rng_R, (2, 3), 4.0, 2.0)
f = compile.function(
[
compile.In(
rng_R,
value=np.random.RandomState(utt.fetch_seed()),
update=post_r,
mutable=True,
)
],
[out],
accept_inplace=True,
)
numpy_rng = np.random.RandomState(utt.fetch_seed())
val0 = f()
val1 = f()
numpy_val0 = numpy_rng.normal(4.0, 2.0, size=(2, 3))
numpy_val1 = numpy_rng.normal(4.0, 2.0, size=(2, 3))
assert np.allclose(val0, numpy_val0)
assert np.allclose(val1, numpy_val1)
def test_normal_vector(self):
rng_R = random_state_type()
avg = tensor.vector()
std = tensor.vector()
post_r, out = normal(rng_R, avg=avg, std=std)
assert out.ndim == 1
f = compile.function([rng_R, avg, std], [post_r, out],
accept_inplace=True)
def as_floatX(thing):
return np.asarray(thing, dtype=theano.config.floatX)
avg_val = [1, 2, 3]
std_val = as_floatX([0.1, 0.2, 0.3])
rng = np.random.RandomState(utt.fetch_seed())
numpy_rng = np.random.RandomState(utt.fetch_seed())
# Arguments of size (3,)
rng0, val0 = f(rng, avg_val, std_val)
numpy_val0 = as_floatX(
numpy_rng.normal(loc=as_floatX(avg_val), scale=as_floatX(std_val)))
assert np.all(val0 == numpy_val0)
# arguments of size (2,)
rng1, val1 = f(rng0, avg_val[:-1], std_val[:-1])
numpy_val1 = np.asarray(
numpy_rng.normal(loc=avg_val[:-1], scale=std_val[:-1]),
dtype=theano.config.floatX,
)
assert np.all(val1 == numpy_val1)
# Specifying the size explicitly
g = compile.function(
[rng_R, avg, std],
normal(rng_R, avg=avg, std=std, size=(3, )),
accept_inplace=True,
)
rng2, val2 = g(rng1, avg_val, std_val)
numpy_val2 = np.asarray(
numpy_rng.normal(loc=avg_val, scale=std_val, size=(3, )),
dtype=theano.config.floatX,
)
assert np.all(val2 == numpy_val2)
with pytest.raises(ValueError):
g(rng2, avg_val[:-1], std_val[:-1])
def test_dtype_normal_uniform_687(self):
# Regression test for #687.
rng_R = random_state_type()
assert (uniform(rng_R,
low=tensor.constant(0, dtype="float64"),
dtype="float32")[1].dtype == "float32")
assert (normal(rng_R,
avg=tensor.constant(0, dtype="float64"),
dtype="float32")[1].dtype == "float32")
def test_infer_shape(self):
rng_R = random_state_type()
rng_R_val = np.random.RandomState(utt.fetch_seed())
# no shape specified, default args
post_r, out = uniform(rng_R)
self._compile_and_check([rng_R], [out], [rng_R_val], RandomFunction)
post_r, out = uniform(rng_R, size=None, ndim=2)
self._compile_and_check([rng_R], [out], [rng_R_val], RandomFunction)
"""
#infer_shape don't work for multinomial.
#The parameter ndim_added is set to 1 and in this case, the infer_shape
#inplementation don't know how to infer the shape
post_r, out = multinomial(rng_R)
self._compile_and_check([rng_R], [out], [rng_R_val],
RandomFunction)
"""
# no shape specified, args have to be broadcasted
low = tensor.TensorType(dtype="float64",
broadcastable=(False, True, True))()
high = tensor.TensorType(dtype="float64",
broadcastable=(True, True, True, False))()
post_r, out = uniform(rng_R, size=None, ndim=2, low=low, high=high)
low_val = [[[3]], [[4]], [[-5]]]
high_val = [[[[5, 8]]]]
self._compile_and_check([rng_R, low, high], [out],
[rng_R_val, low_val, high_val], RandomFunction)
# multinomial, specified shape
"""
#infer_shape don't work for multinomial
n = iscalar()
pvals = dvector()
size_val = (7, 3)
n_val = 6
pvals_val = [0.2] * 5
post_r, out = multinomial(rng_R, size=size_val, n=n, pvals=pvals,
ndim=2)
self._compile_and_check([rng_R, n, pvals], [out],
[rng_R_val, n_val, pvals_val],
RandomFunction)
"""
# uniform vector low and high
low = dvector()
high = dvector()
post_r, out = uniform(rng_R, low=low, high=1)
low_val = [-5, 0.5, 0, 1]
self._compile_and_check([rng_R, low], [out], [rng_R_val, low_val],
RandomFunction)
low_val = [0.9]
self._compile_and_check([rng_R, low], [out], [rng_R_val, low_val],
RandomFunction)
post_r, out = uniform(rng_R, low=low, high=high)
low_val = [-4.0, -2]
high_val = [-1, 0]
self._compile_and_check([rng_R, low, high], [out],
[rng_R_val, low_val, high_val], RandomFunction)
low_val = [-4.0]
high_val = [-1]
self._compile_and_check([rng_R, low, high], [out],
[rng_R_val, low_val, high_val], RandomFunction)
# uniform broadcasting low and high
low = dvector()
high = dcol()
post_r, out = uniform(rng_R, low=low, high=high)
low_val = [-5, 0.5, 0, 1]
high_val = [[1.0]]
self._compile_and_check([rng_R, low, high], [out],
[rng_R_val, low_val, high_val], RandomFunction)
low_val = [0.9]
high_val = [[1.0], [1.1], [1.5]]
self._compile_and_check([rng_R, low, high], [out],
[rng_R_val, low_val, high_val], RandomFunction)
low_val = [-5, 0.5, 0, 1]
high_val = [[1.0], [1.1], [1.5]]
self._compile_and_check([rng_R, low, high], [out],
[rng_R_val, low_val, high_val], RandomFunction)
# uniform with vector slice
low = dvector()
high = dvector()
post_r, out = uniform(rng_R, low=low, high=high)
low_val = [0.1, 0.2, 0.3]
high_val = [1.1, 2.2, 3.3]
size_val = (3, )
self._compile_and_check(
[rng_R, low, high],
[out],
[rng_R_val, low_val[:-1], high_val[:-1]],
RandomFunction,
)
# uniform with explicit size and size implicit in parameters
# NOTE 1: Would it be desirable that size could also be supplied
# as a Theano variable?
post_r, out = uniform(rng_R, size=size_val, low=low, high=high)
self._compile_and_check([rng_R, low, high], [out],
[rng_R_val, low_val, high_val], RandomFunction)
# binomial with vector slice
n = ivector()
prob = dvector()
post_r, out = binomial(rng_R, n=n, p=prob)
n_val = [1, 2, 3]
prob_val = [0.1, 0.2, 0.3]
size_val = (3, )
self._compile_and_check(
[rng_R, n, prob],
[out],
[rng_R_val, n_val[:-1], prob_val[:-1]],
RandomFunction,
)
# binomial with explicit size and size implicit in parameters
# cf. NOTE 1
post_r, out = binomial(rng_R, n=n, p=prob, size=size_val)
self._compile_and_check([rng_R, n, prob], [out],
[rng_R_val, n_val, prob_val], RandomFunction)
# normal with vector slice
avg = dvector()
std = dvector()
post_r, out = normal(rng_R, avg=avg, std=std)
avg_val = [1, 2, 3]
std_val = [0.1, 0.2, 0.3]
size_val = (3, )
self._compile_and_check(
[rng_R, avg, std],
[out],
[rng_R_val, avg_val[:-1], std_val[:-1]],
RandomFunction,
)
# normal with explicit size and size implicit in parameters
# cf. NOTE 1
post_r, out = normal(rng_R, avg=avg, std=std, size=size_val)
self._compile_and_check([rng_R, avg, std], [out],
[rng_R_val, avg_val, std_val], RandomFunction)
# multinomial with tensor-3 probabilities
"""