Merge pull request #2543 from yaoli/pool_pad

theano/tensor/signal/tests/test_downsample.py

@@ -38,6 +38,49 @@ class TestDownsampleFactorMax(utt.InferShapeTester):
                     output_val[k][i, j] = numpy.max(patch)
         return output_val
 
+    @staticmethod
+    def numpy_max_pool_2d_stride_padding(
+            x, ds, ignore_border=True, st=None, padding=(0, 0)):
+        pad_h = padding[0]
+        pad_w = padding[1]
+        h = x.shape[-2]
+        w = x.shape[-1]
+        assert ds[0] > pad_h
+        assert ds[1] > pad_w
+
+        def pad_img(x):
+            fill = x.min()-1
+            t = numpy.ones((x.shape[0], x.shape[1], 1, 1))
+            ud_bar = (numpy.zeros((pad_h, w)) + fill)[
+                numpy.newaxis, numpy.newaxis, :, :] * t
+            lr_bar = (numpy.zeros((pad_h * 2 + h, pad_w)) + fill)[
+                numpy.newaxis, numpy.newaxis, :, :] * t
+            y = numpy.concatenate([ud_bar, x, ud_bar], axis=2)
+            y = numpy.concatenate([lr_bar, y, lr_bar], axis=3)
+            return y
+        img_rows = h + 2 * pad_h
+        img_cols = w + 2 * pad_w
+        out_r = (img_rows - ds[0]) // st[0] + 1
+        out_c = (img_cols - ds[1]) // st[1] + 1
+        out_shp = list(x.shape[:-2])
+        out_shp.append(out_r)
+        out_shp.append(out_c)
+        ds0, ds1 = ds
+        st0, st1 = st
+        output_val = numpy.zeros(out_shp)
+        tt = []
+        y = pad_img(x)
+        for k in numpy.ndindex(*x.shape[:-2]):
+            for i in range(output_val.shape[-2]):
+                ii_st = i * st[0]
+                ii_end = __builtin__.min(ii_st + ds[0], img_rows)
+                for j in range(output_val.shape[-1]):
+                    jj_st = j * st[1]
+                    jj_end = __builtin__.min(jj_st + ds[1], img_cols)
+                    patch = y[k][ii_st:ii_end, jj_st:jj_end]
+                    output_val[k][i, j] = numpy.max(patch)
+        return output_val
+
     @staticmethod
     def numpy_max_pool_2d_stride(input, ds, ignore_border=False, st=None):
         '''Helper function, implementing max_pool_2d in pure numpy
@@ -196,6 +239,53 @@ class TestDownsampleFactorMax(utt.InferShapeTester):
                 output_val = f(imval)
                 utt.assert_allclose(output_val, numpy_output_val)
 
+    def test_DownsampleFactorMaxPaddingStride(self):
+        ignore_border = True  # padding does not support ignore_border=False
+        rng = numpy.random.RandomState(utt.fetch_seed())
+        maxpoolsizes = [(3, 3), (4, 4), (3, 4), (4, 3)]
+        stridesizes = [(2, 2), (2, 2), (1, 1), (1, 2)]
+        paddingsizes = [(2, 2), (1, 2), (2, 1), (0, 0)]
+        imgsizes = [(5, 5), (5, 5), (5, 6), (6, 5)]
+        m = 4 # minibatch
+        c = 10 # channel size
+        images = tensor.dtensor4()
+        for indx in numpy.arange(len(maxpoolsizes)):
+            imgsize = imgsizes[indx]
+            imval = rng.rand(m, c, imgsize[0], imgsize[1])
+            stridesize = stridesizes[indx]
+            maxpoolsize = maxpoolsizes[indx]
+            paddingsize = paddingsizes[indx]
+            numpy_output_val = self.numpy_max_pool_2d_stride_padding(
+                    imval, maxpoolsize, ignore_border, stridesize, paddingsize)
+            maxpool_op = DownsampleFactorMax(
+                maxpoolsize,
+                ignore_border=ignore_border,
+                st=stridesize, padding=paddingsize)(images)
+            f = function([images], maxpool_op)
+            output_val = f(imval)
+            utt.assert_allclose(output_val, numpy_output_val)
+
+    def test_DownsampleFactorMaxPaddingStride_grad(self):
+        rng = numpy.random.RandomState(utt.fetch_seed())
+        imgsizes = ((10, 10), (10, 5))
+        maxpoolsizes = ((5, 3),(3, 5))
+        stridesizes = ((3, 2), (2, 3))
+        paddingsizes = ((2, 2),(2, 1))
+        for i in range(len(imgsizes)):
+            imgsize = imgsizes[i]
+            imval = rng.rand(1, 1, imgsize[0], imgsize[1]) * 10.0
+            maxpoolsize = maxpoolsizes[i]
+            stridesize = stridesizes[i]
+            paddingsize = paddingsizes[i]
+            
+            def mp(input):
+                return DownsampleFactorMax(
+                    maxpoolsize, ignore_border=True,
+                    st=stridesize,
+                    padding=paddingsize,
+                    )(input)
+            utt.verify_grad(mp, [imval], rng=rng)
+
     def test_DownsampleFactorMax_grad(self):
         rng = numpy.random.RandomState(utt.fetch_seed())
         maxpoolshps = ((1, 1), (3, 2), (2, 3))