Merge pull request #2383 from nouiz/tests

theano/sandbox/cuda/tests/test_dnn.py

@@ -201,10 +201,10 @@ class TestDnnInferShapes(utt.InferShapeTester):
         super(TestDnnInferShapes, self).setUp()
 
     def test_softmax(self):
-        t = T.tensor4('t')
+        t = T.ftensor4('t')
         rand_tensor = numpy.asarray(
             numpy.random.rand(5, 4, 3, 2),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
         self._compile_and_check(
             [t],
@@ -230,15 +230,15 @@ class TestDnnInferShapes(utt.InferShapeTester):
         )
 
     def test_conv(self):
-        img = T.tensor4('img')
-        kerns = T.tensor4('kerns')
+        img = T.ftensor4('img')
+        kerns = T.ftensor4('kerns')
         img_val = numpy.asarray(
             numpy.random.rand(3, 4, 5, 6),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
         kern_vals = numpy.asarray(
             numpy.random.rand(3, 4, 5, 6),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
 
         for params in product(
@@ -260,15 +260,15 @@ class TestDnnInferShapes(utt.InferShapeTester):
             )
 
     def test_conv_gradw(self):
-        img = T.tensor4('img')
-        kerns = T.tensor4('kerns')
+        img = T.ftensor4('img')
+        kerns = T.ftensor4('kerns')
         img_val = numpy.asarray(
             numpy.random.rand(3, 4, 5, 6),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
         kern_vals = numpy.asarray(
             numpy.random.rand(3, 4, 5, 6),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
 
         for params in product(
@@ -306,15 +306,15 @@ class TestDnnInferShapes(utt.InferShapeTester):
             )
 
     def test_conv_gradi(self):
-        img = T.tensor4('img')
-        kerns = T.tensor4('kerns')
+        img = T.ftensor4('img')
+        kerns = T.ftensor4('kerns')
         img_val = numpy.asarray(
             numpy.random.rand(3, 4, 5, 6),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
         kern_vals = numpy.asarray(
             numpy.random.rand(3, 4, 5, 6),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
 
         for params in product(
@@ -349,10 +349,10 @@ class TestDnnInferShapes(utt.InferShapeTester):
             )
 
     def test_pool(self):
-        img = T.tensor4('img')
+        img = T.ftensor4('img')
         img_val = numpy.asarray(
             numpy.random.rand(2, 3, 4, 5),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
         for params in product(
             [(1, 1), (2, 2), (3, 3)],
@@ -372,20 +372,20 @@ class TestDnnInferShapes(utt.InferShapeTester):
             )
 
     def test_pool_grad(self):
-        img = T.tensor4('img')
-        img_grad = T.tensor4('img_grad')
-        out = T.tensor4('out')
+        img = T.ftensor4('img')
+        img_grad = T.ftensor4('img_grad')
+        out = T.ftensor4('out')
         img_val = numpy.asarray(
             numpy.random.rand(2, 3, 4, 5),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
         img_grad_val = numpy.asarray(
             numpy.random.rand(2, 3, 4, 5),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
         out_val = numpy.asarray(
             numpy.random.rand(2, 3, 4, 5),
-            dtype=theano.config.floatX
+            dtype='float32'
         )
 
         for params in product(

theano/sandbox/cuda/tests/test_opt.py

@@ -81,7 +81,7 @@ def test_gpualloc():
     m = (x).dimshuffle(['x', 0])
     v = tensor.alloc(1., *m.shape)
     f = theano.function([], v + x,
-                        mode=mode_with_gpu.excluding("local_alloc_elemwise"))
+                        mode=mode_with_gpu.excluding("local_elemwise_alloc"))
     l = f.maker.fgraph.toposort()
     assert numpy.any([isinstance(x.op, cuda.GpuAlloc) for x in l])
 

theano/tensor/opt.py

@@ -1606,53 +1606,55 @@ compile.optdb['specialize'].register('local_remove_all_assert',
                                      local_remove_all_assert,
                                      use_db_name_as_tag=False)
 
+
 def local_elemwise_alloc_op(ElemwiseOP, AllocOP, DimShuffleOP):
     def local_elemwise_alloc(node):
         """
         elemwise(alloc(x, shp), ..., y.TensorType(BROADCAST CONDITION))
           -> elemwise(x, y.TensorType(BROADCAST CONDITION))
-    
+
         elemwise(dimshuffle(alloc(x, shp)),... ,y.TensorType(BROADCAST CONDITION))
           -> elemwise(x.dimshuffle(...), y.TensorType(BROADCAST CONDITION))
-    
+
         BROADCAST CONDITION: the condition is that the one input that are
         not to be optimized to have the same broadcast pattern as the
         output
-    
+
              We can change the alloc by a dimshuffle as the elemwise
              already have the shape info.  The dimshuffle will be faster
              to exec
         """
         if not isinstance(node.op, ElemwiseOP):
             return False
-    
+
         if len(node.outputs) > 1:
             # Ensure all outputs have the same broadcast pattern
             # This is a supposition that I'm not sure is always true.
             assert all([o.type.broadcastable ==
                         node.outputs[0].type.broadcastable for o in
                         node.outputs[1:]])
-    
-        # The broadcast pattern of the ouptut must match the broadcast pattern of
-        # at least one of the inputs.
+
+        # The broadcast pattern of the ouptut must match the broadcast
+        # pattern of at least one of the inputs.
         if not any([i.type.broadcastable ==
             node.outputs[0].type.broadcastable for i in node.inputs]):
             return False
-    
+
         def dimshuffled_alloc(i):
             return (isinstance(i.owner.op, DimShuffleOP) and
-                         i.owner.inputs[0].owner and
-                             isinstance(i.owner.inputs[0].owner.op, AllocOP))
-    
+                    i.owner.inputs[0].owner and
+                    isinstance(i.owner.inputs[0].owner.op, AllocOP))
+
         # At least one input must have an owner that is either a AllocOP or a
         # DimShuffleOP with an owner that is a AllocOP -- otherwise there is
         # nothing to optimize.
         if not any([i.owner
-                    and (isinstance(i.owner.op, AllocOP) or dimshuffled_alloc(i))
+                    and (isinstance(i.owner.op, AllocOP) or
+                         dimshuffled_alloc(i))
                     for i in node.inputs]):
             return False
-    
-        ## Search for input that we can use as a baseline for the dimensions.
+
+        # Search for input that we can use as a baseline for the dimensions.
         assert_op_idx = -1
         for idx, i in enumerate(node.inputs):
             if i.type.broadcastable == node.outputs[0].type.broadcastable:
@@ -1663,47 +1665,48 @@ def local_elemwise_alloc_op(ElemwiseOP, AllocOP, DimShuffleOP):
                              or dimshuffled_alloc(i))):
                     assert_op_idx = idx
                     break
-    
+
         # It may be the case that only AllocOP and DimShuffleOP of AllocOP exist.
         if assert_op_idx < 0:
-            # We want to optimize as many allocs as possible. When there is more
-            # than one then do all but one.
-            # number of inputs with alloc or dimshuffle alloc
+            # We want to optimize as many allocs as possible. When
+            # there is more than one then do all but one.  number of
+            # inputs with alloc or dimshuffle alloc
             l2 = [i for i in node.inputs
                   if (i.owner and (isinstance(i.owner.op, AllocOP)
                              or dimshuffled_alloc(i)))]
-            # If only 1 alloc or dimshuffle alloc, it is the one we will use for the shape
-            # So no alloc would be removed.
+            # If only 1 alloc or dimshuffle alloc, it is the one we
+            # will use for the shape. So no alloc would be removed.
             if len(l2) > 1:
-                # l containt inputs with alloc or dimshuffle alloc only.
-                # Its length will always be at least one, as we checked that before
+                # l containt inputs with alloc or dimshuffle alloc
+                # only.  Its length will always be at least one, as we
+                # checked that before
                 l = [idx for idx, i in enumerate(node.inputs)
-                     if i.type.broadcastable == node.outputs[0].type.broadcastable]
+                     if i.broadcastable == node.outputs[0].broadcastable]
                 assert_op_idx = l[0]  # The first one is as good as any to use.
             else:
                 # Nothing would be optimized!
                 return False
-    
+
         assert_op = node.inputs[assert_op_idx]
         cmp_op = assert_op
         new_i = []
-    
+
         for i in node.inputs:
             # Remove alloc
             if (i.owner and isinstance(i.owner.op, AllocOP)
                 and i.owner.inputs[0].type != i.owner.outputs[0].type):
                 # when i.owner.inputs[0].type == i.owner.outputs[0].type we
                 # will remove that alloc later
-    
+
                 assert i.type.ndim == cmp_op.ndim
                 if (theano.config.experimental.local_alloc_elemwise_assert
                     and not node.fgraph.shape_feature.same_shape(i, cmp_op)):
                     assert_op = assert_(assert_op,
                                         *[T.eq(i.shape[idx], cmp_op.shape[idx])
-                                              for idx in xrange(i.type.ndim)
-                                              if not i.type.broadcastable[idx]])
+                                          for idx in xrange(i.type.ndim)
+                                          if not i.type.broadcastable[idx]])
                 new_i.append(i.owner.inputs[0])
-    
+
             # Remove Alloc in DimShuffle
             elif i.owner and dimshuffled_alloc(i):
                 assert i.type.ndim == cmp_op.type.ndim
@@ -1719,28 +1722,30 @@ def local_elemwise_alloc_op(ElemwiseOP, AllocOP, DimShuffleOP):
                     # We add a dimshuffle to add them.
                     # We let later optimization merge the multiple dimshuffle
                     nb_dim_to_add = i.owner.inputs[0].ndim - alloc_input.ndim
-                    alloc_input = alloc_input.dimshuffle(['x'] * nb_dim_to_add +
-                                                         range(alloc_input.ndim))
-    
+                    alloc_input = alloc_input.dimshuffle(
+                        ['x'] * nb_dim_to_add +
+                        range(alloc_input.ndim))
+
                 # We need to keep the dimshuffle. It could swap axes or
                 # add dimensions anywhere.
                 new_i.append(i.owner.op(alloc_input))
             else:
                 new_i.append(i)
         new_i[assert_op_idx] = assert_op
-    
+
         return node.op(*new_i, return_list=True)
 
     return local_elemwise_alloc
-    
-#TODO, global optimizer that lift the assert to the beginning of the graph.
-#TODO, optimize all inputs when possible -- currently when all inputs have
+
+# TODO, global optimizer that lift the assert to the beginning of the graph.
+# TODO, optimize all inputs when possible -- currently when all inputs have
 # an alloc all but one is optimized.
 
-local_elemwise_alloc = register_specialize(gof.local_optimizer([T.Elemwise])(
-    local_elemwise_alloc_op(T.Elemwise, T.Alloc, T.DimShuffle)
-))
-        
+local_elemwise_alloc = register_specialize(
+    gof.local_optimizer([T.Elemwise])(
+        local_elemwise_alloc_op(T.Elemwise, T.Alloc, T.DimShuffle)),
+    'local_alloc_elemwise')
+
 theano.configparser.AddConfigVar('experimental.local_alloc_elemwise',
                                  "DEPRECATED: If True, enable the experimental"
                                  " optimization local_alloc_elemwise."