partial rewrite of the ConvOp grad test. It was not testing in float32…

partial rewrite of the ConvOp grad test. It was not testing in float32 correctly. This uncover a bug in the grad in float32. Maybe the bug is in verify_grad. I added an option to verify_grad to help test the float32 case correctly, but we did't can use it by default because it make some test fail. I don't know why.

partial rewrite of the ConvOp grad test. It was not testing in float32…
befb9054 · Frederic Bastien · 5fe9e8d5 · befb9054
--- a/theano/sandbox/test_conv.py
+++ b/theano/sandbox/test_conv.py
@@ -420,64 +420,51 @@ class TestConvOp(unittest.TestCase):
    def test_ConvOpGrad(self):
-        nkern = 3
+        """
-        bsize = 2
+        test the gradient in float and double
-        imgs  = T.dmatrix('imgs')
+        """
-        kerns = T.dmatrix('kerns')
+        nkern = 4
-        kshps = [(3,3), (5,5)]
+        bsize = 3
+        types = ["float32", "float32"]#flot32 is BUGGED
-        for mode in 'valid', 'full':
+        kshps = [(3,3),(5,5)]# TODO: (6,7)show a bug that is not fixed!!
+        imshps = [(1,5,5),(2,10,10),(2,12,12)] #TODO bugged (2,12,10), (3,12,11):
-            for imshp in (5,5),(2,3,3),(3,6,6): # (12,10), (3,12,11):
+        modes = ['valid', 'full']
-                # 'full' mode should support kernels bigger than the input
+        unroll_batch=[0,1,3]
-                if mode == 'valid' and (kshps[0] > imshp[1]):
+        unroll_kern=[0,1,2,4]
-                    continue
+        for t in types:
+            imgs  = T.TensorType(t, (False, False, False, False),'imgs')
+            kerns = T.TensorType(t, (False, False, False, False),'kerns')
+            for mode in modes:
+                for imshp in imshps:
                    visdim = 1 if len(imshp)!=3 else imshp[0]
                    for kshp in kshps:
-                    imgvals = N.random.random(N.hstack((bsize,imshp)))
+                        t=numpy.array([imshp[1]-kshp[0],imshp[2]-kshp[1]])
-                    print 'imgvals.shape = ', imgvals.shape
+                        # 'full' mode should support kernels bigger than the input
-                    imgvals = imgvals.reshape(bsize,-1)
+                        if mode == 'valid' and (t<0).any():
+                            continue
-                    if visdim == 1: 
+                        for un_b in unroll_batch:
-                        kernvals = N.random.rand(nkern,kshp[0],kshp[1])
+                            for un_k in unroll_kern:
-                    else:
+                                imgvals = N.array(N.random.random(N.hstack((bsize,imshp))),dtype=imgs.dtype)
-                        kernvals = N.random.rand(nkern,visdim,kshp[0],kshp[1])
+#                                print 'imgvals.shape = ', imgvals.shape, imgvals.dtype
-                    kernvals = kernvals.reshape(nkern,-1)
+#                                imgvals = imgvals.reshape(bsize,-1)
-                    def testf(imgs, kerns):
-                        out, outshp = convolve2(kerns, kshp, nkern, imgs, 
-                                                   imshp, bsize, mode=mode)
-                        return out
-                    try:
+                                kernvals = N.array(N.random.rand(nkern,visdim,kshp[0],
-                        utt.verify_grad(testf, [imgvals, kernvals])
+                                                         kshp[1]),dtype=kerns.dtype)
-                    except NotImplementedError, e:
-                        print e
-    def test_ConvOpGrad32(self):
+#                                print 'kernvals.shape = ', kernvals.shape, kernvals.dtype
-        nkern = 4
+#                                kernvals = kernvals.reshape(nkern,-1)
-        bsize = 3
-        imgs  = T.fmatrix('imgs')
-        kerns = T.fmatrix('kerns')
                                def testf(imgs, kerns):
-            out, outshp = convolve2(kerns, kshp, nkern, imgs, 
+                                    out, outshp = convolve2(kerns, kshp, nkern, 
-                                       imshp, bsize, mode='valid')
+                                                            imgs, imshp, bsize, 
+                                                            mode=mode,
+                                                            unroll_batch=un_b,
+                                                            unroll_kern=un_k)
+                                    print "2",imgs.dtype,kerns.dtype
+                                    out = ConvOp(imshp,kshp,nkern,bsize,1,1,mode)(imgs,kerns)
                                    return out
-        for mode in 'valid', 'full':
-            for imshp in (1,5,5),(2,10,10): # (12,10), (3,12,11):
-                visdim = 1 if len(imshp)!=3 else imshp[0]
-                for kshp in (3,3),:# (6,7):
-                    imgvals = N.random.random(N.hstack((bsize,imshp)))
-                    print 'imgvals.shape = ', imgvals.shape
-                    imgvals = imgvals.reshape(bsize,-1)
-                    kernvals = N.random.rand(nkern,visdim,kshp[0],kshp[1])
-                    print 'kernvals.shape = ', kernvals.shape
-                    kernvals = kernvals.reshape(nkern,-1)
                                utt.verify_grad(testf, [imgvals, kernvals])
 if __name__ == '__main__':