Merge pull request #3186 from nouiz/mixed

doc/library/sandbox/cuda/dnn.txt

@@ -63,6 +63,11 @@ To get an error if Theano can not use cuDNN, use this Theano flag:
     There is a problem we do not understand yet when cudnn paths are
     used with symbolic links. So avoid using that.
 
+.. note::
+
+    cudnn.so* must be readable and executable by everybody.
+    cudnn.h must be readable by everybody.
+
 
 Functions
 =========

doc/tutorial/examples.txt

@@ -465,11 +465,19 @@ There are :ref:`other distributions implemented <libdoc_tensor_raw_random>`.
 Other Implementations
 ---------------------
 
-There is 2 other implementations based on :class:`CURAND
-<theano.sandbox.cuda.rng_curand>` and :ref:`MRG31k3p
-<libdoc_rng_mrg>`. The RandomStream only work on the CPU, MRG31k3p
+There is 2 other implementations based on :ref:`MRG31k3p
+<libdoc_rng_mrg>` and :class:`CURAND <theano.sandbox.cuda.rng_curand>`.
+ The RandomStream only work on the CPU, MRG31k3p
 work on the CPU and GPU. CURAND only work on the GPU.
 
+.. note::
+
+    To use you the MRG version easily, you can just change the import to:
+
+        .. code-block:: python
+
+            from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams
+
 .. _logistic_regression:
 
 

theano/sandbox/cuda/basic_ops.py

@@ -3539,6 +3539,9 @@ class GpuAllocEmpty(GpuOp):
     def make_node(self, *shape):
         shape, output = self.validate_shape(shape)
         output.tag.values_eq_approx = tensor.type.values_eq_approx_always_true
+        # The outut can contain nan/inf.  output.type is a new
+        # instance, so we can do this only for that variable.
+        output.type.filter_checks_isfinite = False
         return Apply(self, shape, [output])
 
     def perform(self, node, inputs, out_):

theano/sandbox/cuda/opt_util.py

@@ -73,8 +73,20 @@ def alpha_merge(cls, alpha_in, beta_in, nd):
                 if lr is None or targ is None:
                     return None
                 inputs = list(targ.inputs)
-                inputs[alpha_in] = lr * targ.inputs[alpha_in]
-                inputs[beta_in] = lr * targ.inputs[beta_in]
+                try:
+                    c = get_scalar_constant_value(lr)
+                    if c == 0:
+                        inputs[alpha_in] = lr
+                        inputs[beta_in] = lr
+                    elif c == 1:
+                        inputs[alpha_in] = targ.inputs[alpha_in]
+                        inputs[beta_in] = targ.inputs[beta_in]
+                    else:
+                        inputs[alpha_in] = lr * targ.inputs[alpha_in]
+                        inputs[beta_in] = lr * targ.inputs[beta_in]
+                except NotScalarConstantError:
+                    inputs[alpha_in] = lr * targ.inputs[alpha_in]
+                    inputs[beta_in] = lr * targ.inputs[beta_in]
                 return maker(targ, *inputs)
         return opt
     return wrapper

theano/sandbox/gpuarray/basic_ops.py

@@ -713,6 +713,8 @@ class GpuAllocEmpty(HideC, Alloc):
         sh, bcast = self.validate_shape(shape)
         output = GpuArrayType(dtype=self.dtype, broadcastable=bcast)()
         output.tag.values_eq_approx = tensor.type.values_eq_approx_always_true
+        # The outut can contain nan/inf.
+        output.type.filter_checks_isfinite = False
         return Apply(self, sh, [output])
 
     def perform(self, node, inputs, out_):

theano/sandbox/gpuarray/opt_util.py

@@ -75,8 +75,20 @@ def alpha_merge(cls, alpha_in, beta_in, nd):
                 if lr is None or targ is None:
                     return None
                 inputs = list(targ.inputs)
-                inputs[alpha_in] = lr * targ.inputs[alpha_in]
-                inputs[beta_in] = lr * targ.inputs[beta_in]
+                try:
+                    c = get_scalar_constant_value(lr)
+                    if c == 0:
+                        inputs[alpha_in] = lr
+                        inputs[beta_in] = lr
+                    elif c == 1:
+                        inputs[alpha_in] = targ.inputs[alpha_in]
+                        inputs[beta_in] = targ.inputs[beta_in]
+                    else:
+                        inputs[alpha_in] = lr * targ.inputs[alpha_in]
+                        inputs[beta_in] = lr * targ.inputs[beta_in]
+                except NotScalarConstantError:
+                    inputs[alpha_in] = lr * targ.inputs[alpha_in]
+                    inputs[beta_in] = lr * targ.inputs[beta_in]
                 return maker(targ, *inputs)
         return opt
     return wrapper

theano/tensor/basic.py

@@ -5709,6 +5709,9 @@ class AllocEmpty(gof.Op):
     def make_node(self, *shape):
         shape, output = self.validate_shape(shape)
         output.tag.values_eq_approx = values_eq_approx_always_true
+        # The outut can contain nan/inf.  output.type is a new
+        # instance, so we can do this only for that variable.
+        output.type.filter_checks_isfinite = False
         return Apply(self, shape, [output])
 
     def perform(self, node, inputs, out_):

theano/tensor/subtensor.py

@@ -1009,6 +1009,8 @@ def inc_subtensor(x, y, inplace=False, set_instead_of_inc=False,
 
     :param x: the symbolic result of a Subtensor operation.
     :param y: the amount by which to increment ths subtensor in question
+    :param inplace: Don't use. Theano will do it when possible.
+    :param set_instead_of_inc: If True, do a set_subtensor instead.
     :param tolerate_inplace_aliasing: allow x and y to be views of a single
         underlying array even while working inplace.  For correct results,
         x and y must not be overlapping views; if they overlap, the result

theano/tensor/tests/test_basic.py

@@ -4898,13 +4898,9 @@ class T_reshape(utt.InferShapeTester, utt.TestOptimizationMixin):
             topo_ = [node for node in topo if not isinstance(node.op,
                                                              self.ignore_topo)]
             assert len(topo_) == 1, topo_
+            assert type(topo_[0].op) is self.op
         return f
 
-    def eval_output_and_check(self, t):
-        f = self.function([], t)
-        tval = f()
-        return tval
-
     def test_reshape(self):
         a = dvector()
         b = dmatrix()
@@ -5020,6 +5016,11 @@ class T_reshape(utt.InferShapeTester, utt.TestOptimizationMixin):
         self.assertRaises(ValueError, f, a_val, [7, 5])
         self.assertRaises(ValueError, f, a_val, [-1, -1])
 
+    def test_0(self):
+        x = fvector('x')
+        f = self.function([x], x.reshape((0, 100)))
+        assert f(numpy.ndarray((0,), dtype='float32')).shape == (0, 100)
+
 
 def test_make_column_matrix_broadcastable():
     # The goal of the operation made by `b` is to ensure the second dimension

theano/tensor/tests/test_casting.py

@@ -34,7 +34,7 @@ class test_casting(unittest.TestCase):
         for type1 in ['uint8', 'uint16', 'uint32', 'uint64',
                       'int8', 'int16', 'int32', 'int64', 'float32', 'float64']:
             x = TensorType(dtype=type1,
-                           broadcastable=(False, )).make_variable()
+                           broadcastable=(False, ))()
             for type2, converter in zip(['int8', 'int16', 'int32', 'int64',
                                          'float32', 'float64'],
                                         [_convert_to_int8, _convert_to_int16,