def multMatVect(v, A, m1, B, m2): # TODO : need description for parameter and return """ Multiply the first half of v by A with a modulo of m1 and the second half by B with a modulo of m2. Notes ----- The parameters of dot_modulo are passed implicitly because passing them explicitly takes more time than running the function's C-code. """ if multMatVect.dot_modulo is None: A_sym = tensor.lmatrix("A") s_sym = tensor.ivector("s") m_sym = tensor.iscalar("m") A2_sym = tensor.lmatrix("A2") s2_sym = tensor.ivector("s2") m2_sym = tensor.iscalar("m2") o = DotModulo()(A_sym, s_sym, m_sym, A2_sym, s2_sym, m2_sym) multMatVect.dot_modulo = function( [A_sym, s_sym, m_sym, A2_sym, s2_sym, m2_sym], o, profile=False) # This way of calling the Aesara fct is done to bypass Aesara overhead. f = multMatVect.dot_modulo f.input_storage[0].storage[0] = A f.input_storage[1].storage[0] = v[:3] f.input_storage[2].storage[0] = m1 f.input_storage[3].storage[0] = B f.input_storage[4].storage[0] = v[3:] f.input_storage[5].storage[0] = m2 f.fn() r = f.output_storage[0].storage[0] return r
def test_multMatVect(): A1 = tensor.lmatrix("A1") s1 = tensor.ivector("s1") m1 = tensor.iscalar("m1") A2 = tensor.lmatrix("A2") s2 = tensor.ivector("s2") m2 = tensor.iscalar("m2") g0 = rng_mrg.DotModulo()(A1, s1, m1, A2, s2, m2) f0 = aesara.function([A1, s1, m1, A2, s2, m2], g0) i32max = np.iinfo(np.int32).max A1 = np.random.randint(0, i32max, (3, 3)).astype("int64") s1 = np.random.randint(0, i32max, 3).astype("int32") m1 = np.asarray(np.random.randint(i32max), dtype="int32") A2 = np.random.randint(0, i32max, (3, 3)).astype("int64") s2 = np.random.randint(0, i32max, 3).astype("int32") m2 = np.asarray(np.random.randint(i32max), dtype="int32") f0.input_storage[0].storage[0] = A1 f0.input_storage[1].storage[0] = s1 f0.input_storage[2].storage[0] = m1 f0.input_storage[3].storage[0] = A2 f0.input_storage[4].storage[0] = s2 f0.input_storage[5].storage[0] = m2 r_a1 = rng_mrg.matVecModM(A1, s1, m1) r_a2 = rng_mrg.matVecModM(A2, s2, m2) f0.fn() r_b = f0.output_storage[0].value assert np.allclose(r_a1, r_b[:3]) assert np.allclose(r_a2, r_b[3:])
def test__getitem__AdvancedSubtensor(): # Make sure we get `AdvancedSubtensor`s for basic indexing operations x = tt.matrix("x") i = tt.ivector("i") # This is a `__getitem__` call that's redirected to `_tensor_py_operators.take` z = x[i] op_types = [type(node.op) for node in aesara.gof.graph.io_toposort([x, i], [z])] assert op_types[-1] == AdvancedSubtensor1 # This should index nothing (i.e. return an empty copy of `x`) # We check that the index is empty z = x[[]] op_types = [type(node.op) for node in aesara.gof.graph.io_toposort([x, i], [z])] assert op_types == [AdvancedSubtensor1] assert isinstance(z.owner.inputs[1], TensorConstant) # This is also a `__getitem__` call that's redirected to `_tensor_py_operators.take` z = x[:, i] op_types = [type(node.op) for node in aesara.gof.graph.io_toposort([x, i], [z])] assert op_types == [DimShuffle, AdvancedSubtensor1, DimShuffle] z = x[..., i, None] op_types = [type(node.op) for node in aesara.gof.graph.io_toposort([x, i], [z])] assert op_types == [MakeSlice, AdvancedSubtensor] z = x[i, None] op_types = [type(node.op) for node in aesara.gof.graph.io_toposort([x, i], [z])] assert op_types[-1] == AdvancedSubtensor
def test_can_not_infer_nb_dim(self): # Was reported in gh-5613. Test that we do not crash # or that we crash in a few other case found while # investigating that case img = tt.tensor4("img") patches = tt.nnet.neighbours.images2neibs(img, [16, 16]) extractPatches = aesara.function([img], patches, mode=self.mode) patsRecovery = tt.matrix("patsRecovery") original_size = tt.ivector("original_size") for mode in ["valid", "ignore_borders"]: out = neibs2images(patsRecovery, (16, 16), original_size, mode=mode) f = aesara.function([patsRecovery, original_size], out, mode=self.mode) im_val = np.ones((1, 3, 320, 320), dtype=np.float32) neibs = extractPatches(im_val) f(neibs, im_val.shape) # Wrong number of dimensions with pytest.raises(ValueError): f(neibs, (1, 1, 3, 320, 320)) # End up with a step of 0 # This can lead to division by zero in DebugMode with pytest.raises((ValueError, ZeroDivisionError)): f(neibs, (3, 320, 320, 1))
def test_invalid_type(self): a = at.ivector("a") a.tag.test_value = np.zeros(3, dtype=a.dtype) a.dshape = (3, ) a.dsize = 3 with pytest.raises(TypeError) as err: ValueGradFunction([a.sum()], [a], {}, mode="FAST_COMPILE") err.match("Invalid dtype")
def test_givens(self): x = shared(0) assign = pfunc([], x, givens={x: 3}) assert assign() == 3 assert x.get_value(borrow=True) == 0 y = tensor.ivector() f = pfunc([y], (y * x), givens={x: 6}) assert np.all(f([1, 1, 1]) == [6, 6, 6]) assert x.get_value() == 0 z = tensor.ivector() c = z * y f = pfunc([y], (c + 7), givens={z: aesara._asarray([4, 4, 4], dtype="int32")}) assert np.all(f([1, 1, 1]) == [11, 11, 11]) assert x.get_value() == 0
def test_local_csm_properties_csm(): data = tensor.vector() indices, indptr, shape = (tensor.ivector(), tensor.ivector(), tensor.ivector()) mode = aesara.compile.mode.get_default_mode() mode = mode.including("specialize", "local_csm_properties_csm") for CS, cast in [ (sparse.CSC, sp.sparse.csc_matrix), (sparse.CSR, sp.sparse.csr_matrix), ]: f = aesara.function( [data, indices, indptr, shape], sparse.csm_properties(CS(data, indices, indptr, shape)), mode=mode, ) assert not any( isinstance(node.op, (sparse.CSM, sparse.CSMProperties)) for node in f.maker.fgraph.toposort() ) v = cast(random_lil((10, 40), config.floatX, 3)) f(v.data, v.indices, v.indptr, v.shape)
def test_local_csm_grad_c(): data = tensor.vector() indices, indptr, shape = (tensor.ivector(), tensor.ivector(), tensor.ivector()) mode = aesara.compile.mode.get_default_mode() if aesara.config.mode == "FAST_COMPILE": mode = aesara.compile.Mode(linker="c|py", optimizer="fast_compile") mode = mode.including("specialize", "local_csm_grad_c") for CS, cast in [ (sparse.CSC, sp.sparse.csc_matrix), (sparse.CSR, sp.sparse.csr_matrix), ]: cost = tensor.sum(sparse.DenseFromSparse()(CS(data, indices, indptr, shape))) f = aesara.function( [data, indices, indptr, shape], tensor.grad(cost, data), mode=mode ) assert not any( isinstance(node.op, sparse.CSMGrad) for node in f.maker.fgraph.toposort() ) v = cast(random_lil((10, 40), config.floatX, 3)) f(v.data, v.indices, v.indptr, v.shape)
def test_seed_fn(): idx = tensor.ivector() for new_seed, same in [(234, True), (None, True), (23, False)]: random = MRG_RandomStreams(234) fn1 = aesara.function([], random.uniform((2, 2), dtype="float32")) fn2 = aesara.function([], random.uniform((3, 3), nstreams=2, dtype="float32")) fn3 = aesara.function([idx], random.uniform(idx, nstreams=3, ndim=1, dtype="float32")) fn1_val0 = fn1() fn1_val1 = fn1() assert not np.allclose(fn1_val0, fn1_val1) fn2_val0 = fn2() fn2_val1 = fn2() assert not np.allclose(fn2_val0, fn2_val1) fn3_val0 = fn3([4]) fn3_val1 = fn3([4]) assert not np.allclose(fn3_val0, fn3_val1) assert fn1_val0.size == 4 assert fn2_val0.size == 9 random.seed(new_seed) fn1_val2 = fn1() fn1_val3 = fn1() fn2_val2 = fn2() fn2_val3 = fn2() fn3_val2 = fn3([4]) fn3_val3 = fn3([4]) assert np.allclose(fn1_val0, fn1_val2) == same assert np.allclose(fn1_val1, fn1_val3) == same assert np.allclose(fn2_val0, fn2_val2) == same assert np.allclose(fn2_val1, fn2_val3) == same assert np.allclose(fn3_val0, fn3_val2) == same assert np.allclose(fn3_val1, fn3_val3) == same
def test__getitem__AdvancedSubtensor_bool(): x = tt.matrix("x") i = tt.type.TensorType("bool", (False, False))("i") z = x[i] op_types = [type(node.op) for node in aesara.gof.graph.io_toposort([x, i], [z])] assert op_types[-1] == AdvancedSubtensor i = tt.type.TensorType("bool", (False,))("i") z = x[:, i] op_types = [type(node.op) for node in aesara.gof.graph.io_toposort([x, i], [z])] assert op_types[-1] == AdvancedSubtensor i = tt.type.TensorType("bool", (False,))("i") z = x[..., i] op_types = [type(node.op) for node in aesara.gof.graph.io_toposort([x, i], [z])] assert op_types[-1] == AdvancedSubtensor with pytest.raises(TypeError): z = x[[True, False], i] z = x[tt.ivector("b"), i] op_types = [type(node.op) for node in aesara.gof.graph.io_toposort([x, i], [z])] assert op_types[-1] == AdvancedSubtensor
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 Aesara 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_mlp(): """ Demonstrate stochastic gradient descent optimization for a multilayer perceptron This is demonstrated on MNIST. :type learning_rate: float :param learning_rate: learning rate used (factor for the stochastic gradient :type n_epochs: int :param n_epochs: maximal number of epochs to run the optimizer :type dataset: string :param dataset: the path of the MNIST dataset file from http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz """ datasets = gen_data() train_set_x, train_set_y = datasets[0] valid_set_x, valid_set_y = datasets[1] test_set_x, test_set_y = datasets[2] batch_size = 100 # size of the minibatch # compute number of minibatches for training, validation and testing # n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size # n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] / batch_size # n_test_batches = test_set_x.get_value(borrow=True).shape[0] / batch_size ###################### # BUILD ACTUAL MODEL # ###################### # print '... building the model' # allocate symbolic variables for the data index = tt.lscalar() # index to a [mini]batch x = tt.matrix("x") # the data is presented as rasterized images y = tt.ivector("y") # the labels are presented as 1D vector of # [int] labels rng = np.random.RandomState(1234) # construct the MLP class classifier = MLP(rng=rng, input=x, n_in=28 * 28, n_hidden=500, n_out=10) # the cost we minimize during training is the negative log likelihood of # the model. # We take the mean of the cost over each minibatch. cost = classifier.negative_log_likelihood(y).mean() # compute the gradient of cost with respect to theta (stored in params) # the resulting gradients will be stored in a list gparams gparams = [] for param in classifier.params: gparam = tt.grad(cost, param) gparams.append(gparam) # Some optimizations needed are tagged with 'fast_run' # TODO: refine that and include only those mode = aesara.compile.get_default_mode().including("fast_run") updates2 = OrderedDict() updates2[classifier.hiddenLayer.params[0]] = tt.grad( cost, classifier.hiddenLayer.params[0]) train_model = aesara.function( inputs=[index], updates=updates2, givens={ x: train_set_x[index * batch_size:(index + 1) * batch_size], y: train_set_y[index * batch_size:(index + 1) * batch_size], }, mode=mode, ) # print 'MODEL 1' # aesara.printing.debugprint(train_model, print_type=True) assert any([ isinstance(i.op, tt.nnet.CrossentropySoftmax1HotWithBiasDx) for i in train_model.maker.fgraph.toposort() ]) # Even without FeatureShape train_model = aesara.function( inputs=[index], updates=updates2, mode=mode.excluding("ShapeOpt"), givens={ x: train_set_x[index * batch_size:(index + 1) * batch_size], y: train_set_y[index * batch_size:(index + 1) * batch_size], }, ) # print # print 'MODEL 2' # aesara.printing.debugprint(train_model, print_type=True) assert any([ isinstance(i.op, tt.nnet.CrossentropySoftmax1HotWithBiasDx) for i in train_model.maker.fgraph.toposort() ])