tmp

theano/sandbox/cuda/tests/test_dnn.py

@@ -31,7 +31,7 @@ else:
 
 
 def pool_2d_i2n(input, ds=(2, 2), strides=None,
-                ignore_border=True,
+                pad=(0, 0),
                 pool_function=T.max, mode='ignore_borders'):
     if strides is None:
         strides = ds
@@ -41,8 +41,19 @@ def pool_2d_i2n(input, ds=(2, 2), strides=None,
             "strides should be smaller than or equal to ds,"
             " strides=(%d, %d) and ds=(%d, %d)" %
             (strides + ds))
-
     shape = input.shape
+    if pad != (0, 0):
+        assert pool_function is T.max
+        pad_x = pad[0]
+        pad_y = pad[1]
+        a = T.alloc(-numpy.inf, shape[0], shape[1], shape[2] + pad_x*2,
+                    shape[3] + pad_y*2)
+        input = T.set_subtensor(a[:, :,
+                                  pad_x:pad_x+shape[2],
+                                  pad_y:pad_y+shape[3]],
+                                input)
+        shape = input.shape
+
     neibs = images2neibs(input, ds, strides, mode=mode)
     pooled_neibs = pool_function(neibs, axis=1)
 
@@ -59,34 +70,43 @@ def test_pooling():
         raise SkipTest(cuda.dnn.dnn_available.msg)
 
     x = T.ftensor4()
-    for func, ignore_border in product(
-        (T.max, T.mean), (False, True)):
+    for func, pad in product(
+        (T.max, T.mean), ((0, 0), (1, 0), (1, 0), (2, 3), (3, 2))):
+        if pad != (0, 0) and cuda.dnn.version() < 20:
+            continue
+
         for ws in (4, 2, 5):
             for stride in (2, 3):
                 if stride > ws:
                     continue
-                if func is T.max:
+                if func is T.max and pad == (0, 0):
                     # We will check that the opt introduced it.
                     out1 = max_pool_2d(x, (ws, ws),
                                        st=(stride, stride),
-                                       ignore_border=ignore_border)
+                                       ignore_border=True,)
+#                                       pad=pad)
                 else:
                     out1 = cuda.dnn.dnn_pool(
                         x, ws=(ws, ws),
                         stride=(stride, stride),
-                        ignore_border=ignore_border,
+                        pad=pad,
                         mode='max' if func is T.max else "average")
+                out2 = pool_2d_i2n(x, ds=(ws, ws), strides=(stride, stride),
+                                   pad=pad,
+                                   pool_function=func)
 
                 f1 = theano.function([x], out1, mode=mode_with_gpu)
                 assert any([isinstance(node.op, cuda.dnn.GpuDnnPool)
                             for node in f1.maker.fgraph.apply_nodes])
-                f2 = theano.function([x], out1, mode=mode_without_gpu)
+                f2 = theano.function([x], out2, mode=mode_without_gpu)
                 assert not any([isinstance(node.op, cuda.dnn.GpuDnnPool)
                                 for node in f2.maker.fgraph.apply_nodes])
                 for shp in [(1, 10, 100, 100),
                             (1, 3, 99, 99),
                             (32, 1, 147, 197),
                          ]:
+                    print func, pad, ws, stride, shp
+
                     data = numpy.random.normal(0, 1, shp).astype("float32")
                     a = f1(data).__array__()
 
@@ -101,49 +121,45 @@ def test_pooling():
 
             ws = 2
             strides = 2
+            print func, pad, ws, stride, shp
 
             # This test the CPU grad + opt + GPU implemtentation
             def fn(x):
-                return max_pool_2d(x, (ws, ws), ignore_border=ignore_border)
+                return max_pool_2d(x, (ws, ws), ignore_border=True,)
+#                                   pad=pad)
             theano.tests.unittest_tools.verify_grad(fn, [data],
                                                     cast_to_output_type=False,
                                                     mode=mode_with_gpu)
             # Confirm that the opt would have inserted it.
             fg = theano.function([x], theano.grad(fn(x).sum(), x),
                                  mode=mode_with_gpu)
-            if ignore_border:
-                assert any([isinstance(node.op, cuda.dnn.GpuDnnPoolGrad)
-                            for node in fg.maker.fgraph.toposort()])
-            else:
-                assert not any([isinstance(node.op, cuda.dnn.GpuDnnPoolGrad)
-                                for node in fg.maker.fgraph.toposort()])
+            assert any([isinstance(node.op, cuda.dnn.GpuDnnPoolGrad)
+                        for node in fg.maker.fgraph.toposort()])
 
             # Test the GPU grad + GPU implementation
             def fn(x):
                 dnn_op = cuda.dnn.dnn_pool(
                     x, ws=(ws, ws),
                     stride=(stride, stride),
-                    ignore_border=ignore_border,
+                    pad=pad,
                     mode='max' if func is T.max else "average")
                 return dnn_op
-            try:
-                theano.tests.unittest_tools.verify_grad(
-                    fn, [data],
-                    cast_to_output_type=False,
-                    mode=mode_with_gpu)
-                # Confirm that we get the good op.
-                fg = theano.function([x], theano.grad(fn(x).sum(), x),
-                                     mode=mode_with_gpu)
-                assert any([isinstance(node.op, cuda.dnn.GpuDnnPoolGrad)
-                            for node in fg.maker.fgraph.toposort()])
-                g_out = fg(data)
-                assert ignore_border
-            except NotImplementedError:
-                assert not ignore_border
-
-            if func is T.max and ignore_border:
+            theano.tests.unittest_tools.verify_grad(
+                fn, [data],
+                cast_to_output_type=False,
+                mode=mode_with_gpu)
+            # Confirm that we get the good op.
+            fg = theano.function([x], theano.grad(fn(x).sum(), x),
+                                 mode=mode_with_gpu)
+            assert any([isinstance(node.op, cuda.dnn.GpuDnnPoolGrad)
+                        for node in fg.maker.fgraph.toposort()])
+            g_out = fg(data)
+
+            if func is T.max and pad == (0, 0):
                 # Compare again the CPU result
-                out = max_pool_2d(x, (ws, ws), ignore_border=ignore_border)
+                out = max_pool_2d(x, (ws, ws),
+#                                  pad=pad,
+                                  ignore_border=True)
                 fc = theano.function([x], theano.grad(out.sum(), x),
                                      mode=mode_without_gpu)
                 assert any([isinstance(node.op, DownsampleFactorMaxGrad)