Merge pull request #412 from lamblin/sparse_indexing

theano/compile/debugmode.py

@@ -1330,11 +1330,16 @@ class _Linker(gof.link.LocalLinker):
                 r_vals_initialized = []
                 for r in storage_map:
                     if (r.owner is None):
-                        if (storage_map[r][0] is None):
-                            raise Exception('Missing input', r)
                         if not r.type.is_valid_value(storage_map[r][0]):
+                            # None may be a valid input value (for instance,
+                            # for a Generic object). We only want to raise
+                            # an error if it is not valid.
+                            if (storage_map[r][0] is None):
+                                raise InvalidValueError(r, storage_map[r][0],
+                                       hint="Graph Input '%s' is missing" % str(r))
                             raise InvalidValueError(r, storage_map[r][0],
-                                   hint="Graph Input '%s' is missing" % str(r))
+                                   hint=("Graph Input '%s' has invalid value "
+                                       "%s" % (r, storage_map[r][0])))
                         r_vals[r] = storage_map[r][0]
                         storage_map[r][0] = None
                         r_vals_initialized.append(r)
@@ -1577,7 +1582,8 @@ class _Linker(gof.link.LocalLinker):
             #print storage_map
             for r in storage_map:
                 if (r.owner is None):
-                    assert storage_map[r][0] is not None
+                    if not r.type.is_valid_value(None):
+                        assert storage_map[r][0] is not None
 
 
             ###############

theano/gof/graph.py

@@ -391,7 +391,11 @@ class Constant(Value):
     def __str__(self):
         if self.name is not None:
             return self.name
-        return str(self.data) #+ "::" + str(self.type)
+        else:
+            name = str(self.data)
+            if len(name) > 20:
+                name = name[:10] + '...' + name[-10]
+            return 'Constant{%s}' % name
     def clone(self):
         """
         We clone this object, but we don't clone the data to lower memory requirement

theano/gof/type.py

@@ -423,4 +423,7 @@ class Generic(SingletonType):
         Py_INCREF(py_%(name)s);
         """ % locals()
 
+    def __str__(self):
+        return self.__class__.__name__
+
 generic = Generic()

theano/sparse/basic.py

@@ -188,13 +188,11 @@ class _sparse_py_operators:
         if not isinstance(args, tuple):
             args = args,
 
-        scalar_var = tensor.iscalar()
-
         if len(args) == 2:
             scalar_arg_1 = (numpy.isscalar(args[0]) or
-                            getattr(args[0], 'type', None) == scalar_var.type)
+                            getattr(args[0], 'type', None) == tensor.iscalar)
             scalar_arg_2 = (numpy.isscalar(args[1]) or
-                            getattr(args[1], 'type', None) == scalar_var.type)
+                            getattr(args[1], 'type', None) == tensor.iscalar)
             if scalar_arg_1 and scalar_arg_2:
                 ret = get_item_scalar(self, args)
             else:
@@ -202,8 +200,8 @@ class _sparse_py_operators:
         else:
             ret = get_item_2d(self, args)
         return ret
-            
-                        
+
+
 class SparseVariable(gof.Variable, _sparse_py_operators):
     dtype = property(lambda self: self.type.dtype)
     format = property(lambda self: self.type.format)
@@ -681,35 +679,57 @@ class GetItem2d(gof.op.Op):
         assert len(index) in [1, 2]
 
         input_op = [x]
+        generic_None = theano.gof.Constant(theano.gof.generic, None)
 
         for ind in index:
             if isinstance(ind, slice):
                 # in case of slice is written in theano variable
                 start = ind.start
                 stop = ind.stop
-
-                # in case of slice is written in python int
-                if isinstance(start, int):
-                    start = theano.tensor.constant(start)
-                if isinstance(stop, int):
-                    stop = theano.tensor.constant(stop)
-
-            #in case of indexing using python int
-            #elif isinstance(ind,int):
-            #    start = theano.tensor.constant(ind)
-            #    stop = start + 1
-            #elif ind.ndim == 0:
-            #    start = ind
-            #    stop = ind + 1
-
-            else:
-                raise NotImplemented(
+                if ind.step is not None:
+                    raise ValueError((
+                        "Using a slice with non-default step when "
+                        "indexing into a sparse matrix is not supported. "),
+                        ind, ind.step)
+
+                # If start or stop are None, make them a Generic constant
+                # Else, they should be converted to Tensor Variables of
+                # dimension 1 and int/uint dtype.
+                if start is None:
+                    start = generic_None
+                else:
+                    if not isinstance(start, gof.Variable):
+                        start = tensor.as_tensor_variable(start)
+                    if not (start.ndim == 0 and start.dtype in tensor.discrete_dtypes):
+                        raise ValueError((
+                            "Impossible to index into a sparse matrix with "
+                            "slice where start=%s" % start),
+                            start.ndim, start.dtype)
+
+                if stop is None:
+                    stop = generic_None
+                else:
+                    if not isinstance(stop, gof.Variable):
+                        stop = tensor.as_tensor_variable(stop)
+                    if not (stop.ndim == 0 and stop.dtype in tensor.discrete_dtypes):
+                        raise ValueError((
+                            "Impossible to index into a sparse matrix with "
+                            "slice where stop=%s" % stop),
+                            stop.ndim, stop.dtype)
+
+            elif ((isinstance(ind, gof.Variable) and
+                        getattr(ind, 'ndim', -1) == 0)
+                        or numpy.isscalar(ind)):
+                raise NotImplementedError(
                     'Theano has no sparse vector' +
                     'Use X[a:b,c:d], X[a:b,c:c+1] or X[a:b] instead.')
+            else:
+                raise ValueError((
+                    'Advanced indexing is not implemented for sparse '
+                    'matrices. Argument not supported: %s' % ind))
             input_op += [start, stop]
         if len(index) == 1:
-            i = theano.gof.Constant(theano.gof.generic, None)
-            input_op += [i, i]
+            input_op += [generic_None, generic_None]
 
         return gof.Apply(self, input_op, [x.type()])
 
@@ -765,7 +785,7 @@ class GetItemScalar(gof.op.Op):
 
     def perform(self, node, (x, ind1, ind2), (out, )):
         assert _is_sparse(x)
-        out[0] = x[ind1, ind2]
+        out[0] = theano._asarray(x[ind1, ind2], x.dtype)
 
     def __str__(self):
         return self.__class__.__name__