Try to fix conv output checking and ultimate jenkins tests.

theano/gpuarray/c_code/dnn_conv_base.c

@@ -98,6 +98,56 @@ c_get_largest_free_block_size(PyGpuContextObject *c)
   return free;
 }
 
+/** Check if convolution output tensor has expected dimensions
+    depending on given inputs and number of groups.
+    return 0 if everything is ok, non-0 on error.
+**/
+static int dnn_check_convolution_output(cudnnConvolutionDescriptor_t convDesc,
+                                        cudnnTensorDescriptor_t inputDesc,
+                                        cudnnFilterDescriptor_t filterDesc,
+                                        size_t tensorNdim,
+                                        PyGpuArrayObject* output,
+                                        int groups) {
+    int expected_output_dims[5] = {0};
+    cudnnStatus_t err = cudnnGetConvolutionNdForwardOutputDim(convDesc, inputDesc, filterDesc,
+                                                              tensorNdim, expected_output_dims);
+    if (err != CUDNN_STATUS_SUCCESS) {
+      PyErr_Format(PyExc_RuntimeError, "error computing convolution output dim: %s",
+                   cudnnGetErrorString(err));
+      return 1;
+    }
+    if (tensorNdim == 4) {
+      if ((PyGpuArray_DIMS(output)[0] != expected_output_dims[0]) ||
+          (PyGpuArray_DIMS(output)[1] / groups != expected_output_dims[1]) ||
+          (PyGpuArray_DIMS(output)[2] != expected_output_dims[2]) ||
+          (PyGpuArray_DIMS(output)[3] != expected_output_dims[3])) {
+        PyErr_Format(PyExc_ValueError, "impossible convolution output dim: expected %dx%dx%dx%d"
+                     " but received %ldx%ldx%ldx%ld",
+                     expected_output_dims[0], expected_output_dims[1] * groups,
+                     expected_output_dims[2], expected_output_dims[3],
+                     PyGpuArray_DIMS(output)[0], PyGpuArray_DIMS(output)[1],
+                     PyGpuArray_DIMS(output)[2], PyGpuArray_DIMS(output)[3]);
+        return 1;
+      }
+    } else if (tensorNdim == 5) {
+      if ((PyGpuArray_DIMS(output)[0] != expected_output_dims[0]) ||
+          (PyGpuArray_DIMS(output)[1] / groups != expected_output_dims[1]) ||
+          (PyGpuArray_DIMS(output)[2] != expected_output_dims[2]) ||
+          (PyGpuArray_DIMS(output)[3] != expected_output_dims[3]) ||
+          (PyGpuArray_DIMS(output)[4] != expected_output_dims[4])) {
+        PyErr_Format(PyExc_ValueError, "impossible convolution output dim: expected %dx%dx%dx%dx%d"
+                     " but received %ldx%ldx%ldx%ldx%ld",
+                     expected_output_dims[0], expected_output_dims[1] * groups,
+                     expected_output_dims[2], expected_output_dims[3],
+                     expected_output_dims[4],
+                     PyGpuArray_DIMS(output)[0], PyGpuArray_DIMS(output)[1],
+                     PyGpuArray_DIMS(output)[2], PyGpuArray_DIMS(output)[3],
+                     PyGpuArray_DIMS(output)[4]);
+        return 1;
+      }
+    }
+    return 0;
+}
 
 static std::string shape(int* res, int size)
 {
@@ -185,43 +235,8 @@ static std::string dnn_conv_shape(cudnnTensorDescriptor_t inputDesc, PyGpuArrayO
     cudnnDataType_t  dType;
     std::ostringstream s;
     int expected_output_dims[5] = {0};
-    cudnnStatus_t err = cudnnGetConvolutionNdForwardOutputDim(convDesc, inputDesc, filterDesc,
-							      PyGpuArray_NDIM(filter), expected_output_dims);
-    if (err != CUDNN_STATUS_SUCCESS) {
-      PyErr_Format(PyExc_RuntimeError, "error computing convolution output dim: %s",
-                   cudnnGetErrorString(err));
-      return "";
-    }
-    if (PyGpuArray_NDIM(filter) == 4) {
-      if ((PyGpuArray_DIMS(output)[0] != expected_output_dims[0]) ||
-          (PyGpuArray_DIMS(output)[1] / groups  != expected_output_dims[1]) ||
-          (PyGpuArray_DIMS(output)[2] != expected_output_dims[2]) ||
-          (PyGpuArray_DIMS(output)[3] != expected_output_dims[3])) {
-        PyErr_Format(PyExc_ValueError, "impossible convolution output dim: expected %dx%dx%dx%d"
-                     " but received gradient with shape %ldx%ldx%ldx%ld",
-                     expected_output_dims[0], expected_output_dims[1] / groups,
-                     expected_output_dims[2], expected_output_dims[3],
-                     PyGpuArray_DIMS(output)[0], PyGpuArray_DIMS(output)[1],
-                     PyGpuArray_DIMS(output)[2], PyGpuArray_DIMS(output)[3]);
+    if (dnn_check_convolution_output(convDesc, inputDesc, filterDesc, PyGpuArray_NDIM(filter), output, groups) != 0)
         return "";
-      }
-    } else if (PyGpuArray_NDIM(filter) == 5) {
-      if ((PyGpuArray_DIMS(output)[0] != expected_output_dims[0]) ||
-          (PyGpuArray_DIMS(output)[1] != expected_output_dims[1]) ||
-          (PyGpuArray_DIMS(output)[2] != expected_output_dims[2]) ||
-          (PyGpuArray_DIMS(output)[3] != expected_output_dims[3]) ||
-          (PyGpuArray_DIMS(output)[4] != expected_output_dims[4])) {
-        PyErr_Format(PyExc_ValueError, "impossible convolution output dim: expected %dx%dx%dx%dx%d"
-                     " but received gradient with shape %ldx%ldx%ldx%ldx%ld",
-                     expected_output_dims[0], expected_output_dims[1],
-                     expected_output_dims[2], expected_output_dims[3],
-                     expected_output_dims[4],
-                     PyGpuArray_DIMS(output)[0], PyGpuArray_DIMS(output)[1],
-                     PyGpuArray_DIMS(output)[2], PyGpuArray_DIMS(output)[3],
-                     PyGpuArray_DIMS(output)[4]);
-        return "";
-      }
-    }
     std::string shapeInput = shape(inputDesc);
     std::string shapeFilter = shape(filterDesc, &dType);
     std::string shapeConvDesc = shape(convDesc);
@@ -230,7 +245,7 @@ static std::string dnn_conv_shape(cudnnTensorDescriptor_t inputDesc, PyGpuArrayO
     s << "-g " << groups << " -dim " << shapeInput << " -filt " <<
       shapeFilter << " " << shapeConvDesc;
 
-// there have to be entries for both aligned and not
+    // there have to be entries for both aligned and not.
     if (!all_aligned(dType, PyGpuArray_DEV_DATA(input), PyGpuArray_DEV_DATA(output), PyGpuArray_DEV_DATA(filter)))
     {
       s << " [unaligned]";

theano/gpuarray/c_code/dnn_gi.c

@@ -141,6 +141,11 @@ APPLY_SPECIFIC(conv_gi)(PyGpuArrayObject *kerns, PyGpuArrayObject *output,
     return 1;
   if (c_set_tensor_for_conv(*input, APPLY_SPECIFIC(input), groups) == -1)
     return 1;
+
+  if (0 != dnn_check_convolution_output(desc, APPLY_SPECIFIC(input), APPLY_SPECIFIC(kerns),
+                                        PyGpuArray_NDIM(kerns), output, groups))
+    return 1;
+
   size_t input_offset = PyGpuArray_STRIDE(*input, 0) / groups;
   size_t kern_offset = PyGpuArray_STRIDE(kerns, 0) * PyGpuArray_DIM(kerns, 0) / groups;
   size_t output_offset = PyGpuArray_STRIDE(output, 0) / groups;

theano/gpuarray/c_code/dnn_gw.c

@@ -128,6 +128,11 @@ APPLY_SPECIFIC(conv_gw)(PyGpuArrayObject *input, PyGpuArrayObject *output,
     return 1;
   if (c_set_filter(*kerns, APPLY_SPECIFIC(kerns), groups) == -1)
     return 1;
+
+  if (0 != dnn_check_convolution_output(desc, APPLY_SPECIFIC(input), APPLY_SPECIFIC(kerns),
+                                        PyGpuArray_NDIM(*kerns), output, groups))
+    return 1;
+
   size_t input_offset = PyGpuArray_STRIDE(input, 0) / groups;
   size_t kern_offset = PyGpuArray_STRIDE(*kerns, 0) * PyGpuArray_DIM(*kerns, 0) / groups;
   size_t output_offset = PyGpuArray_STRIDE(output, 0) / groups;