Crash fix in GpuIncSubtensor andd make *subtensor* tests use the GPU mode more frequently.

theano/gpuarray/subtensor.py

@@ -232,7 +232,7 @@ class GpuIncSubtensor(IncSubtensor):
             if not self.set_instead_of_inc:
                 # sub_x += y
                 iadd = get_iadd(node.inputs[0], node.inputs[1])
-                iadd(sub_x, y, broadcast=False)
+                iadd(sub_x, y)
             else:
                 # sub_x[...] = y
                 x.__setitem__(cdata, y)

theano/tensor/tests/test_subtensor.py

@@ -524,10 +524,11 @@ class T_subtensor(unittest.TestCase, utt.TestOptimizationMixin):
             gn = theano.grad(t.sum(), n)
             g = self.function([], gn, op=self.adv_incsub1)
             utt.verify_grad(lambda m: m[[1, 3]],
-                            [np.random.rand(5, 5).astype(self.dtype)])
+                            [np.random.rand(5, 5).astype(self.dtype)],
+                            mode=self.mode)
             g()
             utt.verify_grad(lambda m: m[idx],
-                            [data])
+                            [data], mode=self.mode)
 
     def test_noncontiguous_idx(self):
         data = rand(4, 2, 3)
@@ -597,17 +598,20 @@ class T_subtensor(unittest.TestCase, utt.TestOptimizationMixin):
         self.assertTrue(np.allclose(g_00, 2))
 
         utt.verify_grad(lambda m: m[[1, 3]],
-                        [np.random.rand(5, 5).astype(self.dtype)])
+                        [np.random.rand(5, 5).astype(self.dtype)],
+                        mode=self.mode)
 
         def fun(x, y):
             return advanced_inc_subtensor1(x, y, [1, 3])
         utt.verify_grad(fun, [np.random.rand(5, 5).astype(self.dtype),
-                              np.random.rand(2, 5).astype(self.dtype)])
+                              np.random.rand(2, 5).astype(self.dtype)],
+                        mode=self.mode)
 
         def fun(x, y):
             return advanced_set_subtensor1(x, y, [1, 3])
         utt.verify_grad(fun, [np.random.rand(5, 5).astype(self.dtype),
-                              np.random.rand(2, 5).astype(self.dtype)])
+                              np.random.rand(2, 5).astype(self.dtype)],
+                        mode=self.mode)
 
         # test set_subtensor broadcast
         self.dtype = 'float32'
@@ -872,12 +876,12 @@ class T_subtensor(unittest.TestCase, utt.TestOptimizationMixin):
 
             def fct(t):
                 return theano.tensor.sum(t[idx_])
-            utt.verify_grad(fct, [data])
+            utt.verify_grad(fct, [data], mode=self.mode)
 
             # Test the grad of the grad (e.i. AdvancedIncSubtensor1.grad)
             def fct2(t):
                 return theano.tensor.grad(theano.tensor.sum(t[idx_]), t)
-            utt.verify_grad(fct2, [data])
+            utt.verify_grad(fct2, [data], mode=self.mode)
 
             # Test shape of AdvancedIncSubtensor1 and AdvancedSubtensor1
             if not self.fast_compile:
@@ -958,7 +962,8 @@ class T_subtensor(unittest.TestCase, utt.TestOptimizationMixin):
         # vector
         utt.verify_grad(
             inc_slice(slice(2, 4, None)),
-            (np.asarray([0, 1, 2, 3, 4, 5.]), np.asarray([9, 9.]),))
+            (np.asarray([0, 1, 2, 3, 4, 5.]), np.asarray([9, 9.]),),
+            mode=self.mode)
 
         # matrix
         utt.verify_grad(
@@ -1640,17 +1645,20 @@ class TestAdvancedSubtensor(unittest.TestCase):
         self.assertTrue(isinstance(t.owner.op, tensor.AdvancedSubtensor))
 
         utt.verify_grad(lambda m: m[[1, 3], [2, 4]],
-                        [np.random.rand(5, 5).astype(self.dtype)])
+                        [np.random.rand(5, 5).astype(self.dtype)],
+                        mode=self.mode)
 
         def fun(x, y):
             return advanced_inc_subtensor(x, y, [1, 3], [2, 4])
         utt.verify_grad(fun, [np.random.rand(5, 5).astype(self.dtype),
-                              np.random.rand(2).astype(self.dtype)])
+                              np.random.rand(2).astype(self.dtype)],
+                        mode=self.mode)
 
         def fun(x, y):
             return advanced_set_subtensor(x, y, [1, 3], [2, 4])
         utt.verify_grad(fun, [np.random.rand(5, 5).astype(self.dtype),
-                              np.random.rand(2).astype(self.dtype)])
+                              np.random.rand(2).astype(self.dtype)],
+                        mode=self.mode)
 
 
 class TestInferShape(utt.InferShapeTester):