Add tests for 6d/7d and to check pool interface

theano/gpuarray/pool.c

@@ -239,11 +239,20 @@ int APPLY_SPECIFIC(pool)(PyGpuArrayObject *x,
   size_t w[3];
   size_t s[3];
   size_t p[3]; z_dims[0] = x_dims[0]; z_dims[1] = x_dims[1];
+  int nonzero_padding = 0;
   for (int i = 0; i < ndims; i++) {
     w[i] = *((npy_intp*)PyArray_GETPTR1(ws, i));
     s[i] = *((npy_intp*)PyArray_GETPTR1(stride, i));
     p[i] = *((npy_intp*)PyArray_GETPTR1(pad, i));
     z_dims[2 + i] = OUTPUT_DIMS(x_dims[2 + i] + 2*p[i], w[i], s[i]);
+    if (p[i] > 0) {
+      nonzero_padding = 1;
+    }
+  }
+  if (!IGNORE_BORDER && nonzero_padding) {
+    PyErr_SetString(PyExc_ValueError,
+                    "GpuPool: padding works only with ignore_border=True");
+    return 1;
   }
 
   if (theano_prep_output(z, PyGpuArray_NDIM(x), z_dims,

theano/gpuarray/pool.py

@@ -48,12 +48,10 @@ class GpuPool(CGpuKernelBase):
             pad = (0,) * nd
         elif isinstance(pad, (tuple, list)):
             if max(pad) != 0 and not self.ignore_border:
-                raise NotImplementedError(
-                    'Padding works only with ignore_border=True')
+                raise ValueError('Padding works only with ignore_border=True')
             if isinstance(ws, (tuple, list)):
                 if any(pad[i] >= ws[i] for i in range(nd)):
-                    raise NotImplementedError(
-                        'Padding must be smaller than strides')
+                    raise ValueError('Padding must be smaller than strides')
 
         ws = as_tensor_variable(ws)
         stride = as_tensor_variable(stride)
@@ -177,6 +175,9 @@ class GpuAveragePoolGrad(CGpuKernelBase):
             stride = ws
         if pad is None:
             pad = (0,) * nd
+        elif isinstance(pad, (tuple, list)):
+            if max(pad) != 0 and not self.mode == 'average_exc_pad':
+                raise ValueError('Padding must be zero for average_exc_pad')
         ws = as_tensor_variable(ws)
         stride = as_tensor_variable(stride)
         pad = as_tensor_variable(pad)

theano/gpuarray/tests/test_pool.py

 from __future__ import absolute_import, print_function, division
+import unittest
 
 import copy
 import itertools
@@ -17,6 +18,36 @@ from ..pool import (GpuPool, GpuMaxPoolGrad, GpuAveragePoolGrad,
                     GpuDownsampleFactorMaxGradGrad)
 
 
+class TestPool(unittest.TestCase):
+
+    def test_pool_py_interface(self):
+        shp = (2, 2, 2, 2)
+        inp = theano.shared(rand(*shp), 'a')
+        inp = tensor.as_tensor_variable(inp)
+        with self.assertRaises(ValueError):
+            # test when pad >= ws
+            ds_op = GpuPool(ignore_border=True, ndim=2)
+            ds_op(inp, [2, 2], pad=[3, 3])
+        with self.assertRaises(ValueError):
+            # test when ignore_border and pad >= 0
+            ds_op = GpuPool(ignore_border=False, ndim=2)
+            ds_op(inp, [2, 2], pad=[1, 1])
+
+    def test_pool_c_interface(self):
+        gpu_mode = copy.copy(mode_with_gpu).excluding("cudnn")
+        gpu_mode.check_py_code = False
+
+        shp = (2, 2, 2, 2)
+        inp = theano.shared(rand(*shp), 'a')
+        inp = tensor.as_tensor_variable(inp)
+        with self.assertRaises(ValueError):
+            # test when ignore_border and pad >= 0
+            ds_op = GpuPool(ignore_border=False, ndim=2)
+            pad = tensor.as_tensor_variable([1, 1])
+            f = theano.function([], ds_op(inp, [2, 2], pad=pad), mode=gpu_mode)
+            f()
+
+
 def test_pool2d():
     shps = [(1, 12),
             (1, 1, 12),