def test_RandomVariable_bcast(): rv = RandomVariable("normal", 0, [0, 0], config.floatX, inplace=True) mu = tensor(config.floatX, [True, False, False]) mu.tag.test_value = np.zeros((1, 2, 3)).astype(config.floatX) sd = tensor(config.floatX, [False, False]) sd.tag.test_value = np.ones((2, 3)).astype(config.floatX) s1 = iscalar() s1.tag.test_value = 1 s2 = iscalar() s2.tag.test_value = 2 s3 = iscalar() s3.tag.test_value = 3 s3 = Assert("testing")(s3, eq(s1, 1)) res = rv(mu, sd, size=(s1, s2, s3)) assert res.broadcastable == (False, ) * 3 size = aet.as_tensor((1, 2, 3), dtype=np.int32).astype(np.int64) res = rv(mu, sd, size=size) assert res.broadcastable == (True, False, False) res = rv(0, 1, size=aet.as_tensor(1, dtype=np.int64)) assert res.broadcastable == (True, )
def make_node(self, x, shp): x = aet.as_tensor_variable(x) shp_orig = shp shp = aet.as_tensor_variable(shp, ndim=1) if not (shp.dtype in int_dtypes or (isinstance(shp, TensorConstant) and shp.data.size == 0)): # It raises an error if shp is not of integer type, # except when shp is constant and empty # (in this case, shp.dtype does not matter anymore). raise TypeError("Shape must be integers", shp, shp.dtype) assert shp.ndim == 1 if isinstance(shp, TensorConstant): bcast = [s == 1 for s in shp.data] return Apply(self, [x, shp], [tensor(x.type.dtype, bcast)]) else: bcasts = [False] * self.ndim shp_list = shp_orig if hasattr(shp_orig, "ndim") and shp_orig.ndim == 0: shp_list = [shp_orig] for index in range(self.ndim): y = shp_list[index] y = aet.as_tensor_variable(y) # Try to see if we can infer that y has a constant value of 1. # If so, that dimension should be broadcastable. try: bcasts[index] = (hasattr(y, "get_scalar_constant_value") and y.get_scalar_constant_value() == 1) except NotScalarConstantError: pass return Apply(self, [x, shp], [tensor(x.type.dtype, bcasts)])
def manual_setup_method(self, dtype="float64"): # This tests can run even when aesara.config.blas__ldflags is empty. self.dtype = dtype self.mode = aesara.compile.get_default_mode().including("fast_run") self.A = tensor(dtype=dtype, broadcastable=(False, False)) self.a = tensor(dtype=dtype, broadcastable=()) self.x = tensor(dtype=dtype, broadcastable=(False, )) self.y = tensor(dtype=dtype, broadcastable=(False, )) self.Aval = np.ones((2, 3), dtype=dtype) self.xval = np.asarray([1, 2], dtype=dtype) self.yval = np.asarray([1.5, 2.7, 3.9], dtype=dtype)
def test_numpy_2d(self): for shp0 in [(2, 3)]: x = tensor(dtype="floatX", broadcastable=(False,) * len(shp0)) a = np.asarray(self.rng.rand(*shp0)).astype(config.floatX) for shp1 in [(6, 7)]: if len(shp0) + len(shp1) == 2: continue y = tensor(dtype="floatX", broadcastable=(False,) * len(shp1)) f = function([x, y], kron(x, y)) b = self.rng.rand(*shp1).astype(config.floatX) out = f(a, b) assert np.allclose(out, np.kron(a, b))
def setup_method(self): self.mode = aesara.compile.get_default_mode() self.mode = self.mode.including("fast_run") self.mode = self.mode.excluding("c_blas") # c_blas trumps scipy Ops dtype = self.dtype = "float64" # optimization isn't dtype-dependent self.A = tensor(dtype=dtype, broadcastable=(False, False)) self.a = tensor(dtype=dtype, broadcastable=()) self.x = tensor(dtype=dtype, broadcastable=(False, )) self.y = tensor(dtype=dtype, broadcastable=(False, )) self.Aval = np.ones((2, 3), dtype=dtype) self.xval = np.asarray([1, 2], dtype=dtype) self.yval = np.asarray([1.5, 2.7, 3.9], dtype=dtype)
def setup_method(self): self.mode = mode_with_gpu dtype = self.dtype = "float32" # optimization isn't dtype-dependent self.A = tensor(dtype=dtype, broadcastable=(False, False)) self.a = tensor(dtype=dtype, broadcastable=()) self.x = tensor(dtype=dtype, broadcastable=(False, )) self.y = tensor(dtype=dtype, broadcastable=(False, )) self.ger_destructive = gpuger_inplace # data on the gpu make the op always inplace self.ger = gpuger_inplace self.gemm = gpugemm_inplace super().setup_method()
def test_argtopk_nd(self, shp, k_, dtype, sorted, idx_dtype): ndim = len(shp) for axis in range(-ndim, ndim): if isinstance(k_, str): k = eval(k_.replace("n", str(shp[axis]))) else: k = k_ if k == 0: continue x = tensor(name="x", broadcastable=(False, ) * len(shp), dtype=dtype) y = argtopk(x, k, axis=axis, sorted=sorted, idx_dtype=idx_dtype) fn = aesara.function([x], y, mode=self.mode) assert any([ isinstance(n.op, self.op_class) for n in fn.maker.fgraph.apply_nodes ]) size = reduce(int.__mul__, shp) xval = gen_unique_vector(size, dtype).reshape(shp) yval = fn(xval) idx = slice(-k, None) if k > 0 else slice(-k) l = axis % ndim r = ndim - l idx = (slice(None), ) * l + (idx, ) + (slice(None), ) * (r - 1) goal = np.argsort(xval, axis=axis)[idx].astype(idx_dtype) assert np.all(np.sort(yval, axis=axis) == np.sort(goal, axis=axis))
def test_advinc_subtensor1_dtype(): # Test the mixed dtype case shp = (3, 4) for dtype1, dtype2 in [ ("float32", "int8"), ("float32", "float64"), ("uint64", "int8"), ("int64", "uint8"), ("float16", "int8"), ("float16", "float64"), ("float16", "float16"), ]: shared = gpuarray_shared_constructor xval = np.arange(np.prod(shp), dtype=dtype1).reshape(shp) + 1 yval = np.empty((2,) + shp[1:], dtype=dtype2) yval[:] = 10 x = shared(xval, name="x") y = tensor(dtype=yval.dtype, broadcastable=(False,) * len(yval.shape), name="y") expr = advanced_inc_subtensor1(x, y, [0, 2]) f = aesara.function([y], expr, mode=mode_with_gpu) assert ( sum( [ isinstance(node.op, GpuAdvancedIncSubtensor1_dev20) for node in f.maker.fgraph.toposort() ] ) == 1 ) rval = f(yval) rep = xval.copy() np.add.at(rep, [[0, 2]], yval) assert np.allclose(rval, rep)
def setup_method(self): # This tests can run even when aesara.config.blas__ldflags is empty. dtype = "float64" self.dtype = dtype self.mode = aesara.compile.get_default_mode().including("fast_run") # matrix self.A = tensor(dtype=dtype, shape=(False, False)) self.Aval = np.ones((2, 3), dtype=dtype) # vector self.x = tensor(dtype=dtype, shape=(False,)) self.y = tensor(dtype=dtype, shape=(False,)) self.xval = np.asarray([1, 2], dtype=dtype) self.yval = np.asarray([1.5, 2.7, 3.9], dtype=dtype) # scalar self.a = tensor(dtype=dtype, shape=())
def test_perform(self): for shp0 in [(2,), (2, 3), (2, 3, 4), (2, 3, 4, 5)]: x = tensor(dtype="floatX", shape=(False,) * len(shp0)) a = np.asarray(self.rng.random(shp0)).astype(config.floatX) for shp1 in [(6,), (6, 7), (6, 7, 8), (6, 7, 8, 9)]: if len(shp0) + len(shp1) == 2: continue y = tensor(dtype="floatX", shape=(False,) * len(shp1)) f = function([x, y], kron(x, y)) b = self.rng.random(shp1).astype(config.floatX) out = f(a, b) # Newer versions of scipy want 4 dimensions at least, # so we have to add a dimension to a and flatten the result. if len(shp0) + len(shp1) == 3: scipy_val = scipy.linalg.kron(a[np.newaxis, :], b).flatten() else: scipy_val = scipy.linalg.kron(a, b) utt.assert_allclose(out, scipy_val)
def make_node(self): return Apply( self, [], [ Variable(Generic()), tensor(self.dtype, shape=self.broadcastable), ], )
def test_local_dimshuffle_subtensor(): dimshuffle_subtensor = out2in(local_dimshuffle_subtensor) x = dtensor4("x") x = aet.patternbroadcast(x, (False, True, False, False)) i = iscalar("i") out = x[:, :, 10:30, ::i].dimshuffle(0, 2, 3) g = FunctionGraph([x, i], [out]) dimshuffle_subtensor(g) topo = g.toposort() assert any([not isinstance(x, DimShuffle) for x in topo]) # Test dimshuffle remove dimensions the subtensor don't "see". x = tensor(broadcastable=(False, True, False), dtype="float64") out = x[i].dimshuffle(1) g = FunctionGraph([x, i], [out]) dimshuffle_subtensor(g) topo = g.toposort() assert any([not isinstance(x, DimShuffle) for x in topo]) # Test dimshuffle remove dimensions the subtensor don't "see" but # have in between dimensions. x = tensor(broadcastable=(False, True, False, True), dtype="float64") out = x[i].dimshuffle(1) f = aesara.function([x, i], out) topo = f.maker.fgraph.toposort() assert any([not isinstance(x, DimShuffle) for x in topo]) assert f(np.random.rand(5, 1, 4, 1), 2).shape == (4, ) # Test a corner case that had Aesara return a bug. x = dtensor4("x") x = aet.patternbroadcast(x, (False, True, False, False)) assert x[:, :, 0:3, ::-1].dimshuffle(0, 2, 3).eval({ x: np.ones((5, 1, 6, 7)) }).shape == (5, 3, 7)
def test_RandomVariable_bcast_specify_shape(): rv = RandomVariable("normal", 0, [0, 0], config.floatX, inplace=True) s1 = aet.as_tensor(1, dtype=np.int64) s2 = iscalar() s2.tag.test_value = 2 s3 = iscalar() s3.tag.test_value = 3 s3 = Assert("testing")(s3, eq(s1, 1)) size = specify_shape(aet.as_tensor([s1, s3, s2, s2, s1]), (5, )) mu = tensor(config.floatX, [False, False, True]) mu.tag.test_value = np.random.normal(size=(2, 2, 1)).astype(config.floatX) std = tensor(config.floatX, [False, True, True]) std.tag.test_value = np.ones((2, 1, 1)).astype(config.floatX) res = rv(mu, std, size=size) assert res.broadcastable == (True, False, False, False, True)
def test_infer_shape(self): a = tensor(config.floatX, [False, True, False]) shape = list(a.shape) out = self.op(a, shape) self._compile_and_check( [a] + shape, [out], [np.random.rand(2, 1, 3).astype(config.floatX), 2, 1, 3], self.op_class, ) a = tensor(config.floatX, [False, True, False]) shape = [iscalar() for i in range(4)] self._compile_and_check( [a] + shape, [self.op(a, shape)], [np.random.rand(2, 1, 3).astype(config.floatX), 6, 2, 5, 3], self.op_class, )
def test_jax_Dimshuffle(): a_at = matrix("a") x = a_at.T x_fg = FunctionGraph([a_at], [x]) compare_jax_and_py(x_fg, [np.c_[[1.0, 2.0], [3.0, 4.0]].astype(config.floatX)]) x = a_at.dimshuffle([0, 1, "x"]) x_fg = FunctionGraph([a_at], [x]) compare_jax_and_py(x_fg, [np.c_[[1.0, 2.0], [3.0, 4.0]].astype(config.floatX)]) a_at = tensor(dtype=config.floatX, shape=[False, True]) x = a_at.dimshuffle((0,)) x_fg = FunctionGraph([a_at], [x]) compare_jax_and_py(x_fg, [np.c_[[1.0, 2.0, 3.0, 4.0]].astype(config.floatX)]) a_at = tensor(dtype=config.floatX, shape=[False, True]) x = at_elemwise.DimShuffle([False, True], (0,))(a_at) x_fg = FunctionGraph([a_at], [x]) compare_jax_and_py(x_fg, [np.c_[[1.0, 2.0, 3.0, 4.0]].astype(config.floatX)])
def numba_funcify_CAReduce(op, node, **kwargs): axes = op.axis if axes is None: axes = list(range(node.inputs[0].ndim)) if hasattr(op, "acc_dtype") and op.acc_dtype is not None: acc_dtype = op.acc_dtype else: acc_dtype = node.outputs[0].type.dtype np_acc_dtype = np.dtype(acc_dtype) scalar_op_identity = np.asarray(op.scalar_op.identity, dtype=np_acc_dtype) acc_dtype = numba.np.numpy_support.from_dtype(np_acc_dtype) scalar_nfunc_spec = op.scalar_op.nfunc_spec # We construct a dummy `Apply` that has the minimum required number of # inputs for the scalar `Op`. Without this, we would get a scalar function # with too few arguments. dummy_node = Apply( op, [tensor(acc_dtype, [False]) for i in range(scalar_nfunc_spec[1])], [tensor(acc_dtype, [False]) for o in range(scalar_nfunc_spec[2])], ) elemwise_fn = numba_funcify_Elemwise(op, dummy_node, use_signature=True, **kwargs) input_name = get_name_for_object(node.inputs[0]) ndim = node.inputs[0].ndim careduce_fn = create_multiaxis_reducer(elemwise_fn, scalar_op_identity, axes, ndim, acc_dtype, input_name=input_name) return numba.njit(careduce_fn)
def test_mvnormal_ShapeFeature(): M_aet = iscalar("M") M_aet.tag.test_value = 2 d_rv = multivariate_normal(aet.ones((M_aet, )), aet.eye(M_aet), size=2) fg = FunctionGraph( [i for i in graph_inputs([d_rv]) if not isinstance(i, Constant)], [d_rv], clone=False, features=[ShapeFeature()], ) s1, s2 = fg.shape_feature.shape_of[d_rv] assert get_test_value(s1) == 2 assert M_aet in graph_inputs([s2]) # Test broadcasted shapes mean = tensor(config.floatX, [True, False]) mean.tag.test_value = np.array([[0, 1, 2]], dtype=config.floatX) test_covar = np.diag(np.array([1, 10, 100], dtype=config.floatX)) test_covar = np.stack([test_covar, test_covar * 10.0]) cov = aet.as_tensor(test_covar).type() cov.tag.test_value = test_covar d_rv = multivariate_normal(mean, cov, size=[2, 3]) fg = FunctionGraph( [i for i in graph_inputs([d_rv]) if not isinstance(i, Constant)], [d_rv], clone=False, features=[ShapeFeature()], ) s1, s2, s3, s4 = fg.shape_feature.shape_of[d_rv] assert s1.get_test_value() == 2 assert s2.get_test_value() == 3 assert s3.get_test_value() == 2 assert s4.get_test_value() == 3
def test_combined_infer_shape(self, shp, k_): ndim = len(shp) for axis in range(-ndim, ndim): if isinstance(k_, str): k = eval(k_.replace("n", str(shp[axis]))) else: k = k_ if k == 0: continue x = tensor(name="x", broadcastable=(False, ) * len(shp), dtype=aesara.config.floatX) yv, yi = topk_and_argtopk(x, k, axis=axis, sorted=False, idx_dtype="int32") size = reduce(int.__mul__, shp) xval = gen_unique_vector(size, aesara.config.floatX).reshape(shp) self._compile_and_check([x], [yv, yi], [xval], TopKOp)
def test_incsub_f16(): shp = (3, 3) shared = gpuarray_shared_constructor xval = np.arange(np.prod(shp), dtype="float16").reshape(shp) + 1 yval = np.empty((2,) + shp[1:], dtype="float16") yval[:] = 2 x = shared(xval, name="x") y = tensor(dtype="float16", broadcastable=(False,) * len(shp), name="y") expr = advanced_inc_subtensor1(x, y, [0, 2]) f = aesara.function([y], expr, mode=mode_with_gpu) assert ( sum( [ isinstance(node.op, GpuAdvancedIncSubtensor1) for node in f.maker.fgraph.toposort() ] ) == 1 ) rval = f(yval) rep = xval.copy() np.add.at(rep, [[0, 2]], yval) assert np.allclose(rval, rep) expr = inc_subtensor(x[1:], y) f = aesara.function([y], expr, mode=mode_with_gpu) assert ( sum( [isinstance(node.op, GpuIncSubtensor) for node in f.maker.fgraph.toposort()] ) == 1 ) rval = f(yval) rep = xval.copy() rep[1:] += yval assert np.allclose(rval, rep)
def test_advinc_subtensor1_vector_scalar(): # Test the case where x is a vector and y a scalar shp = (3,) for dtype1, dtype2 in [ ("float32", "int8"), ("float32", "float64"), ("float16", "int8"), ("float16", "float64"), ("float16", "float16"), ("int8", "int8"), ("int16", "int16"), ]: shared = gpuarray_shared_constructor xval = np.arange(np.prod(shp), dtype=dtype1).reshape(shp) + 1 yval = np.asarray(10, dtype=dtype2) x = shared(xval, name="x") y = tensor(dtype=yval.dtype, broadcastable=(False,) * len(yval.shape), name="y") expr = advanced_inc_subtensor1(x, y, [0, 2]) f = aesara.function([y], expr, mode=mode_with_gpu) assert ( sum( [ isinstance( node.op, (GpuAdvancedIncSubtensor1_dev20, GpuAdvancedIncSubtensor1), ) for node in f.maker.fgraph.toposort() ] ) == 1 ) rval = f(yval) rep = xval.copy() rep[[0, 2]] += yval assert np.allclose(rval, rep)
def test_advinc_subtensor1(): # Test the second case in the opt local_gpu_advanced_incsubtensor1 for shp in [(3, 3), (3, 3, 3)]: shared = gpuarray_shared_constructor xval = np.arange(np.prod(shp), dtype="float32").reshape(shp) + 1 yval = np.empty((2,) + shp[1:], dtype="float32") yval[:] = 10 x = shared(xval, name="x") y = tensor(dtype="float32", broadcastable=(False,) * len(shp), name="y") expr = advanced_inc_subtensor1(x, y, [0, 2]) f = aesara.function([y], expr, mode=mode_with_gpu) assert ( sum( [ isinstance(node.op, GpuAdvancedIncSubtensor1) for node in f.maker.fgraph.toposort() ] ) == 1 ) rval = f(yval) rep = xval.copy() np.add.at(rep, [0, 2], yval) assert np.allclose(rval, rep)
def test_infer_shape(self): image = dtensor4() maxout = dtensor4() gz = dtensor4() rng = np.random.RandomState(utt.fetch_seed()) maxpoolshps = ((1, 1), (2, 2), (3, 3), (2, 3), (3, 2)) image_val = rng.rand(4, 6, 7, 9) out_shapes = [ [ [[4, 6, 7, 9], [4, 6, 7, 9]], [[4, 6, 3, 4], [4, 6, 4, 5]], [[4, 6, 2, 3], [4, 6, 3, 3]], [[4, 6, 3, 3], [4, 6, 4, 3]], [[4, 6, 2, 4], [4, 6, 3, 5]], ], [ [None, None], [[4, 6, 4, 5], None], [[4, 6, 3, 3], None], [[4, 6, 4, 3], None], [[4, 6, 3, 5], None], ], [ [None, None], [None, None], [[4, 6, 3, 4], None], [[4, 6, 4, 4], None], [None, None], ], ] for i, maxpoolshp in enumerate(maxpoolshps): for j, ignore_border in enumerate([True, False]): for k, pad in enumerate([(0, 0), (1, 1), (1, 2)]): if out_shapes[k][i][j] is None: continue # checking shapes generated by Pool self._compile_and_check( [image], [ Pool(ignore_border=ignore_border)( image, maxpoolshp, pad=pad) ], [image_val], Pool, ) # checking shapes generated by MaxPoolGrad maxout_val = rng.rand(*out_shapes[k][i][j]) gz_val = rng.rand(*out_shapes[k][i][j]) self._compile_and_check( [image, maxout, gz], [ MaxPoolGrad(ignore_border=ignore_border)( image, maxout, gz, maxpoolshp, pad=pad) ], [image_val, maxout_val, gz_val], MaxPoolGrad, warn=False, ) # checking with broadcastable input image = tensor(dtype="float64", broadcastable=(False, False, True, True)) image_val = rng.rand(4, 6, 1, 1) self._compile_and_check( [image], [Pool(ignore_border=True)(image, (2, 2), pad=(0, 0))], [image_val], Pool, )
def test_static_shape(self): x = tensor(np.float64, shape=(1, 2), name="x") y = x.dimshuffle([0, 1, "x"]) assert y.type.shape == (1, 2, 1)
def test_broadcast_params(): ndims_params = [0, 0] mean = np.array([0, 1, 2]) cov = np.array(1e-6) params = [mean, cov] res = broadcast_params(params, ndims_params) assert np.array_equal(res[0], mean) assert np.array_equal(res[1], np.broadcast_to(cov, (3, ))) ndims_params = [1, 2] mean = np.r_[1, 2, 3] cov = np.stack([np.eye(3) * 1e-5, np.eye(3) * 1e-4]) params = [mean, cov] res = broadcast_params(params, ndims_params) assert np.array_equal(res[0], np.broadcast_to(mean, (2, 3))) assert np.array_equal(res[1], cov) mean = np.stack([np.r_[0, 0, 0], np.r_[1, 1, 1]]) cov = np.arange(3 * 3).reshape((3, 3)) params = [mean, cov] res = broadcast_params(params, ndims_params) assert np.array_equal(res[0], mean) assert np.array_equal(res[1], np.broadcast_to(cov, (2, 3, 3))) mean = np.stack([np.r_[0, 0, 0], np.r_[1, 1, 1]]) cov = np.stack([ np.arange(3 * 3).reshape((3, 3)), np.arange(3 * 3).reshape((3, 3)) * 10 ]) params = [mean, cov] res = broadcast_params(params, ndims_params) assert np.array_equal(res[0], mean) assert np.array_equal(res[1], cov) mean = np.array([[1, 2, 3]]) cov = np.stack([np.eye(3) * 1e-5, np.eye(3) * 1e-4]) params = [mean, cov] res = broadcast_params(params, ndims_params) assert np.array_equal(res[0], np.array([[1, 2, 3], [1, 2, 3]])) assert np.array_equal(res[1], cov) mean = np.array([[0], [10], [100]]) cov = np.diag(np.array([1e-6])) params = [mean, cov] res = broadcast_params(params, ndims_params) assert np.array_equal(res[0], mean) assert np.array_equal(res[1], np.broadcast_to(cov, (3, 1, 1))) # Try it in Aesara with config.change_flags(compute_test_value="raise"): mean = tensor(config.floatX, [False, True]) mean.tag.test_value = np.array([[0], [10], [100]], dtype=config.floatX) cov = matrix() cov.tag.test_value = np.diag(np.array([1e-6], dtype=config.floatX)) params = [mean, cov] res = broadcast_params(params, ndims_params) assert np.array_equal(res[0].get_test_value(), mean.get_test_value()) assert np.array_equal(res[1].get_test_value(), np.broadcast_to(cov.get_test_value(), (3, 1, 1)))
def make_node(self, path): if isinstance(path, str): path = Constant(Generic(), path) return Apply(self, [path], [tensor(self.dtype, shape=self.broadcastable)])
def make_node(self, request, data): return Apply( self, [request, data], [tensor(data.dtype, shape=data.broadcastable)], )
def test_RandomVariable_basics(): str_res = str( RandomVariable( "normal", 0, [0, 0], config.floatX, inplace=True, )) assert str_res == "normal_rv" # `ndims_params` should be a `Sequence` type with raises(TypeError, match="^Parameter ndims_params*"): RandomVariable( "normal", 0, 0, config.floatX, inplace=True, ) # `size` should be a `Sequence` type with raises(TypeError, match="^Parameter size*"): RandomVariable( "normal", 0, [0, 0], config.floatX, inplace=True, )(0, 1, size={1, 2}) # No dtype with raises(TypeError, match="^dtype*"): RandomVariable( "normal", 0, [0, 0], inplace=True, )(0, 1) # Confirm that `inplace` works rv = RandomVariable( "normal", 0, [0, 0], "normal", inplace=True, ) assert rv.inplace assert rv.destroy_map == {0: [3]} # A no-params `RandomVariable` rv = RandomVariable(name="test_rv", ndim_supp=0, ndims_params=()) with raises(TypeError): rv.make_node(rng=1) # `RandomVariable._infer_shape` should handle no parameters rv_shape = rv._infer_shape(aet.constant([]), (), []) assert rv_shape.equals(aet.constant([], dtype="int64")) # Integer-specificed `dtype` dtype_1 = all_dtypes[1] rv_node = rv.make_node(None, None, 1) rv_out = rv_node.outputs[1] rv_out.tag.test_value = 1 assert rv_out.dtype == dtype_1 with raises(NullTypeGradError): grad(rv_out, [rv_node.inputs[0]]) rv = RandomVariable("normal", 0, [0, 0], config.floatX, inplace=True) mu = tensor(config.floatX, [True, False, False]) mu.tag.test_value = np.zeros((1, 2, 3)).astype(config.floatX) sd = tensor(config.floatX, [False, False]) sd.tag.test_value = np.ones((2, 3)).astype(config.floatX) s1 = iscalar() s1.tag.test_value = 1 s2 = iscalar() s2.tag.test_value = 2 s3 = iscalar() s3.tag.test_value = 3 s3 = Assert("testing")(s3, eq(s1, 1)) res = rv.compute_bcast([mu, sd], (s1, s2, s3)) assert res == [False] * 3