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_multinomial(self): # Test that raw_random.multinomial generates the same results as numpy. # Check over two calls to see if the random state is correctly updated. rng_R = random_state_type() post_r, out = multinomial(rng_R, (7, 3), 6, [0.2] * 5) 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.multinomial(6, [0.2] * 5, (7, 3)) numpy_val1 = numpy_rng.multinomial(6, [0.2] * 5, (7, 3)) assert np.all(val0 == numpy_val0) assert np.all(val1 == numpy_val1) assert val0.shape == (7, 3, 5) assert val1.shape == (7, 3, 5)
def test_binomial(self): # Test that raw_random.binomial 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, and larger dimensions because of # the integer nature of the result post_r, bin = binomial(rng_R, (7, 12), 5, 0.8) f = compile.function( [ compile.In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=post_r, mutable=True, ) ], [bin], accept_inplace=True, ) numpy_rng = np.random.RandomState(utt.fetch_seed()) val0 = f() val1 = f() numpy_val0 = numpy_rng.binomial(5, 0.8, size=(7, 12)) numpy_val1 = numpy_rng.binomial(5, 0.8, size=(7, 12)) assert np.all(val0 == numpy_val0) assert np.all(val1 == numpy_val1)
def test_inplace_optimization(self): # Test that FAST_RUN includes the random_make_inplace optimization # inplace = False rf2 = RandomFunction(np.random.RandomState.uniform, tensor.dvector) rng_R = random_state_type() # If calling RandomFunction directly, all args have to be specified, # because shape will have to be moved to the end post_r2, out2 = rf2(rng_R, (4, ), 0.0, 1.0) f = compile.function( [ compile.In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=post_r2, mutable=True, ) ], out2, mode="FAST_RUN", ) # DEBUG_MODE can't pass the id-based # test below # test that the RandomState object stays the same from function call to # function call, but that the values returned change from call to call. id0 = id(f[rng_R]) val0 = f() assert id0 == id(f[rng_R]) val1 = f() assert id0 == id(f[rng_R]) assert not np.allclose(val0, val1)
def gen(self, op, *args, **kwargs): random_state_variable = raw_random.random_state_type() new_r, out = op(random_state_variable, *args, **kwargs) self.add_input(SymbolicInput(random_state_variable, update=new_r)) out.rng = new_r out.auto = self return out
def test_poisson(self): # Test that raw_random.poisson 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, and larger dimensions because of # the integer nature of the result post_r, out = poisson(rng_R, lam=5, size=(11, 8)) 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.poisson(5, size=(11, 8)) numpy_val1 = numpy_rng.poisson(5, size=(11, 8)) assert np.allclose(val0, numpy_val0) assert np.allclose(val1, numpy_val1)
def test_random_function_noshape_noargs(self): # Test if random_function helper works without args or shape rng_R = random_state_type() # No shape, no args -> TypeError with pytest.raises(TypeError): poisson(rng_R, size=None, ndim=2)
def test_no_inplace(self): # Test that when not running inplace, the RandomState is not updated rf = RandomFunction("uniform", tensor.dvector) rng_R = random_state_type() post_r, out = rf(rng_R, (3, ), 0.0, 1.0) f = compile.function([rng_R], [post_r, out]) rng = np.random.RandomState(utt.fetch_seed()) rng0, val0 = f(rng) rng_ = np.random.RandomState(utt.fetch_seed()) # rng should still be in a fresh state assert rng_R.type.values_eq(rng, rng_) # rng0 should be in an updated state assert not rng_R.type.values_eq(rng, rng0) f2 = compile.function( [compile.In(rng_R, value=rng, update=post_r, mutable=False)], [post_r, out]) rng2, val2 = f2() # rng should be in a fresh state assert rng_R.type.values_eq(rng, rng_) # rng2 should be in an updated state assert not rng_R.type.values_eq(rng, rng2) # The updated state should be the same for both functions assert rng_R.type.values_eq(rng2, rng0) rng3, val3 = f2() # rng2 should not have changed assert rng_R.type.values_eq(rng2, rng0) # rng3 should be an updated again version of rng2 assert not rng_R.type.values_eq(rng3, rng2) assert not rng_R.type.values_eq(rng3, rng)
def test_random_function_ndim(self): # Test that random_function helper function accepts argument ndim rng_R = random_state_type() # ndim is an optional argument indicating the length of the 'shape' # ndim not specified, OK post_out4, out4 = uniform(rng_R, (4, )) # ndim specified, consistent with shape, OK post_out1_4, out1_4 = uniform(rng_R, (4, ), ndim=1) post_out2_4_4, out2_4_4 = uniform(rng_R, (4, 4), ndim=2) # ndim specified, but not compatible with shape with pytest.raises(ValueError): uniform(rng_R, (4, ), ndim=2) f_ok = compile.function( [ compile.In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=post_out2_4_4, mutable=True, ) ], [out4, out1_4, out2_4_4], accept_inplace=True, ) # The correct cases should execute properly o4, o1_4, o2_4_4 = f_ok() # Check the sanity of the answers assert np.allclose(o4, o1_4) assert np.allclose(o4, o2_4_4[0])
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 gen(self, op, *args, **kwargs): random_state_variable = raw_random.random_state_type() new_r, out = op(random_state_variable, *args, **kwargs) self.add_input(SymbolicInput(random_state_variable, update = new_r)) out.rng = new_r out.auto = self return out
def test_choice(self): # Test that raw_random.choice 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, and larger dimensions because of # the integer nature of the result post_r, out = choice(rng_R, (11, 8), 10, 1, 0) 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_val0 = numpy_rng.choice(10, (11, 8), True, None) numpy_val1 = numpy_rng.choice(10, (11, 8), True, None) assert np.allclose(val0, numpy_val0) assert np.allclose(val1, numpy_val1)
def test_random_integers(self): # Test that raw_random.random_integers generates the same # results as numpy. We use randint() for comparison since # random_integers() is deprecated. # Check over two calls to see if the random state is correctly updated. rng_R = random_state_type() # Use non-default parameters, and larger dimensions because of # the integer nature of the result post_r, out = random_integers(rng_R, (11, 8), -3, 16) 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_val0 = numpy_rng.randint(-3, 17, size=(11, 8)) numpy_val1 = numpy_rng.randint(-3, 17, size=(11, 8)) assert np.allclose(val0, numpy_val0) assert np.allclose(val1, numpy_val1)
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=theano.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_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_args(self): # Test that arguments to RandomFunction are honored rf2 = RandomFunction(np.random.RandomState.uniform, tensor.dvector) rf4 = RandomFunction(np.random.RandomState.uniform, tensor.dvector, inplace=True) rng_R = random_state_type() # use make_node to override some of the self.args post_r2, out2 = rf2(rng_R, (4, ), -2, 2) # NOT INPLACE post_r4, out4 = rf4(rng_R, (4, ), -4, 4) # INPLACE post_r2_4, out2_4 = rf2(rng_R, (4, ), -4.0, 2) # NOT INPLACE post_r2_4_4, out2_4_4 = rf2(rng_R, (4, ), -4.0, 4.0) # NOT INPLACE # configure out4 to be computed inplace # The update expression means that the random state rng_R will # be maintained by post_r4 f = compile.function( [ compile.In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=post_r4, mutable=True, ) ], [out2, out4, out2_4, out2_4_4], accept_inplace=True, ) f2, f4, f2_4, f2_4_4 = f() f2b, f4b, f2_4b, f2_4_4b = f() # print f2 # print f4 # print f2_4 # print f2_4_4 # print f2b # print f4b # print f2_4b # print f2_4_4b # setting bounds is same as multiplying by 2 assert np.allclose(f2 * 2, f4), (f2, f4) # retrieving from non-inplace generator # is same as inplace one for first call assert np.allclose(f2_4_4, f4), (f2_4_4, f4) # f4 changes from call to call, that the update has worked assert not np.allclose(f4, f4b), (f4, f4b)
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_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_pkl(self): # Test pickling of RandomFunction. # binomial was created by calling RandomFunction on a string, # random_integers by calling it on a function. rng_r = random_state_type() mode = None if theano.config.mode in ["DEBUG_MODE", "DebugMode"]: mode = "FAST_COMPILE" post_bin_r, bin_sample = binomial(rng_r, (3, 5), 1, 0.3) f = theano.function([rng_r], [post_bin_r, bin_sample], mode=mode) pickle.dumps(f) post_int_r, int_sample = random_integers(rng_r, (3, 5), -1, 8) g = theano.function([rng_r], [post_int_r, int_sample], mode=mode) pkl_g = pickle.dumps(g) pickle.loads(pkl_g)
def test_mixed_shape(self): # Test when the provided shape is a tuple of ints and scalar vars rng_R = random_state_type() shape0 = tensor.lscalar() shape = (shape0, 3) post_r, u = uniform(rng_R, size=shape, ndim=2) f = compile.function([rng_R, shape0], u) rng_state0 = np.random.RandomState(utt.fetch_seed()) assert f(rng_state0, 2).shape == (2, 3) assert f(rng_state0, 8).shape == (8, 3) post_r, v = uniform(rng_R, size=shape) g = compile.function([rng_R, shape0], v) assert g(rng_state0, 2).shape == (2, 3) assert g(rng_state0, 8).shape == (8, 3)
def test_random_function_noshape_args(self): # Test if random_function helper works with args but without shape rng_R = random_state_type() # No shape, default args -> OK post_out, out = uniform(rng_R, size=None, ndim=2) f = compile.function( [ compile.In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=post_out, mutable=True, ) ], [out], accept_inplace=True, ) (o, ) = f() # No shape, args that have to be broadcasted -> OK low = tensor.TensorType(dtype="float64", broadcastable=(False, True, True))() high = tensor.TensorType(dtype="float64", broadcastable=(True, True, True, False))() post_out2, out2 = uniform(rng_R, size=None, ndim=2, low=low, high=high) assert out2.ndim == 4 assert out2.broadcastable == (True, False, True, False) g = compile.function( [ low, high, compile.In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=post_out2, mutable=True, ), ], [out2], accept_inplace=True, ) low_v = [[[3]], [[4]], [[-5]]] high_v = [[[[5, 8]]]] (o2, ) = g(low_v, high_v) assert o2.shape == (1, 3, 1, 2)
def test_dtype(self): rng_R = random_state_type() low = tensor.lscalar() high = tensor.lscalar() post_r, out = random_integers( rng_R, low=low, high=high, size=(20,), dtype="int8" ) assert out.dtype == "int8" f = compile.function([rng_R, low, high], [post_r, out]) rng = np.random.RandomState(utt.fetch_seed()) rng0, val0 = f(rng, 0, 9) assert val0.dtype == "int8" rng1, val1 = f(rng0, 255, 257) assert val1.dtype == "int8" assert np.all(abs(val1) <= 1)
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_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_mixed_shape_bcastable(self): # Test when the provided shape is a tuple of ints and scalar vars rng_R = random_state_type() shape0 = tensor.lscalar() shape = (shape0, 1) post_r, u = uniform(rng_R, size=shape, ndim=2) assert u.broadcastable == (False, True) f = function([rng_R, shape0], u) rng_state0 = np.random.RandomState(utt.fetch_seed()) assert f(rng_state0, 2).shape == (2, 1) assert f(rng_state0, 8).shape == (8, 1) post_r, v = uniform(rng_R, size=shape) assert v.broadcastable == (False, True) g = function([rng_R, shape0], v) assert g(rng_state0, 2).shape == (2, 1) assert g(rng_state0, 8).shape == (8, 1)
def test_permutation(self): # Test that raw_random.permutation generates the same results as numpy. rng_R = random_state_type() post_r, out = permutation(rng_R, size=(9, ), n=6) 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()) # Check over two calls to see if the random state is correctly updated. # numpy_rng.permutation outputs one vector at a time, # so we call it iteratively to generate all the samples. val0 = f() val1 = f() numpy_val0 = np.asarray([numpy_rng.permutation(6) for i in range(9)]) numpy_val1 = np.asarray([numpy_rng.permutation(6) for i in range(9)]) assert np.all(val0 == numpy_val0) assert np.all(val1 == numpy_val1) # Test that we can generate a list: have size=None or (). for ndim in [1, None]: post_r, out = permutation(rng_R, n=10, size=None, ndim=ndim) inp = compile.In( rng_R, value=np.random.RandomState(utt.fetch_seed()), update=post_r, mutable=True, ) f = theano.function([inp], out) o = f() assert o.shape == (10, ) assert (np.sort(o) == np.arange(10)).all() # Wrong number of dimensions asked with pytest.raises(TypeError): permutation(rng_R, size=None, ndim=2)
def gen(self, op, *args, **kwargs): """Create a new random stream in this container. :param op: a RandomFunction instance to :param args: interpreted by `op` :param kwargs: interpreted by `op` :returns: The symbolic random draw part of op()'s return value. This function stores the updated RandomStateType Variable for use at `build` time. :rtype: TensorVariable """ random_state_variable = raw_random.random_state_type() new_r, out = op(random_state_variable, *args, **kwargs) out.rng = random_state_variable self.random_state_variables.append((random_state_variable, new_r)) return out
def test_multinomial_tensor3_b(self): # Test the examples given in the multinomial documentation regarding # tensor3 objects rng_R = random_state_type() n = 9 pvals = tensor.dtensor3() post_r, out = multinomial(rng_R, n=n, pvals=pvals, size=(10, 1, -1)) assert out.ndim == 4 assert out.broadcastable == (False, True, False, False) f = function([rng_R, pvals], [post_r, out], accept_inplace=True) rng = np.random.RandomState(utt.fetch_seed()) pvals_val = np.asarray([[[0.1, 0.9], [0.2, 0.8], [0.3, 0.7]]]) assert pvals_val.shape == (1, 3, 2) out_rng, draw = f(rng, pvals_val) assert draw.shape == (10, 1, 3, 2) assert np.allclose(draw.sum(axis=3), 9)
def test_broadcast_arguments(self): rng_R = random_state_type() low = tensor.dvector() high = tensor.dcol() post_r, out = uniform(rng_R, low=low, high=high) assert out.ndim == 2 f = compile.function([rng_R, low, high], [post_r, out], accept_inplace=True) 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], [[1.0]]) post1, val1 = f(post0, [0.9], [[1.0], [1.1], [1.5]]) post2, val2 = f(post1, [-5, 0.5, 0, 1], [[1.0], [1.1], [1.5]]) numpy_val0 = numpy_rng.uniform(low=[-5, 0.5, 0, 1], high=[1.0]) numpy_val1 = numpy_rng.uniform(low=[0.9], high=[[1.0], [1.1], [1.5]]) numpy_val2 = numpy_rng.uniform(low=[-5, 0.5, 0, 1], high=[[1.0], [1.1], [1.5]]) assert np.all(val0 == numpy_val0), (val0, numpy_val0) assert np.all(val1 == numpy_val1) assert np.all(val2 == numpy_val2)
def test_basic_usage(self): rf = RandomFunction(np.random.RandomState.uniform, tensor.dvector) assert not rf.inplace assert getattr(rf, "destroy_map", {}) == {} rng_R = random_state_type() # If calling RandomFunction directly, all args have to be specified, # because shape will have to be moved to the end post_r, out = rf(rng_R, (4, ), 0.0, 1.0) assert out.type == tensor.dvector f = compile.function([rng_R], out) rng_state0 = np.random.RandomState(utt.fetch_seed()) f_0 = f(rng_state0) f_1 = f(rng_state0) assert np.all(f_0 == f_1)
def test_uniform_vector(self): rng_R = random_state_type() low = tensor.vector() high = tensor.vector() post_r, out = uniform(rng_R, low=low, high=high) assert out.ndim == 1 f = compile.function([rng_R, low, high], [post_r, out], accept_inplace=True) def as_floatX(thing): return np.asarray(thing, dtype=theano.config.floatX) low_val = as_floatX([0.1, 0.2, 0.3]) high_val = as_floatX([1.1, 2.2, 3.3]) 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 = as_floatX(numpy_rng.uniform(low=low_val, high=high_val)) assert np.all(val0 == numpy_val0) # arguments of size (2,) rng1, val1 = f(rng0, low_val[:-1], high_val[:-1]) numpy_val1 = as_floatX( numpy_rng.uniform(low=low_val[:-1], high=high_val[:-1])) assert np.all(val1 == numpy_val1) # Specifying the size explicitly g = compile.function( [rng_R, low, high], uniform(rng_R, low=low, high=high, size=(3, )), accept_inplace=True, ) rng2, val2 = g(rng1, low_val, high_val) numpy_val2 = as_floatX( numpy_rng.uniform(low=low_val, high=high_val, size=(3, ))) assert np.all(val2 == numpy_val2) with pytest.raises(ValueError): g(rng2, low_val[:-1], high_val[:-1])