Merge pull request #6505 from abergeron/fix_bb

theano/tensor/tests/_test_mpi_roundtrip.py

@@ -4,6 +4,7 @@ from __future__ import absolute_import, print_function, division
 
 from mpi4py import MPI
 import theano
+from theano.configparser import change_flags
 from theano.tensor.io import send, recv, mpi_cmps
 from theano.gof.sched import sort_schedule_fn
 import numpy as np
@@ -27,30 +28,31 @@ scheduler = sort_schedule_fn(*mpi_cmps)
 mode = theano.Mode(optimizer=None,
                    linker=theano.OpWiseCLinker(schedule=scheduler))
 
-if rank == 0:
-    x = theano.tensor.matrix('x', dtype=dtype)
-    y = x + 1
-    send_request = send(y, 1, 11)
+with change_flags(compute_test_value='off'):
+    if rank == 0:
+        x = theano.tensor.matrix('x', dtype=dtype)
+        y = x + 1
+        send_request = send(y, 1, 11)
 
-    z = recv(shape, dtype, 1, 12)
+        z = recv(shape, dtype, 1, 12)
 
-    f = theano.function([x], [send_request, z], mode=mode)
+        f = theano.function([x], [send_request, z], mode=mode)
 
-    xx = np.random.rand(*shape).astype(dtype)
-    expected = (xx + 1) * 2
+        xx = np.random.rand(*shape).astype(dtype)
+        expected = (xx + 1) * 2
 
-    _, zz = f(xx)
+        _, zz = f(xx)
 
-    same = np.linalg.norm(zz - expected) < .001
-    # The parent test will look for "True" in the output
-    stdout.write(str(same))
+        same = np.linalg.norm(zz - expected) < .001
+        # The parent test will look for "True" in the output
+        stdout.write(str(same))
 
-if rank == 1:
+    if rank == 1:
 
-    y = recv(shape, dtype, 0, 11)
-    z = y * 2
-    send_request = send(z, 0, 12)
+        y = recv(shape, dtype, 0, 11)
+        z = y * 2
+        send_request = send(z, 0, 12)
 
-    f = theano.function([], send_request, mode=mode)
+        f = theano.function([], send_request, mode=mode)
 
-    f()
+        f()

theano/tensor/tests/test_basic.py

@@ -4431,12 +4431,12 @@ class T_Join_and_Split(unittest.TestCase):
                 assert not isinstance(node.op, type(self.join_op))
 
         # Test dim 1
-        z = self.join_op(1, x1, x2, x3)
-        f = theano.function([], z.shape, mode=self.mode)
-        topo = f.maker.fgraph.toposort()
         x1.set_value(get_mat(3, 4))
         x2.set_value(get_mat(3, 4))
         x3.set_value(get_mat(3, 5))
+        z = self.join_op(1, x1, x2, x3)
+        f = theano.function([], z.shape, mode=self.mode)
+        topo = f.maker.fgraph.toposort()
         out = f()
         assert (out == [3, 13]).all()
 

theano/tensor/tests/test_mpi.py

@@ -47,7 +47,7 @@ def test_mpi_roundtrip():
         raise SkipTest('MPI not enabled')
     theano_root = theano.__file__.split('__init__')[0]
     env = os.environ.copy()
-    flags = env['THEANO_FLAGS']
+    flags = env.get('THEANO_FLAGS', '')
     keep_flags = ','.join((f for f in flags.split(',') if not f.startswith('init_gpu_device')))
     env['THEANO_FLAGS'] = keep_flags
     p = subprocess.Popen("mpiexec -np 2 python " + theano_root +

theano/tensor/tests/test_subtensor.py

@@ -421,47 +421,48 @@ class T_subtensor(unittest.TestCase, utt.TestOptimizationMixin):
         assert_array_equal(numpy_inc_subtensor(numpy_n4, [numpy_n > 2, Ellipsis, 0, 1], 1),
                            inc_subtensor(n4[n > 2, ..., 0, 1], 1).eval())
 
-        # the boolean mask should have the correct shape
-        # - too large, padded with True
-        mask = np.array([True, False, True])
-        self.assertRaises(IndexError, n[mask].eval)
-        self.assertRaises(IndexError, n[mask, ...].eval)
-        self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
-        self.assertRaises(IndexError, inc_subtensor(n[mask, ...], 1).eval)
-        mask = np.array([[True, False, False, True], [False, True, False, True]])
-        self.assertRaises(IndexError, n[mask].eval)
-        self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
-        # - too large, padded with False (this works in NumPy < 0.13.0)
-        mask = np.array([True, False, False])
-        self.assertRaises(IndexError, n[mask].eval)
-        self.assertRaises(IndexError, n[mask, ...].eval)
-        self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
-        self.assertRaises(IndexError, inc_subtensor(n[mask, ...], 1).eval)
-        mask = np.array([[True, False, False, False], [False, True, False, False]])
-        self.assertRaises(IndexError, n[mask].eval)
-        self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
-        # - mask too small (this works in NumPy < 0.13.0)
-        mask = np.array([True])
-        self.assertRaises(IndexError, n[mask].eval)
-        self.assertRaises(IndexError, n[mask, ...].eval)
-        self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
-        self.assertRaises(IndexError, inc_subtensor(n[mask, ...], 1).eval)
-        mask = np.array([[True], [True]])
-        self.assertRaises(IndexError, n[mask].eval)
-        self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
-        # - too many dimensions
-        mask = np.array([[[True, False, False],
-                          [False, True, False]]])
-        self.assertRaises(IndexError, n.__getitem__, mask)
-        self.assertRaises(IndexError, n.__getitem__, mask)
-
-        # special cases: Python bools and bools nested in Python arrays are not supported
-        self.assertRaises(TypeError, n.__getitem__, (True,))
-        self.assertRaises(TypeError, n.__getitem__, (False,))
-        self.assertRaises(TypeError, n.__getitem__, (True, False))
-        self.assertRaises(TypeError, n.__getitem__, ([True, False]))
-        self.assertRaises(TypeError, n.__getitem__, ([0, 1], [0, False]))
-        self.assertRaises(TypeError, n.__getitem__, ([0, 1], [0, theano.shared(True)]))
+        with change_flags(compute_test_value='off'):
+            # the boolean mask should have the correct shape
+            # - too large, padded with True
+            mask = np.array([True, False, True])
+            self.assertRaises(IndexError, n[mask].eval)
+            self.assertRaises(IndexError, n[mask, ...].eval)
+            self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
+            self.assertRaises(IndexError, inc_subtensor(n[mask, ...], 1).eval)
+            mask = np.array([[True, False, False, True], [False, True, False, True]])
+            self.assertRaises(IndexError, n[mask].eval)
+            self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
+            # - too large, padded with False (this works in NumPy < 0.13.0)
+            mask = np.array([True, False, False])
+            self.assertRaises(IndexError, n[mask].eval)
+            self.assertRaises(IndexError, n[mask, ...].eval)
+            self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
+            self.assertRaises(IndexError, inc_subtensor(n[mask, ...], 1).eval)
+            mask = np.array([[True, False, False, False], [False, True, False, False]])
+            self.assertRaises(IndexError, n[mask].eval)
+            self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
+            # - mask too small (this works in NumPy < 0.13.0)
+            mask = np.array([True])
+            self.assertRaises(IndexError, n[mask].eval)
+            self.assertRaises(IndexError, n[mask, ...].eval)
+            self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
+            self.assertRaises(IndexError, inc_subtensor(n[mask, ...], 1).eval)
+            mask = np.array([[True], [True]])
+            self.assertRaises(IndexError, n[mask].eval)
+            self.assertRaises(IndexError, inc_subtensor(n[mask], 1).eval)
+            # - too many dimensions
+            mask = np.array([[[True, False, False],
+                              [False, True, False]]])
+            self.assertRaises(IndexError, n.__getitem__, mask)
+            self.assertRaises(IndexError, n.__getitem__, mask)
+
+            # special cases: Python bools and bools nested in Python arrays are not supported
+            self.assertRaises(TypeError, n.__getitem__, (True,))
+            self.assertRaises(TypeError, n.__getitem__, (False,))
+            self.assertRaises(TypeError, n.__getitem__, (True, False))
+            self.assertRaises(TypeError, n.__getitem__, ([True, False]))
+            self.assertRaises(TypeError, n.__getitem__, ([0, 1], [0, False]))
+            self.assertRaises(TypeError, n.__getitem__, ([0, 1], [0, theano.shared(True)]))
 
     def test_newaxis(self):
         # newaxis support comes from logic in the __getitem__ of TensorType

theano/tests/test_gradient.py

@@ -9,7 +9,7 @@ import numpy as np
 from six.moves import xrange
 
 import theano
-from theano import gof
+from theano import gof, change_flags
 from theano.compat import izip
 from theano.tests import unittest_tools as utt
 
@@ -803,6 +803,7 @@ def test_grad_scale():
     assert np.allclose(out, (8, 4))
 
 
+@change_flags(compute_test_value='off')
 def test_undefined_grad_opt():
     # Make sure that undefined grad get removed in optimized graph.
     random = RandomStreams(np.random.randint(1, 2147462579))