def random_ranged(min, max, shape, rng=None): if rng is None: rng = np.random.default_rng(seed=utt.fetch_seed()) return np.asarray(rng.random(shape) * (max - min) + min, dtype=config.floatX)
def test_permutation_helper(self): # Test that raw_random.permutation_helper generates the same # results as numpy, # and that the 'ndim_added' keyword behaves correctly. # permutation_helper needs "ndim_added=1", because its output # is one dimension more than its "shape" argument (and there's # no way to determine that automatically). # Check the working case, over two calls to see if the random # state is correctly updated. rf = RandomFunction(permutation_helper, tensor.imatrix, 8, ndim_added=1) rng_R = random_state_type() post_r, out = rf(rng_R, (7, ), 8) f = function( [ 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_rng.permutation outputs one vector at a time, # so we call it iteratively to generate all the samples. numpy_val0 = np.asarray([numpy_rng.permutation(8) for i in range(7)]) numpy_val1 = np.asarray([numpy_rng.permutation(8) for i in range(7)]) assert np.all(val0 == numpy_val0) assert np.all(val1 == numpy_val1) # This call lacks "ndim_added=1", so ndim_added defaults to 0. # A ValueError should be raised. rf0 = RandomFunction(permutation_helper, tensor.imatrix, 8) post_r0, out0 = rf0(rng_R, (7, ), 8) f0 = function( [ In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=post_r0, mutable=True, ) ], [out0], accept_inplace=True, ) with pytest.raises(ValueError): f0() # Here, ndim_added is 2 instead of 1. A ValueError should be raised. rf2 = RandomFunction(permutation_helper, tensor.imatrix, 8, ndim_added=2) post_r2, out2 = rf2(rng_R, (7, ), 8) f2 = function( [ In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=post_r2, mutable=True, ) ], [out2], accept_inplace=True, ) with pytest.raises(ValueError): f2()
def test_det_grad(): rng = np.random.RandomState(utt.fetch_seed()) r = rng.randn(5, 5).astype(config.floatX) tensor.verify_grad(det, [r], rng=np.random)
def test_specify_shape_partial(self): dtype = self.dtype if dtype is None: dtype = aesara.config.floatX rng = np.random.default_rng(utt.fetch_seed()) x1_1 = np.asarray(rng.uniform(1, 2, [4, 2]), dtype=dtype) x1_1 = self.cast_value(x1_1) x1_2 = np.asarray(rng.uniform(1, 2, [4, 2]), dtype=dtype) x1_2 = self.cast_value(x1_2) x2 = np.asarray(rng.uniform(1, 2, [5, 2]), dtype=dtype) x2 = self.cast_value(x2) # Test that we can replace with values of the same shape x1_shared = self.shared_constructor(x1_1) x1_specify_shape = specify_shape( x1_shared, (aet.as_tensor_variable(x1_1.shape[0]), x1_shared.shape[1]), ) x1_shared.set_value(x1_2) assert np.allclose(self.ref_fct(x1_shared.get_value(borrow=True)), self.ref_fct(x1_2)) shape_op_fct = aesara.function([], x1_shared.shape) topo = shape_op_fct.maker.fgraph.toposort() shape_op_fct() if aesara.config.mode != "FAST_COMPILE": assert len(topo) == 3 assert isinstance(topo[0].op, Shape_i) assert isinstance(topo[1].op, Shape_i) assert isinstance(topo[2].op, MakeVector) # Test that we forward the input specify_shape_fct = aesara.function([], x1_specify_shape) specify_shape_fct() # aesara.printing.debugprint(specify_shape_fct) assert np.all( self.ref_fct(specify_shape_fct()) == self.ref_fct(x1_2)) topo_specify = specify_shape_fct.maker.fgraph.toposort() if aesara.config.mode != "FAST_COMPILE": assert len(topo_specify) == 4 # Test that we put the shape info into the graph shape_constant_fct = aesara.function([], x1_specify_shape.shape) # aesara.printing.debugprint(shape_constant_fct) assert np.all(shape_constant_fct() == shape_op_fct()) topo_cst = shape_constant_fct.maker.fgraph.toposort() if aesara.config.mode != "FAST_COMPILE": assert len(topo_cst) == 2 # Test that we can replace with values of the different shape # but that will raise an error in some case, but not all x1_shared.set_value(x2) with pytest.raises(AssertionError): specify_shape_fct() # No assertion will be raised as the Op is removed from the graph if aesara.config.mode not in [ "FAST_COMPILE", "DebugMode", "DEBUG_MODE" ]: shape_constant_fct() else: with pytest.raises(AssertionError): shape_constant_fct()
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 """
def test_gpu3_mixture_dtype_outputs(self): def f_rnn(u_t, x_tm1, W_in, W): return (u_t * W_in + x_tm1 * W, theano.tensor.cast(u_t + x_tm1, "int64")) u = theano.tensor.fvector("u") x0 = theano.tensor.fscalar("x0") W_in = theano.tensor.fscalar("win") W = theano.tensor.fscalar("w") output, updates = theano.scan( f_rnn, u, [x0, None], [W_in, W], n_steps=None, truncate_gradient=-1, go_backwards=False, mode=mode_with_gpu, ) f2 = theano.function( [u, x0, W_in, W], output, updates=updates, allow_input_downcast=True, mode=mode_with_gpu, ) # get random initial values rng = np.random.RandomState(utt.fetch_seed()) v_u = rng.uniform(size=(4, ), low=-5.0, high=5.0) v_x0 = rng.uniform() W = rng.uniform() W_in = rng.uniform() # compute the output in numpy v_out1 = np.zeros((4, )) v_out2 = np.zeros((4, ), dtype="int64") v_out1[0] = v_u[0] * W_in + v_x0 * W v_out2[0] = v_u[0] + v_x0 for step in range(1, 4): v_out1[step] = v_u[step] * W_in + v_out1[step - 1] * W v_out2[step] = np.int64(v_u[step] + v_out1[step - 1]) theano_out1, theano_out2 = f2(v_u, v_x0, W_in, W) utt.assert_allclose(theano_out1, v_out1) utt.assert_allclose(theano_out2, v_out2) topo = f2.maker.fgraph.toposort() scan_node = [ node for node in topo if isinstance(node.op, theano.scan_module.scan_op.Scan) ] assert len(scan_node) == 1 scan_node = scan_node[0] assert scan_node.op.gpua scan_node_topo = scan_node.op.fn.maker.fgraph.toposort() # check that there is no gpu transfer in the inner loop. assert not any( [isinstance(node.op, HostFromGpu) for node in scan_node_topo]) assert not any( [isinstance(node.op, GpuFromHost) for node in scan_node_topo])
from tests import unittest_tools as utt from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, test_ctx_name from tests.tensor.test_basic import ( TestAlloc, TestComparison, TestJoinAndSplit, TestReshape, ) from tests.tensor.utils import rand, safe_make_node pygpu = pytest.importorskip("pygpu") gpuarray = pygpu.gpuarray utt.seed_rng() rng = np.random.RandomState(seed=utt.fetch_seed()) def inplace_func( inputs, outputs, mode=None, allow_input_downcast=False, on_unused_input="raise", name=None, ): if mode is None: mode = mode_with_gpu return aesara.function( inputs, outputs,
def setup_method(self): super().setup_method() self.rng = np.random.RandomState(utt.fetch_seed()) self.A = matrix(dtype=self.dtype) self.X = np.asarray(self.rng.rand(5, 5), dtype=self.dtype) self.S = self.X.dot(self.X.T)
def test_make_node(self, A_func, b_func, error_message): np.random.default_rng(utt.fetch_seed()) with pytest.raises(ValueError, match=error_message): A = A_func() b = b_func() SolveBase()(A, b)
def test_DownsampleFactorMax(self): rng = np.random.RandomState(utt.fetch_seed()) # maxpool, input size examples = ( ((2, ), (16, )), ( (2, ), ( 4, 16, ), ), ( (2, ), ( 4, 2, 16, ), ), ((1, 1), (4, 2, 16, 16)), ((2, 2), (4, 2, 16, 16)), ((3, 3), (4, 2, 16, 16)), ((3, 2), (4, 2, 16, 16)), ((3, 2, 2), (3, 2, 16, 16, 16)), ((2, 2, 3, 2), (3, 2, 6, 6, 6, 5)), ) for example, ignore_border, mode in product( examples, [True, False], ["max", "sum", "average_inc_pad", "average_exc_pad"], ): (maxpoolshp, inputsize) = example imval = rng.rand(*inputsize) images = aesara.shared(imval) # Pure Numpy computation numpy_output_val = self.numpy_max_pool_nd(imval, maxpoolshp, ignore_border, mode=mode) # The pool_2d or pool_3d helper methods if len(maxpoolshp) == 2: output = pool_2d(images, maxpoolshp, ignore_border, mode=mode) f = function( [], [ output, ], ) output_val = f() utt.assert_allclose(output_val, numpy_output_val) elif len(maxpoolshp) == 3: output = pool_3d(images, maxpoolshp, ignore_border, mode=mode) f = function( [], [ output, ], ) output_val = f() utt.assert_allclose(output_val, numpy_output_val) # Pool op maxpool_op = Pool(ndim=len(maxpoolshp), ignore_border=ignore_border, mode=mode)(images, maxpoolshp) output_shape = Pool.out_shape( imval.shape, maxpoolshp, ndim=len(maxpoolshp), ignore_border=ignore_border, ) utt.assert_allclose(np.asarray(output_shape), numpy_output_val.shape) f = function([], maxpool_op) output_val = f() utt.assert_allclose(output_val, numpy_output_val)
def test_DownsampleFactorMaxStride(self): rng = np.random.RandomState(utt.fetch_seed()) # maxpool, stride, ignore_border, input, output sizes examples = ( ((1, 1), (1, 1), True, (4, 10, 16, 16), (4, 10, 16, 16)), ((1, 1), (5, 7), True, (4, 10, 16, 16), (4, 10, 4, 3)), ((1, 1), (1, 1), False, (4, 10, 16, 16), (4, 10, 16, 16)), ((1, 1), (5, 7), False, (4, 10, 16, 16), (4, 10, 4, 3)), ((3, 3), (1, 1), True, (4, 10, 16, 16), (4, 10, 14, 14)), ((3, 3), (3, 3), True, (4, 10, 16, 16), (4, 10, 5, 5)), ((3, 3), (5, 7), True, (4, 10, 16, 16), (4, 10, 3, 2)), ((3, 3), (1, 1), False, (4, 10, 16, 16), (4, 10, 14, 14)), ((3, 3), (3, 3), False, (4, 10, 16, 16), (4, 10, 6, 6)), ((3, 3), (5, 7), False, (4, 10, 16, 16), (4, 10, 4, 3)), ((5, 3), (1, 1), True, (4, 10, 16, 16), (4, 10, 12, 14)), ((5, 3), (3, 3), True, (4, 10, 16, 16), (4, 10, 4, 5)), ((5, 3), (5, 7), True, (4, 10, 16, 16), (4, 10, 3, 2)), ((5, 3), (1, 1), False, (4, 10, 16, 16), (4, 10, 12, 14)), ((5, 3), (3, 3), False, (4, 10, 16, 16), (4, 10, 5, 6)), ((5, 3), (5, 7), False, (4, 10, 16, 16), (4, 10, 4, 3)), ((16, 16), (1, 1), True, (4, 10, 16, 16), (4, 10, 1, 1)), ((16, 16), (5, 7), True, (4, 10, 16, 16), (4, 10, 1, 1)), ((16, 16), (1, 1), False, (4, 10, 16, 16), (4, 10, 1, 1)), ((16, 16), (5, 7), False, (4, 10, 16, 16), (4, 10, 1, 1)), ((3, ), (5, ), True, (16, ), (3, )), ( (3, ), (5, ), True, ( 2, 16, ), ( 2, 3, ), ), ( (5, ), (3, ), True, ( 2, 3, 16, ), ( 2, 3, 4, ), ), ((5, 1, 3), (3, 3, 3), True, (2, 16, 16, 16), (2, 4, 6, 5)), ((5, 1, 3), (3, 3, 3), True, (4, 2, 16, 16, 16), (4, 2, 4, 6, 5)), ) for example, mode in product( examples, ["max", "sum", "average_inc_pad", "average_exc_pad"]): (maxpoolshp, stride, ignore_border, inputshp, outputshp) = example # generate random images imval = rng.rand(*inputshp) images = aesara.shared(imval) # Pool op numpy_output_val = self.numpy_max_pool_nd_stride( imval, maxpoolshp, ignore_border, stride, mode) assert ( numpy_output_val.shape == outputshp ), f"outshape is {outputshp}, calculated shape is {numpy_output_val.shape}" maxpool_op = Pool(ndim=len(maxpoolshp), ignore_border=ignore_border, mode=mode)(images, maxpoolshp, stride) f = function([], maxpool_op) output_val = f() utt.assert_allclose(output_val, numpy_output_val)
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 random_complex128_ranged(min, max, shape, rng=None): if rng is None: rng = np.random.default_rng(seed=utt.fetch_seed()) return np.asarray(rng.random(shape) * (max - min) + min, dtype="complex128")
def integers_ranged(min, max, shape, rng=None): if rng is None: rng = np.random.default_rng(seed=utt.fetch_seed()) return rng.integers(min, max + 1, shape)
def test_grad(self): rng = np.random.default_rng(utt.fetch_seed()) utt.verify_grad(self.op, [self.a[self.idx_sorted], self.b], rng=rng)
def test__repr__(self): np.random.default_rng(utt.fetch_seed()) A = matrix() b = matrix() y = SolveBase()(A, b) assert y.__repr__() == "SolveBase{lower=False, check_finite=True}.0"
def setup_method(self): self.rng = np.random.default_rng(utt.fetch_seed())
def setup_method(self): self.rng = np.random.RandomState(utt.fetch_seed(666))
def test_one_sequence_one_output_weights_gpu2(self): def f_rnn(u_t, x_tm1, W_in, W): return u_t * W_in + x_tm1 * W u = theano.tensor.fvector("u") x0 = theano.tensor.fscalar("x0") W_in = theano.tensor.fscalar("win") W = theano.tensor.fscalar("w") output, updates = theano.scan( f_rnn, u, x0, [W_in, W], n_steps=None, truncate_gradient=-1, go_backwards=False, mode=mode_with_gpu, ) f2 = theano.function( [u, x0, W_in, W], output, updates=updates, allow_input_downcast=True, mode=mode_with_gpu, ) # get random initial values rng = np.random.RandomState(utt.fetch_seed()) v_u = rng.uniform(size=(4, ), low=-5.0, high=5.0) v_x0 = rng.uniform() W = rng.uniform() W_in = rng.uniform() # compute the output in numpy v_out = np.zeros((4, )) v_out[0] = v_u[0] * W_in + v_x0 * W for step in range(1, 4): v_out[step] = v_u[step] * W_in + v_out[step - 1] * W theano_values = f2(v_u, v_x0, W_in, W) utt.assert_allclose(theano_values, v_out) topo = f2.maker.fgraph.toposort() assert sum([isinstance(node.op, HostFromGpu) for node in topo]) == 1 assert sum([isinstance(node.op, GpuFromHost) for node in topo]) == 4 scan_node = [ node for node in topo if isinstance(node.op, theano.scan_module.scan_op.Scan) ] assert len(scan_node) == 1 scan_node = scan_node[0] scan_node_topo = scan_node.op.fn.maker.fgraph.toposort() # check that there is no gpu transfer in the inner loop. assert any( [isinstance(node.op, GpuElemwise) for node in scan_node_topo]) assert not any( [isinstance(node.op, HostFromGpu) for node in scan_node_topo]) assert not any( [isinstance(node.op, GpuFromHost) for node in scan_node_topo])
def test_one_sequence_one_output_weights_gpu1(self): def f_rnn(u_t, x_tm1, W_in, W): return u_t * W_in + x_tm1 * W u = fvector("u") x0 = fscalar("x0") W_in = fscalar("win") W = fscalar("w") mode = mode_with_gpu.excluding("InputToGpuOptimizer") output, updates = scan( f_rnn, u, x0, [W_in, W], n_steps=None, truncate_gradient=-1, go_backwards=False, mode=mode, ) output = GpuFromHost(test_ctx_name)(output) f2 = aesara.function( [u, x0, W_in, W], output, updates=updates, allow_input_downcast=True, mode=mode, ) rng = np.random.RandomState(utt.fetch_seed()) v_u = rng.uniform(size=(4, ), low=-5.0, high=5.0) v_x0 = rng.uniform() W = rng.uniform() W_in = rng.uniform() v_u = np.asarray(v_u, dtype="float32") v_x0 = np.asarray(v_x0, dtype="float32") W = np.asarray(W, dtype="float32") W_in = np.asarray(W_in, dtype="float32") # compute the output in numpy v_out = np.zeros((4, )) v_out[0] = v_u[0] * W_in + v_x0 * W for step in range(1, 4): v_out[step] = v_u[step] * W_in + v_out[step - 1] * W aesara_values = f2(v_u, v_x0, W_in, W) utt.assert_allclose(aesara_values, v_out) # TO DEL topo = f2.maker.fgraph.toposort() scan_node = [ node for node in topo if isinstance(node.op, scan.op.Scan) ] assert len(scan_node) == 1 scan_node = scan_node[0] topo = f2.maker.fgraph.toposort() assert sum([isinstance(node.op, HostFromGpu) for node in topo]) == 0 assert sum([isinstance(node.op, GpuFromHost) for node in topo]) == 4 scan_node = [ node for node in topo if isinstance(node.op, scan.op.Scan) ] assert len(scan_node) == 1 scan_node = scan_node[0] scan_node_topo = scan_node.op.fn.maker.fgraph.toposort() # check that there is no gpu transfer in the inner loop. assert any( [isinstance(node.op, GpuElemwise) for node in scan_node_topo]) assert not any( [isinstance(node.op, HostFromGpu) for node in scan_node_topo]) assert not any( [isinstance(node.op, GpuFromHost) for node in scan_node_topo])
def test_specify_shape(self): dtype = self.dtype if dtype is None: dtype = aesara.config.floatX rng = np.random.default_rng(utt.fetch_seed()) x1_1 = np.asarray(rng.uniform(1, 2, [4, 2]), dtype=dtype) x1_1 = self.cast_value(x1_1) x1_2 = np.asarray(rng.uniform(1, 2, [4, 2]), dtype=dtype) x1_2 = self.cast_value(x1_2) x2 = np.asarray(rng.uniform(1, 2, [4, 3]), dtype=dtype) x2 = self.cast_value(x2) # Test that we can replace with values of the same shape x1_shared = self.shared_constructor(x1_1) x1_specify_shape = specify_shape(x1_shared, x1_1.shape) x1_shared.set_value(x1_2) assert np.allclose(self.ref_fct(x1_shared.get_value(borrow=True)), self.ref_fct(x1_2)) shape_op_fct = aesara.function([], x1_shared.shape) topo = shape_op_fct.maker.fgraph.toposort() if aesara.config.mode != "FAST_COMPILE": assert len(topo) == 3 assert isinstance(topo[0].op, Shape_i) assert isinstance(topo[1].op, Shape_i) assert isinstance(topo[2].op, MakeVector) # Test that we forward the input specify_shape_fct = aesara.function([], x1_specify_shape) assert np.all( self.ref_fct(specify_shape_fct()) == self.ref_fct(x1_2)) topo_specify = specify_shape_fct.maker.fgraph.toposort() assert len(topo_specify) == 2 # Test that we put the shape info into the graph shape_constant_fct = aesara.function([], x1_specify_shape.shape) assert np.all(shape_constant_fct() == shape_op_fct()) topo_cst = shape_constant_fct.maker.fgraph.toposort() if aesara.config.mode != "FAST_COMPILE": assert len(topo_cst) == 1 topo_cst[0].op == aesara.compile.function.types.deep_copy_op # Test that we can take the grad. if aesara.sparse.enable_sparse and isinstance( x1_specify_shape.type, aesara.sparse.SparseType): # SparseVariable don't support sum for now. assert not hasattr(x1_specify_shape, "sum") else: shape_grad = aesara.gradient.grad(x1_specify_shape.sum(), x1_shared) shape_constant_fct_grad = aesara.function([], shape_grad) # aesara.printing.debugprint(shape_constant_fct_grad) shape_constant_fct_grad() # Test that we can replace with values of the different shape # but that will raise an error in some case, but not all specify_shape_fct() x1_shared.set_value(x2) with pytest.raises(AssertionError): specify_shape_fct() # No assertion will be raised as the Op is removed from the graph # when their is optimization if aesara.config.mode not in [ "FAST_COMPILE", "DebugMode", "DEBUG_MODE" ]: shape_constant_fct() else: with pytest.raises(AssertionError): shape_constant_fct()
def setup_method(self): super().setup_method() self.rng = np.random.default_rng(utt.fetch_seed()) self.A = matrix(dtype=self.dtype) self.op = svd
def test_specify_shape_inplace(self): # test that specify_shape don't break inserting inplace op dtype = self.dtype if dtype is None: dtype = aesara.config.floatX rng = np.random.default_rng(utt.fetch_seed()) a = np.asarray(rng.uniform(1, 2, [40, 40]), dtype=dtype) a = self.cast_value(a) a_shared = self.shared_constructor(a) b = np.asarray(rng.uniform(1, 2, [40, 40]), dtype=dtype) b = self.cast_value(b) b_shared = self.shared_constructor(b) s = np.zeros((40, 40), dtype=dtype) s = self.cast_value(s) s_shared = self.shared_constructor(s) f = aesara.function( [], updates=[(s_shared, aesara.tensor.dot(a_shared, b_shared) + s_shared)], ) topo = f.maker.fgraph.toposort() f() # [Gemm{inplace}(<TensorType(float64, matrix)>, 0.01, <TensorType(float64, matrix)>, <TensorType(float64, matrix)>, 2e-06)] if aesara.config.mode != "FAST_COMPILE": assert (sum([ node.op.__class__.__name__ in ["Gemm", "GpuGemm", "StructuredDot"] for node in topo ]) == 1) assert all(node.op == aesara.tensor.blas.gemm_inplace for node in topo if isinstance(node.op, aesara.tensor.blas.Gemm)) assert all(node.op.inplace for node in topo if node.op.__class__.__name__ == "GpuGemm") # Their is no inplace gemm for sparse # assert all(node.op.inplace for node in topo if node.op.__class__.__name__ == "StructuredDot") s_shared_specify = specify_shape( s_shared, s_shared.get_value(borrow=True).shape) # now test with the specify shape op in the output f = aesara.function( [], s_shared.shape, updates=[ (s_shared, aesara.tensor.dot(a_shared, b_shared) + s_shared_specify) ], ) topo = f.maker.fgraph.toposort() shp = f() assert np.all(shp == (40, 40)) if aesara.config.mode != "FAST_COMPILE": assert (sum([ node.op.__class__.__name__ in ["Gemm", "GpuGemm", "StructuredDot"] for node in topo ]) == 1) assert all(node.op == aesara.tensor.blas.gemm_inplace for node in topo if isinstance(node.op, aesara.tensor.blas.Gemm)) assert all(node.op.inplace for node in topo if node.op.__class__.__name__ == "GpuGemm") # now test with the specify shape op in the inputs and outputs a_shared = specify_shape(a_shared, a_shared.get_value(borrow=True).shape) b_shared = specify_shape(b_shared, b_shared.get_value(borrow=True).shape) f = aesara.function( [], s_shared.shape, updates=[ (s_shared, aesara.tensor.dot(a_shared, b_shared) + s_shared_specify) ], ) topo = f.maker.fgraph.toposort() shp = f() assert np.all(shp == (40, 40)) if aesara.config.mode != "FAST_COMPILE": assert (sum([ node.op.__class__.__name__ in ["Gemm", "GpuGemm", "StructuredDot"] for node in topo ]) == 1) assert all(node.op == aesara.tensor.blas.gemm_inplace for node in topo if isinstance(node.op, aesara.tensor.blas.Gemm)) assert all(node.op.inplace for node in topo if node.op.__class__.__name__ == "GpuGemm")
def test_det_grad(): rng = np.random.default_rng(utt.fetch_seed()) r = rng.standard_normal((5, 5)).astype(config.floatX) utt.verify_grad(det, [r], rng=np.random)
def test_random_function_ndim_added(self): # Test that random_function helper function accepts ndim_added as # keyword argument # If using numpy's uniform distribution, ndim_added should be 0, # because the shape provided as argument is the output shape. # Specifying a different ndim_added will change the Op's output ndim, # so np.uniform will produce a result of incorrect shape, # and a ValueError should be raised. def ndim_added_deco(ndim_added): def randomfunction(random_state, size=(), low=0.0, high=0.0, ndim=None): ndim, size, bcast = raw_random._infer_ndim_bcast(ndim, size) if ndim_added < 0: bcast = bcast[:ndim_added] else: bcast = bcast + ((False, ) * ndim_added) assert len(bcast) == ndim + ndim_added op = RandomFunction( "uniform", tensor.TensorType(dtype="float64", broadcastable=bcast), ndim_added=ndim_added, ) return op(random_state, size, low, high) return randomfunction uni_1 = ndim_added_deco(1) uni_0 = ndim_added_deco(0) uni_m1 = ndim_added_deco(-1) rng_R = random_state_type() p_uni11, uni11 = uni_1(rng_R, size=(4, )) p_uni12, uni12 = uni_1(rng_R, size=(3, 4)) p_uni01, uni01 = uni_0(rng_R, size=(4, )) p_uni02, uni02 = uni_0(rng_R, size=(3, 4)) p_unim11, unim11 = uni_m1(rng_R, size=(4, )) p_unim12, unim12 = uni_m1(rng_R, size=(3, 4)) assert uni11.ndim == 2 assert uni12.ndim == 3 assert uni01.ndim == 1 assert uni02.ndim == 2 assert unim11.ndim == 0 assert unim12.ndim == 1 f11 = function( [ In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=p_uni11, mutable=True, ) ], [uni11], accept_inplace=True, ) f12 = function( [ In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=p_uni12, mutable=True, ) ], [uni12], accept_inplace=True, ) fm11 = function( [ In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=p_unim11, mutable=True, ) ], [unim11], accept_inplace=True, ) fm12 = function( [ In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=p_unim12, mutable=True, ) ], [unim12], accept_inplace=True, ) f0 = function( [ In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=p_uni02, mutable=True, ) ], [uni01, uni02], accept_inplace=True, ) with pytest.raises(ValueError): f11() with pytest.raises(ValueError): f12() with pytest.raises(ValueError): fm11() with pytest.raises(ValueError): fm12() u01, u02 = f0() assert np.allclose(u01, u02[0])
def setup_method(self): super().setup_method() self.rng = np.random.default_rng(utt.fetch_seed()) self.A = matrix(dtype=self.dtype) self.X = np.asarray(self.rng.random((5, 5)), dtype=self.dtype) self.S = self.X.dot(self.X.T)
def setup_method(self): super().setup_method() self.rng = np.random.RandomState(utt.fetch_seed()) self.A = theano.tensor.matrix(dtype=self.dtype) self.op = svd
def setup_method(self): super().setup_method() self.op_class = MatrixInverse self.op = matrix_inverse self.rng = np.random.default_rng(utt.fetch_seed())
def test_alloc_diag_grad(self): rng = np.random.RandomState(utt.fetch_seed()) x = rng.rand(5) tensor.verify_grad(alloc_diag, [x], rng=rng)
def integers_nonzero(*shape, rng=None): if rng is None: rng = np.random.default_rng(seed=utt.fetch_seed()) r = rng.integers(-5, 5, shape) return r + (r == 0) * 5