Merge pull request #3804 from nouiz/tests

theano/compile/debugmode.py

@@ -2043,7 +2043,7 @@ class _Linker(gof.link.LocalLinker):
                                       "output storage", i)
                         try:
                             thunk_py()
-                        except utils.MethodNotDefined:
+                        except (utils.MethodNotDefined, NotImplementedError):
                             # shouldn't have put it into the list in
                             # the first place
                             thunk_py = None

theano/sandbox/multinomial.py

@@ -172,13 +172,12 @@ class MultinomialFromUniform(Op):
 
         nb_multi = pvals.shape[0]
         nb_outcomes = pvals.shape[1]
-
         # For each multinomial, loop over each possible outcome
         for c in range(n_samples):
             for n in range(nb_multi):
                 waiting = True
                 cummul = 0
-                unis_n = unis[n]
+                unis_n = unis[c * nb_multi + n]
 
                 for m in range(nb_outcomes):
                     cummul += pvals[n, m]

theano/sandbox/tests/test_multinomial.py

@@ -8,11 +8,11 @@ from theano.sandbox import multinomial
 from theano.compile.mode import get_default_mode, predefined_linkers
 import theano.sandbox.cuda as cuda
 import theano.tests.unittest_tools as utt
-import six.moves.cPickle as pickle
 import os
 from theano.compat import PY3
 from theano.misc.pkl_utils import CompatUnpickler
 
+
 def get_mode(gpu):
     mode = get_default_mode()
     mode = copy.copy(mode)
@@ -37,14 +37,14 @@ def test_n_samples_1():
     u = tensor.fvector()
     n = tensor.iscalar()
     m = multinomial.MultinomialFromUniform('auto')(p, u, n)
-    
+
     f = function([p, u, n], m, allow_input_downcast=True)
 
     numpy.random.seed(12345)
     for i in [1, 5, 10, 100, 1000, 10000]:
-        uni = numpy.random.rand(2*i).astype(config.floatX)
+        uni = numpy.random.rand(2 * i).astype(config.floatX)
         res = f([[1.0, 0.0], [0.0, 1.0]], uni, i)
-        utt.assert_allclose(res, [[i*1.0, 0.0], [0.0, i*1.0]])
+        utt.assert_allclose(res, [[i * 1.0, 0.0], [0.0, i * 1.0]])
 
 
 def test_n_samples_2():
@@ -52,24 +52,26 @@ def test_n_samples_2():
     u = tensor.fvector()
     n = tensor.iscalar()
     m = multinomial.MultinomialFromUniform('auto')(p, u, n)
-    
+
     f = function([p, u, n], m, allow_input_downcast=True)
 
     numpy.random.seed(12345)
     for i in [1, 5, 10, 100, 1000]:
         uni = numpy.random.rand(i).astype(config.floatX)
-        pvals = numpy.random.randint(1,1000,(1,1000)).astype(config.floatX)
+        pvals = numpy.random.randint(1, 1000, (1, 1000)).astype(config.floatX)
         pvals /= pvals.sum(1)
         res = f(pvals, uni, i)
         assert res.sum() == i
 
     for i in [1, 5, 10, 100, 1000]:
         uni = numpy.random.rand(i).astype(config.floatX)
-        pvals = numpy.random.randint(1,1000000,(1,1000000)).astype(config.floatX)
+        pvals = numpy.random.randint(
+            1, 1000000, (1, 1000000)).astype(config.floatX)
         pvals /= pvals.sum(1)
         res = f(pvals, uni, i)
         assert res.sum() == i
 
+
 def test_n_samples_compatibility():
     """
     This test checks if the new change to MultinomialFromUniform is still compatible
@@ -83,28 +85,30 @@ def test_n_samples_compatibility():
     pickle.dump([X, samples], open("multinomial_test_graph.pkl", "w"))
     """
     folder = os.path.dirname(os.path.abspath(__file__))
-    with open(os.path.join(folder, "multinomial_test_graph.pkl"), "rb") as pkl_file:
+    with open(os.path.join(folder, "multinomial_test_graph.pkl"),
+              "rb") as pkl_file:
         if PY3:
             u = CompatUnpickler(pkl_file, encoding="latin1")
         else:
             u = CompatUnpickler(pkl_file)
         X, samples = u.load()
         f = theano.function([X], samples)
-        res = f(numpy.random.randn(20,10))
+        res = f(numpy.random.randn(20, 10))
         assert numpy.all(res.sum(axis=1) == 1)
 
+
 def test_multinomial_0():
     # This tests the MultinomialFromUniform Op directly, not going through the
     # multinomial() call in GPU random generation.
 
     p = tensor.fmatrix()
     u = tensor.fvector()
-    
+
     m = multinomial.MultinomialFromUniform('auto')(p, u)
 
     def body(mode, gpu):
         # the m*2 allows the multinomial to reuse output
-        f = function([p, u], m*2, allow_input_downcast=True, mode=mode)
+        f = function([p, u], m * 2, allow_input_downcast=True, mode=mode)
 
         if gpu:
             assert any([type(node.op) is multinomial.GpuMultinomialFromUniform
@@ -112,7 +116,7 @@ def test_multinomial_0():
 
         # test that both first and second samples can be drawn
         utt.assert_allclose(f([[1, 0], [0, 1]], [.1, .1]),
-                              [[2, 0], [0, 2]])
+                            [[2, 0], [0, 2]])
 
         # test that both second labels can be drawn
         r = f([[.2, .8], [.3, .7]], [.31, .31])
@@ -140,12 +144,12 @@ def test_multinomial_large():
         p = tensor.fmatrix()
         u = tensor.fvector()
         m = multinomial.MultinomialFromUniform('auto')(p, u)
-        f = function([p, u], m*2, allow_input_downcast=True, mode=mode)
+        f = function([p, u], m * 2, allow_input_downcast=True, mode=mode)
         if gpu:
             assert any([type(node.op) is multinomial.GpuMultinomialFromUniform
                         for node in f.maker.fgraph.toposort()])
 
-        pval = numpy.arange(10000 * 4, dtype='float32').reshape((10000, 4))+0.1
+        pval = numpy.arange(10000 * 4, dtype='float32').reshape((10000, 4)) + 0.1
         pval = pval / pval.sum(axis=1)[:, None]
         uval = numpy.ones_like(pval[:, 0]) * 0.5
         mval = f(pval, uval)
@@ -160,7 +164,7 @@ def test_multinomial_large():
         else:
             raise NotImplementedError(config.cast_policy)
         utt.assert_allclose(mval.sum(axis=1), 2)
-        asdf = numpy.asarray([0, 0, 2, 0])+0*pval
+        asdf = numpy.asarray([0, 0, 2, 0]) + 0 * pval
         utt.assert_allclose(mval, asdf)  # broadcast over all rows
     run_with_c(body)
     if cuda.cuda_available:
@@ -201,10 +205,10 @@ def test_gpu_opt():
     f = function([p, u], m_gpu, allow_input_downcast=True, mode=get_mode(True))
     assert any([type(node.op) is multinomial.GpuMultinomialFromUniform
                 for node in f.maker.fgraph.toposort()])
-    pval = numpy.arange(10000 * 4, dtype='float32').reshape((10000, 4))+0.1
+    pval = numpy.arange(10000 * 4, dtype='float32').reshape((10000, 4)) + 0.1
     pval = pval / pval.sum(axis=1)[:, None]
     uval = numpy.ones_like(pval[:, 0]) * 0.5
-    mval = f(pval, uval)
+    f(pval, uval)
 
     # Test with a row, it was failing in the past.
     r = tensor.frow()
@@ -215,7 +219,7 @@ def test_gpu_opt():
     f = function([r, u], m_gpu, allow_input_downcast=True, mode=get_mode(True))
     assert any([type(node.op) is multinomial.GpuMultinomialFromUniform
                 for node in f.maker.fgraph.toposort()])
-    pval = numpy.arange(1 * 4, dtype='float32').reshape((1, 4))+0.1
+    pval = numpy.arange(1 * 4, dtype='float32').reshape((1, 4)) + 0.1
     pval = pval / pval.sum(axis=1)[:, None]
     uval = numpy.ones_like(pval[:, 0]) * 0.5
-    mval2 = f(pval, uval)
+    f(pval, uval)

theano/sandbox/tests/test_rng_mrg.py

@@ -15,13 +15,12 @@ from theano import tensor, config
 from theano.sandbox import rng_mrg
 from theano.sandbox.rng_mrg import MRG_RandomStreams
 from theano.sandbox.cuda import cuda_available
+from theano.tests import unittest_tools as utt
+from theano.tests.unittest_tools import attr
 
 if cuda_available:
     from theano.sandbox.cuda import float32_shared_constructor
 
-from theano.tests import unittest_tools as utt
-from theano.tests.unittest_tools import attr
-
 # TODO: test gpu
 # Done in test_consistency_GPU_{serial,parallel}
 
@@ -474,8 +473,8 @@ def basictest(f, steps, sample_size, prefix="", allow_01=False, inputs=None,
         else:
             alpha = 1.0 / (1 + i)
             mean = alpha * ival + (1 - alpha) * mean
-            avg_var = (alpha * numpy.mean((ival - target_avg) ** 2)
-                       + (1 - alpha) * avg_var)
+            avg_var = (alpha * numpy.mean((ival - target_avg) ** 2) +
+                       (1 - alpha) * avg_var)
             min_ = min(min_, ival.min())
             max_ = max(max_, ival.max())
         if not allow_01:
@@ -487,8 +486,9 @@ def basictest(f, steps, sample_size, prefix="", allow_01=False, inputs=None,
         # print prefix, 'mean diff with mean', diff
         assert numpy.all(diff < mean_rtol * (1 + abs(target_avg))), (
             'bad mean? %s %s' % (mean, target_avg))
-    else:  # if target_avg is a scalar, then we can do the mean of
-           # `mean` to get something more precise
+    else:
+        # if target_avg is a scalar, then we can do the mean of
+        # `mean` to get something more precise
         mean = numpy.mean(mean)
         # print prefix, 'mean', mean
         assert abs(mean - target_avg) < mean_rtol * (1 + abs(target_avg)), (
@@ -507,13 +507,13 @@ def basictest(f, steps, sample_size, prefix="", allow_01=False, inputs=None,
 
 
 def test_uniform():
-# TODO: test param low, high
-# TODO: test size=None
-# TODO: test ndim!=size.ndim
-# TODO: test bad seed
-# TODO: test size=Var, with shape that change from call to call
+    # TODO: test param low, high
+    # TODO: test size=None
+    # TODO: test ndim!=size.ndim
+    # TODO: test bad seed
+    # TODO: test size=Var, with shape that change from call to call
     if (mode in ['DEBUG_MODE', 'DebugMode', 'FAST_COMPILE'] or
-        mode == 'Mode' and config.linker in ['py']):
+            mode == 'Mode' and config.linker in ['py']):
         sample_size = (10, 100)
         steps = 50
     else:
@@ -531,7 +531,7 @@ def test_uniform():
             ((), (), [], []),
             ]:
 
-        #### TEST CPU IMPLEMENTATION ####
+        # TEST CPU IMPLEMENTATION
         # The python and C implementation are tested with DebugMode
         # print ''
         # print 'ON CPU with size=(%s):' % str(size)
@@ -598,16 +598,16 @@ def test_uniform():
 
 @attr('slow')
 def test_binomial():
-# TODO: test size=None, ndim=X
-# TODO: test size=X, ndim!=X.ndim
-# TODO: test random seed in legal value(!=0 and other)
-# TODO: test sample_size not a multiple of guessed #streams
-# TODO: test size=Var, with shape that change from call to call
-# we test size in a tuple of int and a tensor.shape.
-# we test the param p with int.
+    # TODO: test size=None, ndim=X
+    # TODO: test size=X, ndim!=X.ndim
+    # TODO: test random seed in legal value(!=0 and other)
+    # TODO: test sample_size not a multiple of guessed #streams
+    # TODO: test size=Var, with shape that change from call to call
+    # we test size in a tuple of int and a tensor.shape.
+    # we test the param p with int.
 
     if (mode in ['DEBUG_MODE', 'DebugMode', 'FAST_COMPILE'] or
-        mode == 'Mode' and config.linker in ['py']):
+            mode == 'Mode' and config.linker in ['py']):
         sample_size = (10, 50)
         steps = 50
         rtol = 0.02
@@ -617,7 +617,6 @@ def test_binomial():
         rtol = 0.01
 
     x = tensor.matrix()
-    v = tensor.vector()
     for mean in [0.1, 0.5]:
         for size, const_size, var_input, input in [
                 (sample_size, sample_size, [], []),
@@ -653,8 +652,8 @@ def t_binomial(mean, size, const_size, var_input, input, steps, rtol):
         # well, it's really that this test w GPU doesn't make sense otw
         assert u.dtype == 'float32'
         f = theano.function(var_input, theano.Out(
-                theano.sandbox.cuda.basic_ops.gpu_from_host(u),
-                borrow=True), mode=mode_with_gpu)
+            theano.sandbox.cuda.basic_ops.gpu_from_host(u),
+            borrow=True), mode=mode_with_gpu)
         gpu_out = numpy.asarray(f(*input))
 
         basictest(f, steps_, const_size, prefix='mrg  gpu',
@@ -678,7 +677,7 @@ def test_normal0():
     steps = 50
     std = 2.
     if (mode in ['DEBUG_MODE', 'DebugMode', 'FAST_COMPILE'] or
-        mode == 'Mode' and config.linker in ['py']):
+            mode == 'Mode' and config.linker in ['py']):
         sample_size = (25, 30)
         default_rtol = .02
     else:
@@ -788,7 +787,7 @@ def basic_multinomialtest(f, steps, sample_size, target_pvals, n_samples,
     avg_pvals /= (steps * n_samples)
 
     assert numpy.mean(abs(avg_pvals - target_pvals)) < mean_rtol
-    
+
     print('random?[:10]\n', numpy.asarray(f()[:10]))
     print(prefix, 'mean', avg_pvals)
     # < mean_rtol, 'bad mean? %s %s' % (str(avg_pvals), str(target_pvals))
@@ -805,7 +804,7 @@ def test_multinomial():
         mode_ = 'FAST_RUN'
 
     if (mode in ['DEBUG_MODE', 'DebugMode', 'FAST_COMPILE'] or
-        mode == 'Mode' and config.linker in ['py']):
+            mode == 'Mode' and config.linker in ['py']):
         sample_size = (49, 5)
     else:
         sample_size = (450, 6)
@@ -821,7 +820,8 @@ def test_multinomial():
     f = theano.function([], m, mode=mode_)
     # theano.printing.debugprint(f)
     out = f()
-    basic_multinomialtest(f, steps, sample_size, pvals, n_samples=1, prefix='mrg ')
+    basic_multinomialtest(f, steps, sample_size, pvals, n_samples=1,
+                          prefix='mrg ')
 
     sys.stdout.flush()
 
@@ -842,7 +842,8 @@ def test_multinomial():
         # theano.printing.debugprint(f)
         gpu_out = f()
         sys.stdout.flush()
-        basic_multinomialtest(f, steps, sample_size, pvals, n_samples=1, prefix='gpu mrg ')
+        basic_multinomialtest(f, steps, sample_size, pvals, n_samples=1,
+                              prefix='gpu mrg ')
         numpy.testing.assert_array_almost_equal(out, gpu_out, decimal=6)
 
 
@@ -852,7 +853,7 @@ def test_multinomial_n_samples():
         mode_ = 'FAST_RUN'
 
     if (mode in ['DEBUG_MODE', 'DebugMode', 'FAST_COMPILE'] or
-        mode == 'Mode' and config.linker in ['py']):
+            mode == 'Mode' and config.linker in ['py']):
         sample_size = (49, 5)
     else:
         sample_size = (450, 6)
@@ -861,27 +862,31 @@ def test_multinomial_n_samples():
     pvals = numpy.asarray(numpy.random.uniform(size=sample_size))
     pvals = numpy.apply_along_axis(lambda row: row / numpy.sum(row), 1, pvals)
     R = MRG_RandomStreams(234, use_cuda=False)
-    
+
     for n_samples, steps in zip([5, 10, 100, 1000], [20, 10, 1, 1]):
-        m = R.multinomial(pvals=pvals, n=n_samples, dtype=config.floatX, nstreams=30 * 256)
+        m = R.multinomial(pvals=pvals, n=n_samples,
+                          dtype=config.floatX, nstreams=30 * 256)
         f = theano.function([], m, mode=mode_)
-        basic_multinomialtest(f, steps, sample_size, pvals, n_samples, prefix='mrg ')
+        basic_multinomialtest(f, steps, sample_size, pvals,
+                              n_samples, prefix='mrg ')
         sys.stdout.flush()
-        
+
         if mode != 'FAST_COMPILE' and cuda_available:
             R = MRG_RandomStreams(234, use_cuda=True)
             pvals = numpy.asarray(pvals, dtype='float32')
-            n = R.multinomial(pvals=pvals, n=n_samples, dtype='float32', nstreams=30 * 256)
+            n = R.multinomial(pvals=pvals, n=n_samples,
+                              dtype='float32', nstreams=30 * 256)
             assert n.dtype == 'float32'
             f = theano.function(
                 [],
                 theano.sandbox.cuda.basic_ops.gpu_from_host(n),
                 mode=mode_.including('gpu'))
-        
+
             sys.stdout.flush()
-            basic_multinomialtest(f, steps, sample_size, pvals, n_samples, prefix='gpu mrg ')
-        
-        
+            basic_multinomialtest(f, steps, sample_size, pvals,
+                                  n_samples, prefix='gpu mrg ')
+
+
 class T_MRG(unittest.TestCase):
     def test_bad_size(self):
 
@@ -1039,7 +1044,6 @@ def test_seed_fn():
 
 if __name__ == "__main__":
     rng = MRG_RandomStreams(numpy.random.randint(2147462579))
-    import time
     print(theano.__file__)
     pvals = theano.tensor.fmatrix()
     for i in range(10):

theano/scalar/basic.py

@@ -199,7 +199,11 @@ class Scalar(Type):
                 type(data), data, self.dtype), e)
 
     def values_eq_approx(self, a, b, tolerance=1e-4):
-        return abs(a - b) <= ((abs(a) + abs(b)) * tolerance)
+        # The addition have risk of overflow especially with [u]int8
+        diff = a - b
+        if diff == 0:
+            return True
+        return abs(diff) <= (abs(a) * tolerance) + (abs(b) * tolerance)
 
     def c_headers(self, c_compiler):
         l = ['<math.h>']

theano/tensor/elemwise.py

@@ -25,6 +25,7 @@ config = theano.config
 # so we redefine them here
 discrete_dtypes = list(map(str, scalar.discrete_types))
 float_dtypes = list(map(str, scalar.float_types))
+int_dtypes = list(map(str, scalar.int_types))
 
 
 # tensor depends on elemwise to provide definitions for several ops
@@ -811,6 +812,24 @@ class Elemwise(OpenMPOp):
             else:
                 node.tag.ufunc = ufunc
 
+        # Numpy ufuncs will sometimes perform operations in
+        # float16, in particular when the input is int8.
+        # This is not something that we want, and we do not
+        # do it in the C code, so we specify that the computation
+        # should be carried out in the returned dtype.
+        # This is done via the "sig" kwarg of the ufunc, its value
+        # should be something like "ff->f", where the characters
+        # represent the dtype of the inputs and outputs.
+
+        # NumPy 1.10.1 raise an error when giving the signature
+        # when the input is complex. So add it only when inputs is int.
+        out_dtype = node.outputs[0].dtype
+        if (out_dtype in float_dtypes and
+                isinstance(self.nfunc, numpy.ufunc) and
+                node.inputs[0].dtype in int_dtypes):
+            char = numpy.sctype2char(out_dtype)
+            sig = char * node.nin + '->' + char * node.nout
+            node.tag.sig = sig
         return super(Elemwise, node_.op).make_thunk(node_, storage_map,
                                                     compute_map, no_recycling)
 
@@ -860,19 +879,8 @@ class Elemwise(OpenMPOp):
         if self.nfunc and len(inputs) == self.nfunc_spec[1]:
             ufunc = self.nfunc
             nout = self.nfunc_spec[2]
-            # Numpy ufuncs will sometimes perform operations in
-            # float16, in particular when the input is int8.
-            # This is not something that we want, and we do not
-            # do it in the C code, so we specify that the computation
-            # should be carried out in the returned dtype.
-            # This is done via the "sig" kwarg of the ufunc, its value
-            # should be something like "ff->f", where the characters
-            # represent the dtype of the inputs and outputs.
-            out_dtype = node.outputs[0].dtype
-            if out_dtype in float_dtypes and isinstance(ufunc, numpy.ufunc):
-                char = numpy.sctype2char(out_dtype)
-                sig = char * node.nin + '->' + char * node.nout
-                ufunc_kwargs['sig'] = sig
+            if hasattr(node.tag, 'sig'):
+                ufunc_kwargs['sig'] = node.tag.sig
             # Unfortunately, the else case does not allow us to
             # directly feed the destination arguments to the nfunc
             # since it sometimes requires resizing. Doing this

theano/tensor/nnet/abstract_conv.py

@@ -306,7 +306,7 @@ class AbstractConv2d(BaseAbstractConv2d):
         raise NotImplementedError(
             'AbstractConv2d theano optimization failed. '
             'Did you exclude both "conv_dnn" and "conv_gemm" from '
-            'the optimizer?')
+            'the optimizer? Is cudnn available and does the GPU support it?')
 
     def grad(self, inp, grads):
         bottom, weights = inp

theano/tests/test_flake8.py

@@ -102,9 +102,7 @@ whitelist_flake8 = [
     "sandbox/debug.py",
     "sandbox/tests/test_theano_object.py",
     "sandbox/tests/test_scan.py",
-    "sandbox/tests/test_rng_mrg.py",
     "sandbox/tests/test_neighbourhoods.py",
-    "sandbox/tests/test_multinomial.py",
     "sandbox/tests/__init__.py",
     "sandbox/cuda/var.py",
     "sandbox/cuda/GpuConvGrad3D.py",