Merge pull request #2424 from SinaHonari/issue2196

theano/tensor/signal/downsample.py

@@ -232,14 +232,15 @@ class DownsampleFactorMax(Op):
         x, = inp
         gz, = grads
         maxout = self(x)
-        if self.st != self.ds:
-            return [theano.gradient.grad_not_implemented(self, 0, x)]
         return [DownsampleFactorMaxGrad(self.ds,
                                         ignore_border=self.ignore_border,
                                         st=self.st)(
                                             x, maxout, gz)]
 
     def c_code(self, node, name, inp, out, sub):
+        # No implementation is currently for the case where
+        # the stride size and the pooling size are different.
+        # An exception is raised for such a case.
         if self.ds != self.st:
            raise theano.gof.utils.MethodNotDefined()
         x, = inp
@@ -374,16 +375,14 @@ class DownsampleFactorMaxGrad(Op):
     def grad(self, inp, grads):
         x, maxout, gz = inp
         ggx, = grads
-        if self.st != self.ds:
-            return [theano.gradient.grad_not_implemented(self, 0, x),
-                    theano.gradient.grad_not_implemented(self, 1, maxout),
-                    theano.gradient.grad_not_implemented(self, 2, gz)]
         return [theano.tensor.zeros_like(x),
                 theano.tensor.zeros_like(maxout),
                 DownsampleFactorMaxGradGrad(
                     self.ds, ignore_border=self.ignore_border, st=self.st)(x, maxout, ggx)]
 
     def c_code(self, node, name, inp, out, sub):
+        if self.ds != self.st:
+           raise theano.gof.utils.MethodNotDefined()
         x, z, gz = inp
         gx, = out
         fail = sub['fail']

theano/tensor/signal/tests/test_downsample.py

@@ -212,6 +212,44 @@ class TestDownsampleFactorMax(utt.InferShapeTester):
                                                ignore_border)(input)
                 utt.verify_grad(mp, [imval], rng=rng)
 
+    def test_DownsampleFactorMax_grad_st(self):
+        """checks the gradient for the case that stride is used"""
+        rng = numpy.random.RandomState(utt.fetch_seed())
+        maxpoolshps = ((1, 1), (3, 3), (5, 3))
+        stridesizes = ((1, 1), (3, 3), (5, 7))
+        imval = rng.rand(1, 2, 16, 16)
+
+        for maxpoolshp in maxpoolshps:
+            for ignore_border in [True, False]:
+                for stride in stridesizes:
+                    def mp(input):
+                        return DownsampleFactorMax(maxpoolshp,
+                                                   ignore_border=ignore_border,
+                                                   st=stride)(input)
+                    utt.verify_grad(mp, [imval], rng=rng)
+
+    def test_DownsampleFactorMax_grad_st_extra(self):
+        """checks the gradient for the case
+        that stride is used for extra examples"""
+        rng = numpy.random.RandomState(utt.fetch_seed())
+        maxpoolshps = ((5, 3), (5, 3), (5, 3), (5, 5), (3, 2), (7, 7), (9, 9))
+        stridesizes = ((3, 2), (7, 5), (10, 6), (1, 1),
+                       (2, 3), (10, 10), (1, 1))
+        imvsizs = ((16, 16), (16, 16), (16, 16), (8, 5),
+                   (8, 5), (8, 5), (8, 5))
+
+        for indx in numpy.arange(len(maxpoolshps)):
+            imvsize = imvsizs[indx]
+            imval = rng.rand(1, 2, imvsize[0], imvsize[1])
+            stride = stridesizes[indx]
+            maxpoolshp = maxpoolshps[indx]
+            for ignore_border in [True, False]:
+                def mp(input):
+                    return DownsampleFactorMax(maxpoolshp,
+                                               ignore_border=ignore_border,
+                                               st=stride)(input)
+                utt.verify_grad(mp, [imval], rng=rng)
+
     def test_DownsampleFactorMaxGrad_grad(self):
         rng = numpy.random.RandomState(utt.fetch_seed())
         maxpoolshps = ((1, 1), (3, 2), (2, 3))
@@ -236,6 +274,68 @@ class TestDownsampleFactorMax(utt.InferShapeTester):
 
                 utt.verify_grad(mp, [imval, grad_val], rng=rng)
 
+    def test_DownsampleFactorMaxGrad_grad_st(self):
+        """checks the gradient of the gradient for
+        the case that stride is used"""
+        rng = numpy.random.RandomState(utt.fetch_seed())
+        maxpoolshps = ((1, 1), (3, 3), (5, 3))
+        stridesizes = ((1, 1), (3, 3), (5, 7))
+        imval = rng.rand(1, 2, 16, 16)
+
+        for maxpoolshp in maxpoolshps:
+            for ignore_border in [True, False]:
+                for stride in stridesizes:
+                    grad_shape = DownsampleFactorMax.out_shape(
+                        imval.shape, maxpoolshp,
+                        ignore_border=ignore_border, st=stride)
+                    grad_val = rng.rand(*grad_shape)
+
+                    def mp(input, grad):
+                        out = DownsampleFactorMax(
+                            maxpoolshp, ignore_border=ignore_border,
+                            st=stride)(input)
+                        grad_op = DownsampleFactorMaxGrad(
+                            maxpoolshp, ignore_border=ignore_border,
+                            st=stride)
+                        return grad_op(input, out, grad)
+
+                    utt.verify_grad(mp, [imval, grad_val], rng=rng)
+
+    def test_DownsampleFactorMaxGrad_grad_st_extra(self):
+        """checks the gradient of the gradient for the case that
+        stride is used for extra examples"""
+        rng = numpy.random.RandomState(utt.fetch_seed())
+        maxpoolshps = ((5, 3), (5, 3), (5, 3), (5, 5), (3, 2), (7, 7), (9, 9))
+        stridesizes = ((3, 2), (7, 5), (10, 6), (1, 1),
+                       (2, 3), (10, 10), (1, 1))
+        imvsizs = ((16, 16), (16, 16), (16, 16), (8, 5),
+                   (8, 5), (8, 5), (8, 5))
+
+        for indx in numpy.arange(len(maxpoolshps)):
+            imvsize = imvsizs[indx]
+            imval = rng.rand(1, 2, imvsize[0], imvsize[1])
+            stride = stridesizes[indx]
+            maxpoolshp = maxpoolshps[indx]
+            for ignore_border in [True, False]:
+                grad_shape = DownsampleFactorMax.out_shape(
+                    imval.shape, maxpoolshp,
+                    ignore_border=ignore_border, st=stride)
+                grad_val = rng.rand(*grad_shape)
+
+                def mp(input, grad):
+                    out = DownsampleFactorMax(
+                        maxpoolshp, ignore_border=ignore_border,
+                        st=stride)(input)
+                    grad_op = DownsampleFactorMaxGrad(
+                        maxpoolshp, ignore_border=ignore_border,
+                        st=stride)
+                    return grad_op(input, out, grad)
+
+                # skip the grad verification when the output is empty
+                if numpy.prod(grad_shape) == 0:
+                    continue
+                utt.verify_grad(mp, [imval, grad_val], rng=rng)
+
     def test_DownsampleFactorMax_hessian(self):
         # Example provided by Frans Cronje, see
         # https://groups.google.com/d/msg/theano-users/qpqUy_3glhw/JMwIvlN5wX4J