Fix backwards-conv work in general (pad/stride/..)

Author: lucasb-eyer

DeepFried2/layers/BackwardsConvolutionCUDNN.py

@@ -8,12 +8,24 @@
 
 class BackwardsConvolutionCUDNN(df.Module):
     def __init__(self, nchan_in, nchan_out, filter_size, stride=1, border=0, mode='cross', init=df.init.xavier(), bias=df.init.const(0)):
-        # mode='cross' is the default in Lasagne[1], Torch[2], matConvNet[3], Caffee[4].
-        #
-        # 1: https://github.com/Lasagne/Lasagne/blob/63d44a0d/lasagne/layers/dnn.py#L299
-        # 2: https://github.com/soumith/cudnn.torch/blob/840f0228/SpatialConvolution.lua#L83
-        # 3: https://github.com/vlfeat/matconvnet/blob/b7dd9c96/matlab/src/bits/impl/nnconv_cudnn.cu#L133
-        # 4: https://github.com/BVLC/caffe/blob/50ab52cb/include/caffe/util/cudnn.hpp#L104
+        """
+        This is the backwards path through a convolution, sometimes is also
+        referred to as transposed convolution and (wrongly) deconvolution.
+
+        This is usually used for upsampling an image. If you want the exact
+        counterpart to another convolution earlier part of your model, consider
+        using the `backward` function with that convolution instead.
+
+        - `nchan_in`: number of channels in the input.
+        - `nchan_out`: number of filters and thus channels in the output.
+        - `filter_size`: 2D or 3D tuple describing the filter size.
+        - `stride`: the stride "dilates" the output, i.e. makes it larger.
+        - `border`: The counterpart to `border` in forward convolution. This
+            effectively crops the output, as opposed to padding it.
+        - `mode`: `'cross'` or `'conv'`, see forward convolution documentation.
+        - `init`: initializer for the weights/filters.
+        - `bias`: initializer for the bias, or `None` or `False`.
+        """
         df.Module.__init__(self)
         self.nchan_in = nchan_in
         self.nchan_out = nchan_out
@@ -39,14 +51,15 @@ def __init__(self, nchan_in, nchan_out, filter_size, stride=1, border=0, mode='c
 
 
     def symb_forward(self, symb_input):
-        """ creates dummy forward conv and uses its gradient as backwards pass """
-        """ This code is mostly taken from https://github.com/Newmu/dcgan_code/blob/master/lib/ops.py """
+        # Calls directly into CUDNN's gradient methods to insert a backward-conv Op.
+        # This code is originally taken from https://github.com/Newmu/dcgan_code/blob/master/lib/ops.py
+        # and extended to more complex scenarios (stride, border)
         img = gpu_contiguous(symb_input)
         kerns = gpu_contiguous(self.W.param)
 
-        alloc_shape = (img.shape[0], kerns.shape[1]) + tuple(i*d for i,d in zip(img.shape[2:],self.stride))
-        desc = dnn.GpuDnnConvDesc(border_mode=self.border, subsample=self.stride, conv_mode=self.mode)(gpu_alloc_empty(*alloc_shape).shape, kerns.shape)
+        alloc_shape = (img.shape[0], self.nchan_out) + tuple((i-1)*s - 2*b + f for i,s,b,f in zip(img.shape[2:], self.stride, self.border, self.filter_size))
         out = gpu_alloc_empty(*alloc_shape)
+        desc = dnn.GpuDnnConvDesc(border_mode=self.border, subsample=self.stride, conv_mode=self.mode)(out.shape, kerns.shape)
         grad = dnn.GpuDnnConv3dGradI if symb_input.ndim == 5 else dnn.GpuDnnConvGradI
         conv_output = grad()(kerns, img, out, desc)
 

DeepFried2/tests/layers/test_BackwardsConvolutionCUDNN.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+
+import DeepFried2 as df
+
+import unittest
+import numpy as np
+
+class TestBackwardsConvolutionCUDNN(unittest.TestCase):
+
+    def testFwdBwd(self):
+        # Let's try fuzz-testing for that one, I hear good things about it!!
+
+        randint = np.random.randint
+
+        for _ in range(100):
+            B = randint(1, 10)
+            cin = randint(1, 10)
+            cout = randint(1, 10)
+
+            # Test both 2D and 3D
+            ndim = randint(2,3)
+
+            fs = tuple(randint(1, 11, size=ndim))
+
+            # Image should be >= filter size in all dimensions.
+            ims = tuple(fs + randint(0, 10, size=ndim))
+
+            stride = tuple(randint(1, 4, size=ndim))
+            border = tuple(randint(0, 5, size=ndim))
+
+            # We can only test those cases where no border gets "lost" during
+            # forward conv using this strategy, as otherwise the result is smaller.
+            # I could come up with the formula of the output shape in other cases,
+            # but why bother if brute-force trying is just as good?
+            # A little over a third of trials pass this test.
+            if not all(((i+2*b) - f) % s == 0 for f,i,s,b in zip(fs, ims, stride, border)):
+                continue
+
+            X = np.random.randn(B, cin, *ims).astype(df.floatX)
+            net = df.Sequential(
+                df.SpatialConvolutionCUDNN(cin, cout, fs, stride, border),
+                df.BackwardsConvolutionCUDNN(cout, cin, fs, stride, border)
+            )
+            Y = net.forward(X)
+            self.assertEqual(Y.shape, X.shape, "Setup: B={B},cin={cin},cout={cout},ndim={ndim},fs={fs},ims={ims},stride={stride},border={border}".format(**locals()))