Make opt local_useless_subtensor convert to subsample when we reverse.

theano/tensor/opt.py

@@ -1715,10 +1715,12 @@ def local_useless_inc_subtensor(node):
     # If is this IncSubtensor useful?
 
     # Check that we keep all the original data.
+    # Put the constant inputs in the slice.
+    idx_cst = theano.tensor.subtensor.get_idx_list(node.inputs[1:],
+                                                   node.op.idx_list)
     if all(isinstance(e, slice) and e.start is None and
-           e.stop is None and e.step is None
-           for e in node.op.idx_list):
-        assert len(node.inputs) == 2
+           e.stop is None and (e.step is None or T.extract_constant(e.step) == -1)
+           for e in idx_cst):
         # IncSubtensor broadcast node.inputs[1] on node.inputs[0]
         # based on run time shapes, so we must check they are the same.
         if not hasattr(node.fgraph, 'shape_feature'):
@@ -1726,8 +1728,12 @@ def local_useless_inc_subtensor(node):
         if not node.fgraph.shape_feature.same_shape(node.inputs[0],
                                                     node.inputs[1]):
             return
-        # They are the same shape, so we can remore this IncSubtensor
-        return node.inputs[1]
+        # There is no reverse, so we don't need a replacement.
+        if all(e.step is None
+               for e in node.op.idx_list):
+            # They are the same shape, so we can remore this IncSubtensor
+            return [node.inputs[1]]
+        return [Subtensor(node.op.idx_list)(*node.inputs[1:])]
 
 
 @register_canonicalize

theano/tensor/tests/test_opt.py

@@ -1574,36 +1574,48 @@ def test_log_add():
 def test_local_useless_inc_subtensor():
     x = tensor.matrix('x')
     y = tensor.matrix('y')
-    o = tensor.set_subtensor(x[::, ::], y)
-    o_shape = tensor.set_subtensor(x[::, ::],
-                                   tensor.specify_shape(y, x.shape))
-    f_shape = theano.function([x, y], o_shape)
-    f = theano.function([x, y], o)
+    for sub in [slice(None), slice(None, None, -1)]:
+        o = tensor.set_subtensor(x[::, sub], y)
+        f = theano.function([x, y], o)
+        o_shape = tensor.set_subtensor(x[::, sub],
+                                       tensor.specify_shape(y, x.shape))
+        f_shape = theano.function([x, y], o_shape)
+
+        # Test with shape info
+        topo = f_shape.maker.fgraph.toposort()
+        assert not any(isinstance(n.op, tensor.IncSubtensor) for n in topo)
+        out = f_shape([[2, 3]], [[3, 4]])
+        assert (out == numpy.asarray([[3, 4]])[::, sub]).all()
+
+        # Test that without shape info, we don't apply the opt.
+        topo = f.maker.fgraph.toposort()
+        assert len(topo) == 1
+        assert isinstance(topo[0].op, tensor.IncSubtensor)
+        out = f([[2, 3]], [[3, 4]])
+        assert (out == numpy.asarray([[3, 4]])[::, sub]).all()
 
-    # Test with shape info
-    topo = f_shape.maker.fgraph.toposort()
-    assert len(topo) == 5, topo
-    assert not isinstance(topo[-1].op, tensor.IncSubtensor)
-    out = f_shape([[2, 3]], [[3, 4]])
-    assert (out == [[3, 4]]).all()
+        # Test that we don't remove shape error
+        try:
+            f([[2, 3]], [[3, 4], [4, 5]])
+            assert False
+        except (ValueError, AssertionError):
+            pass
 
-    # Test that without shape info, we don't apply the opt.
-    topo = f.maker.fgraph.toposort()
-    assert len(topo) == 1
-    assert isinstance(topo[0].op, tensor.IncSubtensor)
-    out = f([[2, 3]], [[3, 4]])
-    assert (out == [[3, 4]]).all()
+        # Test that we don't remove broadcastability
+        out = f([[2, 3], [3, 4]], [[5, 6]])
+        assert (out == numpy.asarray([[5, 6], [5, 6]])[::, sub]).all()
 
-    # Test that we don't remove shape error
-    try:
-        f([[2, 3]], [[3, 4], [4, 5]])
-        assert False
-    except (ValueError, AssertionError):
-        pass
-
-    # Test that we don't remove broadcastability
-    out = f([[2, 3], [3, 4]], [[5, 6]])
-    assert (out == [[5, 6], [5, 6]]).all()
+    # Test that we do not optimize others strides even when sub and y
+    # have same shapes
+    sub = x[::, ::2]
+    o_shape = tensor.set_subtensor(sub,
+                                   tensor.specify_shape(y, sub.shape))
+    f_shape = theano.function([x, y], o_shape)
+    topo = f_shape.maker.fgraph.toposort()
+    theano.printing.debugprint(f_shape)
+    assert any(isinstance(n.op, tensor.IncSubtensor) for n in topo)
+    out = f_shape([[2, 3, 6, 7]], [[8, 9]])
+    assert (out == numpy.asarray([[8, 3, 9, 7]])).all()
 
 
 def test_local_useless_subtensor():