def test_no_reuse():
x = tt.lvector()
y = tt.lvector()
f = aesara.function([x, y], x + y)
# provide both inputs in the first call
f(np.ones(10, dtype="int64"), np.ones(10, dtype="int64"))
try:
f(np.ones(10))
except TypeError:
return
assert not "should not get here"
def test_binomial_vector(self):
random = RandomStreams(utt.fetch_seed())
n = tensor.lvector()
prob = tensor.vector()
out = random.binomial(n=n, p=prob)
assert out.ndim == 1
f = function([n, prob], out)
n_val = [1, 2, 3]
prob_val = np.asarray([0.1, 0.2, 0.3], dtype=config.floatX)
seed_gen = np.random.RandomState(utt.fetch_seed())
numpy_rng = np.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = f(n_val, prob_val)
numpy_val0 = numpy_rng.binomial(n=n_val, p=prob_val)
assert np.all(val0 == numpy_val0)
# arguments of size (2,)
val1 = f(n_val[:-1], prob_val[:-1])
numpy_val1 = numpy_rng.binomial(n=n_val[:-1], p=prob_val[:-1])
assert np.all(val1 == numpy_val1)
# Specifying the size explicitly
g = function([n, prob], random.binomial(n=n, p=prob, size=(3, )))
val2 = g(n_val, prob_val)
numpy_rng = np.random.RandomState(int(seed_gen.randint(2**30)))
numpy_val2 = numpy_rng.binomial(n=n_val, p=prob_val, size=(3, ))
assert np.all(val2 == numpy_val2)
with pytest.raises(ValueError):
g(n_val[:-1], prob_val[:-1])
def test_bug_2009_06_02_trac_387():
y = tensor.lvector("y")
f = aesara.function([y],
tensor.int_div(
tensor.DimShuffle(y[0].broadcastable, ["x"])(y[0]),
2))
print(f(np.ones(1, dtype="int64") * 3))
def test_binomial_vector(self):
rng_R = random_state_type()
n = tensor.lvector()
prob = tensor.vector()
post_r, out = binomial(rng_R, n=n, p=prob)
assert out.ndim == 1
f = compile.function([rng_R, n, prob], [post_r, out],
accept_inplace=True)
n_val = [1, 2, 3]
prob_val = np.asarray([0.1, 0.2, 0.3], dtype=config.floatX)
rng = np.random.RandomState(utt.fetch_seed())
numpy_rng = np.random.RandomState(utt.fetch_seed())
# Arguments of size (3,)
rng0, val0 = f(rng, n_val, prob_val)
numpy_val0 = numpy_rng.binomial(n=n_val, p=prob_val)
assert np.all(val0 == numpy_val0)
# arguments of size (2,)
rng1, val1 = f(rng0, n_val[:-1], prob_val[:-1])
numpy_val1 = numpy_rng.binomial(n=n_val[:-1], p=prob_val[:-1])
assert np.all(val1 == numpy_val1)
# Specifying the size explicitly
g = compile.function(
[rng_R, n, prob],
binomial(rng_R, n=n, p=prob, size=(3, )),
accept_inplace=True,
)
rng2, val2 = g(rng1, n_val, prob_val)
numpy_val2 = numpy_rng.binomial(n=n_val, p=prob_val, size=(3, ))
assert np.all(val2 == numpy_val2)
with pytest.raises(ValueError):
g(rng2, n_val[:-1], prob_val[:-1])
def test_GpuCrossentropySoftmaxArgmax1HotWithBias():
# This is basic test for GpuCrossentropySoftmaxArgmax1HotWithBias
# We check that we loop when their is too much threads
n_in = 1000
batch_size = 4097
n_out = 1250
if not isinstance(mode_with_gpu, aesara.compile.DebugMode):
n_in = 4098
n_out = 4099
y = tt.lvector("y")
b = tt.fvector("b")
# we precompute the dot with big shape before to allow the test of
# GpuCrossentropySoftmax1HotWithBiasDx to don't fail with the error
# (the launch timed out and was terminated) on GPU card not
# powerful enough. We need the big shape to check for corner
# case.
dot_result = tt.fmatrix("dot_result")
# Seed numpy.random with config.unittests.rseed
utt.seed_rng()
xx = np.asarray(np.random.rand(batch_size, n_in), dtype=np.float32)
yy = np.ones((batch_size, ), dtype="int32")
b_values = np.zeros((n_out, ), dtype="float32")
W_values = np.asarray(np.random.rand(n_in, n_out), dtype="float32")
dot_value = np.asarray(np.dot(xx, W_values), dtype="float32")
del W_values
p_y_given_x = tt.nnet.softmax(dot_result + b)
y_pred = tt.argmax(p_y_given_x, axis=-1)
loss = -tt.mean(tt.log(p_y_given_x)[tt.arange(y.shape[0]), y])
dW = tt.grad(loss, dot_result)
classify = aesara.function(inputs=[y, b, dot_result],
outputs=[loss, y_pred, dW],
mode=mode_without_gpu)
classify_gpu = aesara.function(inputs=[y, b, dot_result],
outputs=[loss, y_pred, dW],
mode=mode_with_gpu)
assert any([
isinstance(node.op, tt.nnet.CrossentropySoftmaxArgmax1HotWithBias)
for node in classify.maker.fgraph.toposort()
])
assert any([
isinstance(node.op, GpuCrossentropySoftmaxArgmax1HotWithBias)
for node in classify_gpu.maker.fgraph.toposort()
])
out = classify(yy, b_values, dot_value)
gout = classify_gpu(yy, b_values, dot_value)
assert len(out) == len(gout) == 3
utt.assert_allclose(out[0], gout[0])
utt.assert_allclose(out[2], gout[2], atol=3e-6)
utt.assert_allclose(out[1], gout[1])
def test_vector_arguments(self):
rng_R = random_state_type()
low = tensor.vector()
post_r, out = uniform(rng_R, low=low, high=1)
assert out.ndim == 1
f = compile.function([rng_R, low], [post_r, out], accept_inplace=True)
def as_floatX(thing):
return np.asarray(thing, dtype=aesara.config.floatX)
rng_state0 = np.random.RandomState(utt.fetch_seed())
numpy_rng = np.random.RandomState(utt.fetch_seed())
post0, val0 = f(rng_state0, [-5, 0.5, 0, 1])
post1, val1 = f(post0, as_floatX([0.9]))
numpy_val0 = as_floatX(numpy_rng.uniform(low=[-5, 0.5, 0, 1], high=1))
numpy_val1 = as_floatX(numpy_rng.uniform(low=as_floatX([0.9]), high=1))
assert np.all(val0 == numpy_val0)
assert np.all(val1 == numpy_val1)
high = tensor.vector()
post_rb, outb = uniform(rng_R, low=low, high=high)
assert outb.ndim == 1
fb = compile.function([rng_R, low, high], [post_rb, outb],
accept_inplace=True)
post0b, val0b = fb(post1, [-4.0, -2], [-1, 0])
post1b, val1b = fb(post0b, [-4.0], [-1])
numpy_val0b = as_floatX(numpy_rng.uniform(low=[-4.0, -2], high=[-1,
0]))
numpy_val1b = as_floatX(numpy_rng.uniform(low=[-4.0], high=[-1]))
assert np.all(val0b == numpy_val0b)
assert np.all(val1b == numpy_val1b)
with pytest.raises(ValueError):
fb(post1b, [-4.0, -2], [-1, 0, 1])
# TODO: do we want that?
# with pytest.raises(ValueError):
# fb(post1b, [-4., -2], [-1])
size = tensor.lvector()
post_rc, outc = uniform(rng_R, low=low, high=high, size=size, ndim=1)
fc = compile.function([rng_R, low, high, size], [post_rc, outc],
accept_inplace=True)
post0c, val0c = fc(post1b, [-4.0, -2], [-1, 0], [2])
post1c, val1c = fc(post0c, [-4.0], [-1], [1])
numpy_val0c = as_floatX(numpy_rng.uniform(low=[-4.0, -2], high=[-1,
0]))
numpy_val1c = as_floatX(numpy_rng.uniform(low=[-4.0], high=[-1]))
assert np.all(val0c == numpy_val0c)
assert np.all(val1c == numpy_val1c)
with pytest.raises(ValueError):
fc(post1c, [-4.0, -2], [-1, 0], [1, 2])
with pytest.raises(ValueError):
fc(post1c, [-4.0, -2], [-1, 0], [2, 1])
with pytest.raises(ValueError):
fc(post1c, [-4.0, -2], [-1, 0], [1])
with pytest.raises(ValueError):
fc(post1c, [-4.0, -2], [-1], [1])
def test_random_integers_vector(self):
rng_R = random_state_type()
low = tensor.lvector()
high = tensor.lvector()
post_r, out = random_integers(rng_R, low=low, high=high)
assert out.ndim == 1
f = compile.function([rng_R, low, high], [post_r, out],
accept_inplace=True)
low_val = [100, 200, 300]
high_val = [110, 220, 330]
rng = np.random.RandomState(utt.fetch_seed())
numpy_rng = np.random.RandomState(utt.fetch_seed())
# Arguments of size (3,)
rng0, val0 = f(rng, low_val, high_val)
numpy_val0 = np.asarray([
numpy_rng.randint(low=lv, high=hv + 1)
for lv, hv in zip(low_val, high_val)
])
assert np.all(val0 == numpy_val0)
# arguments of size (2,)
rng1, val1 = f(rng0, low_val[:-1], high_val[:-1])
numpy_val1 = np.asarray([
numpy_rng.randint(low=lv, high=hv + 1)
for lv, hv in zip(low_val[:-1], high_val[:-1])
])
assert np.all(val1 == numpy_val1)
# Specifying the size explicitly
g = compile.function(
[rng_R, low, high],
random_integers(rng_R, low=low, high=high, size=(3, )),
accept_inplace=True,
)
rng2, val2 = g(rng1, low_val, high_val)
numpy_val2 = np.asarray([
numpy_rng.randint(low=lv, high=hv + 1)
for lv, hv in zip(low_val, high_val)
])
assert np.all(val2 == numpy_val2)
with pytest.raises(ValueError):
g(rng2, low_val[:-1], high_val[:-1])
def test_vector_arguments(self):
random = RandomStreams(utt.fetch_seed())
low = tensor.dvector()
out = random.uniform(low=low, high=1)
assert out.ndim == 1
f = function([low], out)
seed_gen = np.random.RandomState(utt.fetch_seed())
numpy_rng = np.random.RandomState(int(seed_gen.randint(2**30)))
val0 = f([-5, 0.5, 0, 1])
val1 = f([0.9])
numpy_val0 = numpy_rng.uniform(low=[-5, 0.5, 0, 1], high=1)
numpy_val1 = numpy_rng.uniform(low=[0.9], high=1)
assert np.all(val0 == numpy_val0)
assert np.all(val1 == numpy_val1)
high = tensor.vector()
outb = random.uniform(low=low, high=high)
assert outb.ndim == 1
fb = function([low, high], outb)
numpy_rng = np.random.RandomState(int(seed_gen.randint(2**30)))
val0b = fb([-4.0, -2], [-1, 0])
val1b = fb([-4.0], [-1])
numpy_val0b = numpy_rng.uniform(low=[-4.0, -2], high=[-1, 0])
numpy_val1b = numpy_rng.uniform(low=[-4.0], high=[-1])
assert np.all(val0b == numpy_val0b)
assert np.all(val1b == numpy_val1b)
with pytest.raises(ValueError):
fb([-4.0, -2], [-1, 0, 1])
# TODO: do we want that?
# with pytest.raises(ValueError):
# fb([-4., -2], [-1])
size = tensor.lvector()
outc = random.uniform(low=low, high=high, size=size, ndim=1)
fc = function([low, high, size], outc)
numpy_rng = np.random.RandomState(int(seed_gen.randint(2**30)))
val0c = fc([-4.0, -2], [-1, 0], [2])
val1c = fc([-4.0], [-1], [1])
numpy_val0c = numpy_rng.uniform(low=[-4.0, -2], high=[-1, 0])
numpy_val1c = numpy_rng.uniform(low=[-4.0], high=[-1])
assert np.all(val0c == numpy_val0c)
assert np.all(val1c == numpy_val1c)
with pytest.raises(ValueError):
fc([-4.0, -2], [-1, 0], [1, 2])
with pytest.raises(ValueError):
fc([-4.0, -2], [-1, 0], [2, 1])
with pytest.raises(ValueError):
fc([-4.0, -2], [-1, 0], [1])
with pytest.raises(ValueError):
fc([-4.0, -2], [-1], [1])
def test_symbolic_shape(self):
random = RandomStreams(utt.fetch_seed())
shape = tensor.lvector()
f = function([shape], random.uniform(size=shape, ndim=2))
assert f([2, 3]).shape == (2, 3)
assert f([4, 8]).shape == (4, 8)
with pytest.raises(ValueError):
f([4])
with pytest.raises(ValueError):
f([4, 3, 4, 5])
def test_random_integers_vector(self):
random = RandomStreams(utt.fetch_seed())
low = tensor.lvector()
high = tensor.lvector()
out = random.random_integers(low=low, high=high)
assert out.ndim == 1
f = function([low, high], out)
low_val = [100, 200, 300]
high_val = [110, 220, 330]
seed_gen = np.random.RandomState(utt.fetch_seed())
numpy_rng = np.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = f(low_val, high_val)
numpy_val0 = np.asarray([
numpy_rng.randint(low=lv, high=hv + 1)
for lv, hv in zip(low_val, high_val)
])
assert np.all(val0 == numpy_val0)
# arguments of size (2,)
val1 = f(low_val[:-1], high_val[:-1])
numpy_val1 = np.asarray([
numpy_rng.randint(low=lv, high=hv + 1)
for lv, hv in zip(low_val[:-1], high_val[:-1])
])
assert np.all(val1 == numpy_val1)
# Specifying the size explicitly
g = function([low, high],
random.random_integers(low=low, high=high, size=(3, )))
val2 = g(low_val, high_val)
numpy_rng = np.random.RandomState(int(seed_gen.randint(2**30)))
numpy_val2 = np.asarray([
numpy_rng.randint(low=lv, high=hv + 1)
for lv, hv in zip(low_val, high_val)
])
assert np.all(val2 == numpy_val2)
with pytest.raises(ValueError):
g(low_val[:-1], high_val[:-1])
def test_symbolic_shape(self):
rng_R = random_state_type()
shape = tensor.lvector()
post_r, out = uniform(rng_R, shape, ndim=2)
f = compile.function([rng_R, shape], out)
rng_state0 = np.random.RandomState(utt.fetch_seed())
assert f(rng_state0, [2, 3]).shape == (2, 3)
assert f(rng_state0, [4, 8]).shape == (4, 8)
with pytest.raises(ValueError):
f(rng_state0, [4])
with pytest.raises(ValueError):
f(rng_state0, [4, 3, 4, 5])
def test_multinomial_vector(self):
rng_R = random_state_type()
n = tensor.lvector()
pvals = tensor.matrix()
post_r, out = multinomial(rng_R, n=n, pvals=pvals)
assert out.ndim == 2
f = compile.function([rng_R, n, pvals], [post_r, out],
accept_inplace=True)
n_val = [1, 2, 3]
pvals_val = [[0.1, 0.9], [0.2, 0.8], [0.3, 0.7]]
pvals_val = np.asarray(pvals_val, dtype=config.floatX)
rng = np.random.RandomState(utt.fetch_seed())
numpy_rng = np.random.RandomState(utt.fetch_seed())
# Arguments of size (3,)
rng0, val0 = f(rng, n_val, pvals_val)
numpy_val0 = np.asarray([
numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val, pvals_val)
])
assert np.all(val0 == numpy_val0)
# arguments of size (2,)
rng1, val1 = f(rng0, n_val[:-1], pvals_val[:-1])
numpy_val1 = np.asarray([
numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val[:-1], pvals_val[:-1])
])
assert np.all(val1 == numpy_val1)
# Specifying the size explicitly
g = compile.function(
[rng_R, n, pvals],
multinomial(rng_R, n=n, pvals=pvals, size=(3, )),
accept_inplace=True,
)
rng2, val2 = g(rng1, n_val, pvals_val)
numpy_val2 = np.asarray([
numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val, pvals_val)
])
assert np.all(val2 == numpy_val2)
with pytest.raises(ValueError):
g(rng2, n_val[:-1], pvals_val[:-1])
def test_op(self):
n = tensor.lscalar()
f = aesara.function([self.p, n], multinomial(n, self.p))
_n = 5
tested = f(self._p, _n)
assert tested.shape == self._p.shape
assert np.allclose(np.floor(tested.todense()), tested.todense())
assert tested[2, 1] == _n
n = tensor.lvector()
f = aesara.function([self.p, n], multinomial(n, self.p))
_n = np.asarray([1, 2, 3, 4], dtype="int64")
tested = f(self._p, _n)
assert tested.shape == self._p.shape
assert np.allclose(np.floor(tested.todense()), tested.todense())
assert tested[2, 1] == _n[2]
def test_multinomial_vector(self):
random = RandomStreams(utt.fetch_seed())
n = tensor.lvector()
pvals = tensor.matrix()
out = random.multinomial(n=n, pvals=pvals)
assert out.ndim == 2
f = function([n, pvals], out)
n_val = [1, 2, 3]
pvals_val = [[0.1, 0.9], [0.2, 0.8], [0.3, 0.7]]
pvals_val = np.asarray(pvals_val, dtype=config.floatX)
seed_gen = np.random.RandomState(utt.fetch_seed())
numpy_rng = np.random.RandomState(int(seed_gen.randint(2**30)))
# Arguments of size (3,)
val0 = f(n_val, pvals_val)
numpy_val0 = np.asarray([
numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val, pvals_val)
])
assert np.all(val0 == numpy_val0)
# arguments of size (2,)
val1 = f(n_val[:-1], pvals_val[:-1])
numpy_val1 = np.asarray([
numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val[:-1], pvals_val[:-1])
])
assert np.all(val1 == numpy_val1)
# Specifying the size explicitly
g = function([n, pvals],
random.multinomial(n=n, pvals=pvals, size=(3, )))
val2 = g(n_val, pvals_val)
numpy_rng = np.random.RandomState(int(seed_gen.randint(2**30)))
numpy_val2 = np.asarray([
numpy_rng.multinomial(n=nv, pvals=pv)
for nv, pv in zip(n_val, pvals_val)
])
assert np.all(val2 == numpy_val2)
with pytest.raises(ValueError):
g(n_val[:-1], pvals_val[:-1])
class TestBinomial(utt.InferShapeTester):
n = tensor.scalar(dtype="int64")
p = tensor.scalar()
shape = tensor.lvector()
_n = 5
_p = 0.25
_shape = np.asarray([3, 5], dtype="int64")
inputs = [n, p, shape]
_inputs = [_n, _p, _shape]
def setup_method(self):
super().setup_method()
self.op_class = Binomial
def test_op(self):
for sp_format in sparse.sparse_formats:
for o_type in sparse.float_dtypes:
f = aesara.function(self.inputs,
Binomial(sp_format, o_type)(*self.inputs))
tested = f(*self._inputs)
assert tested.shape == tuple(self._shape)
assert tested.format == sp_format
assert tested.dtype == o_type
assert np.allclose(np.floor(tested.todense()),
tested.todense())
def test_infer_shape(self):
for sp_format in sparse.sparse_formats:
for o_type in sparse.float_dtypes:
self._compile_and_check(
self.inputs,
[Binomial(sp_format, o_type)(*self.inputs)],
self._inputs,
self.op_class,
)
