Merge pull request #2683 from nouiz/partial_revert_5ed8d923

theano/sandbox/cuda/opt.py

@@ -2055,6 +2055,12 @@ def local_gpu_extract_diagonal(node):
                 gpu_from_host(diag_node.inputs[0]))]
     return False
 
+def typeConstructor(broadcastable, dtype):
+    if dtype == 'float32':
+        return CudaNdarrayType(broadcastable=broadcastable)
+    else:
+        return tensor.TensorType(broadcastable=broadcastable, dtype=dtype)
+
 @register_opt('scan')
 @local_optimizer([gpu_from_host, scan_op.Scan])
 def gpuScanOptimization(node):
@@ -2114,7 +2120,9 @@ def gpuScanOptimization(node):
 
             nw_op = scan_op.Scan(scan_ins,
                                  scan_outs,
-                                 info).make_node(*nw_ins)
+                                 info,
+                                 typeConstructor=typeConstructor).make_node(
+                                     *nw_ins)
             _outputs = nw_op.outputs
             return _outputs
 
@@ -2160,7 +2168,8 @@ def gpuScanOptimization(node):
             _outputs = scan_op.Scan(
                 scan_ins,
                 scan_outs,
-                info).make_node(*nw_ins).outputs
+                info,
+                typeConstructor=typeConstructor).make_node(*nw_ins).outputs
             outputs = []
             for x, y in zip(_outputs, node.outputs):
                 if isinstance(y.type, CudaNdarrayType):
@@ -2172,7 +2181,8 @@ def gpuScanOptimization(node):
 
 
 optdb.register('gpu_scanOp_make_inplace',
-               scan_opt.ScanInplaceOptimizer(gpu_flag=True),
+               scan_opt.ScanInplaceOptimizer(typeConstructor=typeConstructor,
+                                             gpu_flag=True),
                75,
                'gpu',
                'fast_run',

theano/sandbox/gpuarray/opt.py

@@ -716,11 +716,13 @@ def local_scan_to_gpua(node):
     _cmodule_key = gof.CLinker().cmodule_key_(local_fgraph, [])
     info['gpu_hash'] = hash(_cmodule_key)
 
-    nw_op = scan_op.Scan(scan_ins, scan_outs, info).make_node(*nw_ins)
+    nw_op = scan_op.Scan(scan_ins, scan_outs, info,
+                         typeConstructor=GpuArrayType).make_node(*nw_ins)
     return nw_op.outputs
 
 optdb.register('gpua_scanOp_make_inplace',
-               scan_opt.ScanInplaceOptimizer(gpua_flag=True),
+               scan_opt.ScanInplaceOptimizer(typeConstructor=GpuArrayType,
+                                             gpua_flag=True),
                75,
                'gpua',
                'fast_run',

theano/sandbox/gpuarray/tests/test_scan.py

@@ -15,7 +15,6 @@ from theano.sandbox.gpuarray.tests.test_basic_ops import mode_with_gpu
 class T_Scan(TestCase):
     def setUp(self):
         utt.seed_rng()
-        super(T_Scan, self).setUp()
 
     def test_one_sequence_one_output_weights_gpu1(self):
         def f_rnn(u_t, x_tm1, W_in, W):

theano/scan_module/scan_op.py

@@ -49,6 +49,7 @@ class Scan(PureOp):
                  inputs,
                  outputs,
                  info,
+                 typeConstructor=None,
                 ):
         """
         :param inputs: inputs of the inner function of scan
@@ -57,6 +58,21 @@ class Scan(PureOp):
             the scan op (like number of different types of
             arguments, name, mode, if it should run on GPU or
             not, etc.)
+        :param typeConstructor: function that constructs an equivalent
+            to Theano TensorType
+
+
+        Note: ``typeConstructor`` had been added to refactor how
+        Theano deals with the GPU. If it runs on the GPU, scan needs
+        to construct certain outputs (those who reside in the GPU
+        memory) as the GPU-specific type.  However we can not import
+        gpu code in this file (as it is in sandbox, and not available
+        on each machine) so the workaround is that the GPU
+        optimization passes to the constructor of this class a
+        function that is able to construct a GPU type. This way the
+        class Scan does not need to be aware of the details for the
+        GPU, it just constructs any tensor using this function (which
+        by default constructs normal tensors).
         """
         if 'gpua' not in info:
             info['gpua'] = False
@@ -72,13 +88,19 @@ class Scan(PureOp):
         self.output_types = []
         idx = 0
         jdx = 0
+        tensorConstructor = lambda broadcastable, dtype: TensorType(
+            broadcastable=broadcastable, dtype=dtype)
+        if typeConstructor is None:
+            typeConstructor = tensorConstructor
 
         while idx < self.n_mit_mot_outs:
             # Not that for mit_mot there are several output slices per
             # output sequence
             o = outputs[idx]
             self.output_types.append(
-                o.type.clone(broadcastable=(False,) + o.type.broadcastable))
+                typeConstructor(
+                    broadcastable=(False,) + o.type.broadcastable,
+                    dtype=o.type.dtype))
 
             idx += len(self.mit_mot_out_slices[jdx])
             jdx += 1
@@ -88,7 +110,9 @@ class Scan(PureOp):
 
         for o in outputs[idx:end]:
             self.output_types.append(
-                o.type.clone(broadcastable=(False,) + o.type.broadcastable))
+                typeConstructor(
+                    broadcastable=(False,) + o.type.broadcastable,
+                    dtype=o.type.dtype))
 
         # shared outputs + possibly the ending condition
         for o in outputs[end:]:

theano/scan_module/scan_opt.py

@@ -916,8 +916,9 @@ class PushOutScanOutput(gof.Optimizer):
 
 class ScanInplaceOptimizer(Optimizer):
     """Graph optimizer for Scan(makes it run inplace)"""
-    def __init__(self, gpu_flag=False, gpua_flag=False):
+    def __init__(self, typeConstructor=None, gpu_flag=False, gpua_flag=False):
         Optimizer.__init__(self)
+        self.typeConstructor = typeConstructor
         self.gpu_flag = gpu_flag
         self.gpua_flag = gpua_flag
 
@@ -959,7 +960,8 @@ class ScanInplaceOptimizer(Optimizer):
                 inputs = ls_begin + ls + ls_end
                 new_op = scan_op.Scan(op.inputs,
                                       op.outputs,
-                                      info)
+                                      info,
+                                      typeConstructor=self.typeConstructor)
 
                 # Do not call make_node for test_value
                 new_outs = new_op(*inputs, **dict(return_list=True))
@@ -2085,7 +2087,8 @@ scan_eqopt2 = theano.gof.EquilibriumDB()
 optdb.register('scan_eqopt1', scan_eqopt1, .1, 'fast_run', 'scan')
 optdb.register('scan_eqopt2', scan_eqopt2, 1.6, 'fast_run', 'scan')
 optdb.register('scanOp_make_inplace',
-               ScanInplaceOptimizer(),
+               ScanInplaceOptimizer(typeConstructor=None,
+                                    gpu_flag=False),
                75,
                'fast_run',
                'inplace',

theano/scan_module/scan_utils.py

@@ -55,9 +55,24 @@ def safe_new(x, tag='', dtype=None):
             return nwx
         else:
             return x.clone()
-
-    # at this point we should only have Variables
-    assert isinstance(x, theano.Variable)
+    # Note, as_tensor_variable will convert the Scalar into a
+    # TensorScalar that will require a ScalarFromTensor op,
+    # making the pushout optimization fail
+    elif isinstance(x, scalar.ScalarVariable):
+        if dtype:
+            nw_x = scalar.get_scalar_type(dtype=dtype)()
+        else:
+            nw_x = x.type()
+        nw_x.name = nw_name
+        return nw_x
+    else:
+        try:
+            x = tensor.as_tensor_variable(x)
+        except TypeError:
+            # This could happen for example for random states, and I really
+            # want to avoid the convoluted logic that checks for cuda
+            # ndarrays
+            pass
     nw_x = x.type()
     if dtype and nw_x.dtype != dtype:
         nw_x = nw_x.astype(dtype).type()