def test_ifelse_lazy_c(): a = scalar() b = generic() c = generic() notimpl = NotImplementedOp() cloops = [True, False] if aesara.config.cxx == "": cloops = [False] for use_cloop in cloops: for lazy in [True, None]: linker = aesara.link.vm.VMLinker(use_cloop=use_cloop, lazy=lazy) f = function( [a, b, c], ifelse(a, notimpl(b), c), mode=Mode(linker=linker, optimizer="fast_run"), ) with pytest.raises(NotImplementedOpException): f(1, "a", "b") assert f(0, "a", "b") == "b"
def test_grad_lazy_if(self): # Tests that we can compute the gradients through lazy if x = vector("x", dtype=self.dtype) y = vector("y", dtype=self.dtype) c = iscalar("c") z = ifelse(c, x, y) gx, gy = aesara.grad(z.sum(), [x, y]) f = function( [c, x, y], [self.cast_output(gx), self.cast_output(gy)], mode=self.mode ) # There is only 2 of the 3 ifelse that are moved on the GPU. # The one that stay on the CPU is for the shape. self.assertFunctionContains(f, self.get_ifelse(1), min=2, max=3) rng = np.random.RandomState(utt.fetch_seed()) xlen = rng.randint(200) ylen = rng.randint(200) vx = np.asarray(rng.uniform(size=(xlen,)), self.dtype) vy = np.asarray(rng.uniform(size=(ylen,)), self.dtype) gx0, gy0 = f(1, vx, vy) assert np.allclose(gx0.shape, vx.shape) assert np.allclose(gy0.shape, vy.shape) assert np.all(np.asarray(gx0) == 1.0) assert np.all(np.asarray(gy0) == 0.0) gx0, gy0 = f(0, vx, vy) assert np.allclose(gx0.shape, vx.shape) assert np.allclose(gy0.shape, vy.shape) assert np.all(np.asarray(gx0) == 0.0) assert np.all(np.asarray(gy0) == 1.0)
def test_grad_test_values(self): # Regression test for test values of `ifelse` gradient. with aesara.config.change_flags(compute_test_value="raise"): x = scalar("x") x.tag.test_value = 1 # Used to crash due to undefined test value. aesara.grad(ifelse(0, x, x), x)
def test_multiple_out_grad(self): # Tests that we can compute the gradients through lazy if x1 = vector("x1") x2 = vector("x2") y1 = vector("y1") y2 = vector("y2") c = iscalar("c") z = ifelse(c, (x1, x2), (y1, y2)) grads = aesara.grad(z[0].sum() + z[1].sum(), [x1, x2, y1, y2]) f = function([c, x1, x2, y1, y2], grads) rng = np.random.RandomState(utt.fetch_seed()) lens = [rng.randint(200) for i in range(4)] values = [ np.asarray(rng.uniform(size=(l,)), aesara.config.floatX) for l in lens ] outs_1 = f(1, *values) assert all([x.shape[0] == y for x, y in zip(outs_1, lens)]) assert np.all(outs_1[0] == 1.0) assert np.all(outs_1[1] == 1.0) assert np.all(outs_1[2] == 0.0) assert np.all(outs_1[3] == 0.0) outs_0 = f(0, *values) assert all([x.shape[0] == y for x, y in zip(outs_1, lens)]) assert np.all(outs_0[0] == 0.0) assert np.all(outs_0[1] == 0.0) assert np.all(outs_0[2] == 1.0) assert np.all(outs_0[3] == 1.0)
def test_multiple_out(self): x1 = vector("x1", dtype=self.dtype) x2 = vector("x2", dtype=self.dtype) y1 = vector("y1", dtype=self.dtype) y2 = vector("y2", dtype=self.dtype) c = iscalar("c") z = ifelse(c, (x1, x2), (y1, y2)) f = function([c, x1, x2, y1, y2], z, mode=self.mode) self.assertFunctionContains1(f, self.get_ifelse(2)) ifnode = [x for x in f.maker.fgraph.toposort() if isinstance(x.op, IfElse)][0] assert len(ifnode.outputs) == 2 rng = np.random.RandomState(utt.fetch_seed()) x1len = rng.randint(200) x2len = rng.randint(200) y1len = rng.randint(200) y2len = rng.randint(200) vx1 = np.asarray(rng.uniform(size=(x1len,)), self.dtype) vx2 = np.asarray(rng.uniform(size=(x2len,)), self.dtype) vy1 = np.asarray(rng.uniform(size=(y1len,)), self.dtype) vy2 = np.asarray(rng.uniform(size=(y2len,)), self.dtype) ovx1, ovx2 = f(1, vx1, vx2, vy1, vy2) ovy1, ovy2 = f(0, vx1, vx2, vy1, vy2) assert np.allclose(vx1, ovx1) assert np.allclose(vy1, ovy1) assert np.allclose(vx2, ovx2) assert np.allclose(vy2, ovy2)
def test_mixed_dtype(self): x1 = vector("x1", dtype="int32") x2 = vector("x2", dtype=self.dtype) y1 = vector("y1", dtype="int32") y2 = vector("y2", dtype=self.dtype) c = iscalar("c") f = function([c, x1, x2, y1, y2], ifelse(c, (x1, x2), (y1, y2)), mode=self.mode) self.assertFunctionContains1(f, self.get_ifelse(2)) rng = np.random.RandomState(utt.fetch_seed()) xlen = rng.randint(200) ylen = rng.randint(200) vx1 = np.asarray(rng.uniform(size=(xlen,)) * 3, "int32") vx2 = np.asarray(rng.uniform(size=(xlen,)), self.dtype) vy1 = np.asarray(rng.uniform(size=(ylen,)) * 3, "int32") vy2 = np.asarray(rng.uniform(size=(ylen,)), self.dtype) o1, o2 = f(1, vx1, vx2, vy1, vy2) assert np.allclose(vx1, o1) assert np.allclose(vx2, o2) o1, o2 = f(0, vx1, vx2, vy1, vy2) assert np.allclose(vy1, o1) assert np.allclose(vy2, o2)
def test_grad_cast_input(self): x = vector("x", dtype=self.dtype) y = vector("y", dtype=self.dtype) c = iscalar("c") z = ifelse(c, self.cast_output(x), self.cast_output(y)) gx, gy = aesara.grad(z.sum(), [x, y]) function([c, x, y], [gx, gy], mode=self.mode)
def test_str(self): x = vector("x", dtype=self.dtype) y = vector("y", dtype=self.dtype) c = iscalar("c") res = ifelse(c, x, y) assert str(res.owner).startswith("if{}") res.owner.op.name = "name" res.owner.op.as_view = True assert str(res.owner).startswith("if{name,inplace}")
def test_remove_useless_inputs1(self): x = vector("x") y = vector("y") c = iscalar("c") z = ifelse(c, (x, x), (y, y)) f = function([c, x, y], z) ifnode = [n for n in f.maker.fgraph.toposort() if isinstance(n.op, IfElse)][0] assert len(ifnode.inputs) == 3
def test_grad_cast_input(self): # Tests the gradient when both inputs are on the GPU. x = vector("x", dtype=self.dtype) y = vector("y", dtype=self.dtype) c = iscalar("c") z = ifelse(c, self.cast_output(x), self.cast_output(y)) gx, gy = aesara.grad(z.sum(), [x, y]) function([c, x, y], [gx, gy], mode=self.mode)
def test_lazy_if_on_generics(self): x = generic() y = generic() c = iscalar("c") f = function([c, x, y], ifelse(c, x, y)) vx = ["testX"] vy = ["testY"] assert f(1, vx, vy) == vx assert f(0, vx, vy) == vy
def test_remove_useless_inputs2(self): x1 = vector("x1") x2 = vector("x2") y1 = vector("y1") y2 = vector("y2") c = iscalar("c") z = ifelse(c, (x1, x1, x1, x2, x2), (y1, y1, y2, y2, y2)) f = function([c, x1, x2, y1, y2], z) ifnode = [x for x in f.maker.fgraph.toposort() if isinstance(x.op, IfElse)][0] assert len(ifnode.outputs) == 3
def test_pushout3(self): x1 = scalar("x1") y1 = scalar("x2") y2 = scalar("y2") c = iscalar("c") two = np.asarray(2, dtype=aesara.config.floatX) x, y = ifelse(c, (x1, y1), (two, y2), name="f1") o3 = np.asarray(0.3, dtype=aesara.config.floatX) o2 = np.asarray(0.2, dtype=aesara.config.floatX) z = ifelse(c, o3, o2, name="f2") out = x * z * y f = function([x1, y1, y2, c], out, allow_input_downcast=True) assert isinstance(f.maker.fgraph.toposort()[-1].op, IfElse) rng = np.random.RandomState(utt.fetch_seed()) vx1 = rng.uniform() vy1 = rng.uniform() vy2 = rng.uniform() assert np.allclose(f(vx1, vy1, vy2, 1), vx1 * vy1 * 0.3) assert np.allclose(f(vx1, vy1, vy2, 0), 2 * vy2 * 0.2)
def test_grad_test_values(self): # Regression test for test values of `ifelse` gradient. backup = aesara.config.compute_test_value aesara.config.compute_test_value = "raise" try: x = tensor.scalar("x") x.tag.test_value = 1 # Used to crash due to undefined test value. tensor.grad(ifelse(0, x, x), x) finally: aesara.config.compute_test_value = backup
def test_grad_int_value(self): w = aesara.shared(np.random.rand(10)) b = aesara.shared(np.random.rand()) params = [w, b] x = vector() y = scalar() score = w.dot(x) + b correct = score * y > 0 loss = ifelse(correct, 0, 1) [(param, param - 0.5 * aesara.grad(cost=loss, wrt=param)) for param in params]
def test_pushout1(self): x1 = scalar("x1") x2 = scalar("x2") y1 = scalar("y1") y2 = scalar("y2") w1 = scalar("w1") w2 = scalar("w2") c = iscalar("c") x, y = ifelse(c, (x1, y1), (x2, y2), name="f1") z = ifelse(c, w1, w2, name="f2") out = x * z * y f = function([x1, x2, y1, y2, w1, w2, c], out, allow_input_downcast=True) assert isinstance(f.maker.fgraph.toposort()[-1].op, IfElse) rng = np.random.RandomState(utt.fetch_seed()) vx1 = rng.uniform() vx2 = rng.uniform() vy1 = rng.uniform() vy2 = rng.uniform() vw1 = rng.uniform() vw2 = rng.uniform() assert np.allclose(f(vx1, vx2, vy1, vy2, vw1, vw2, 1), vx1 * vy1 * vw1) assert np.allclose(f(vx1, vx2, vy1, vy2, vw1, vw2, 0), vx2 * vy2 * vw2)
def test_lazy_if(self): # Tests that lazy if works .. even if the two results have different # shapes but the same type (i.e. both vectors, or matrices or # whatnot of same dtype) x = vector("x", dtype=self.dtype) y = vector("y", dtype=self.dtype) c = iscalar("c") f = function([c, x, y], ifelse(c, x, y), mode=self.mode) self.assertFunctionContains1(f, self.get_ifelse(1)) rng = np.random.RandomState(utt.fetch_seed()) xlen = rng.randint(200) ylen = rng.randint(200) vx = np.asarray(rng.uniform(size=(xlen,)), self.dtype) vy = np.asarray(rng.uniform(size=(ylen,)), self.dtype) assert np.allclose(vx, f(1, vx, vy)) assert np.allclose(vy, f(0, vx, vy))
def test_multiple_out_crash(self): # This test failed up to commit 2faeb62c38 p0 = self.shared(np.asarray(np.random.random([4, 8]), dtype=self.dtype)) p1 = self.shared(np.asarray(np.random.random(8), dtype=self.dtype)) p2 = self.shared(np.asarray(np.random.random([8, 3]), dtype=self.dtype)) p3 = self.shared(np.asarray(np.random.random(3), dtype=self.dtype)) p = [p0, p1, p2, p3] # in my code these vars are the result of applying scan ften0 = tensor3("ft0", dtype=self.dtype) fmat1 = matrix("fm1", dtype=self.dtype) ften2 = tensor3("ft2", dtype=self.dtype) fmat3 = matrix("fm3", dtype=self.dtype) # then I keep only the last iteration fsub0 = ften0[-1] fsub1 = fmat1[-1] fsub2 = ften2[-1] fsub3 = fmat3[-1] fsub = [fsub0, fsub1, fsub2, fsub3] acc = at.constant(1, "int8") >= 0 new_positions = ifelse(acc, fsub, p) new_updates = [(p[0], new_positions[0])] f = function([ften0, fmat1, ften2, fmat3], [], updates=new_updates, mode=self.mode) self.assertFunctionContains1(f, self.get_ifelse(4)) i1 = np.asarray(np.random.random([19, 4, 8]), dtype=self.dtype) i2 = np.asarray(np.random.random([19, 8]), dtype=self.dtype) i3 = np.asarray(np.random.random([19, 8, 3]), dtype=self.dtype) i4 = np.asarray(np.random.random([19, 3]), dtype=self.dtype) f(i1, i2, i3, i4)
def test_sparse_tensor_error(self): pytest.importorskip("scipy", minversion="0.7.0") import aesara.sparse rng = np.random.RandomState(utt.fetch_seed()) data = rng.rand(2, 3).astype(self.dtype) x = self.shared(data) y = aesara.sparse.matrix("csc", dtype=self.dtype, name="y") z = aesara.sparse.matrix("csr", dtype=self.dtype, name="z") cond = iscalar("cond") with pytest.raises(TypeError): ifelse(cond, x, y) with pytest.raises(TypeError): ifelse(cond, y, x) with pytest.raises(TypeError): ifelse(cond, x, z) with pytest.raises(TypeError): ifelse(cond, z, x) with pytest.raises(TypeError): ifelse(cond, y, z) with pytest.raises(TypeError): ifelse(cond, z, y)