make test for DownsampleFactorMax op faster and cover more case.

theano/sandbox/test_downsample.py

@@ -5,24 +5,30 @@ from theano.tests import unittest_tools as utt
 from theano.sandbox.downsample import DownsampleFactorMax, max_pool
 from theano import function, Mode
 
-class TestDownSample(unittest.TestCase):
+class TestDownsampleFactorMax(unittest.TestCase):
     def test_maxpool(self):
         # generate flatted images
         maxpoolshps = ((1,1),(2,2),(3,3),(2,3))
         imval = N.random.rand(4,10,64,64)
-        do_theano=True
         images = T.dmatrix()
         dmatrix4=T.TensorType('float64', (False, False, False, False))
         images4=dmatrix4()
-        tctot, tpytot, ntot, gtot= [],[],[],[]
+        tctot, tpytot, ntot = [],[],[]
         for maxpoolshp in maxpoolshps:
-
-            print 'maxpoolshp', maxpoolshp
+            for border in [True,False]:
+                print 'maxpoolshp', maxpoolshp,'border', border
            
                 # numeric verification
+                xi=0
+                yi=0
+                if not border:
+                    if imval.shape[-2] % maxpoolshp[0]:
+                        xi += 1
+                    if imval.shape[-1] % maxpoolshp[1]:
+                        yi += 1
                 my_output_val = N.zeros((imval.shape[0], imval.shape[1],
-                                     imval.shape[2]/maxpoolshp[0],
-                                     imval.shape[3]/maxpoolshp[1]))
+                                         imval.shape[2]/maxpoolshp[0]+xi,
+                                         imval.shape[3]/maxpoolshp[1]+yi))
             
                 time1=time.time()
                 for n in range(imval.shape[0]):
@@ -37,37 +43,29 @@ class TestDownSample(unittest.TestCase):
                 ntot+=[time.time()-time1]
 
                 # symbolic stuff
-            if do_theano:
             #### wrapper to DownsampleFactorMax op ####
-                output, outshp = max_pool(images, imval.shape[1:], maxpoolshp)
+                output, outshp = max_pool(images, imval.shape[1:], maxpoolshp, border)
                 assert N.prod(my_output_val.shape[1:]) == N.prod(outshp)
-                print outshp
-                print my_output_val.shape
                 assert N.prod(my_output_val.shape[1:]) == N.prod(outshp)
                 f = function([images,],[output,])
                 imval2=imval.reshape(imval.shape[0],-1)
                 output_val = f(imval2)
                 assert N.all(output_val == my_output_val)
-            else:
-                tctot=-1
-                output_val = my_output_val.copy()
                 
                 #DownsampleFactorMax op
-            maxpool_op = DownsampleFactorMax(maxpoolshp, ignore_border=True)(images4)
+                maxpool_op = DownsampleFactorMax(maxpoolshp, ignore_border=border)(images4)
                 f = function([images4],maxpool_op,mode=Mode(linker="py"))
                 f2 = function([images4],maxpool_op,mode=Mode(linker="c"))
+                f3 = function([images4],maxpool_op)#for when we want to use the debug mode
                 time1=time.time()
-            output_val2 = f(imval)
-            tpytot+=[time.time()-time1]
-            assert (N.abs(my_output_val.flatten()-output_val2.flatten())<1e-5).all()
-            time1=time.time()
-            output_val2 = f2(imval)
+                output_val = f(imval)
                 tctot+=[time.time()-time1]
-            assert (N.abs(my_output_val.flatten()-output_val2.flatten())<1e-5).all()
-
-            def mp(input):
-                output, outshp = max_pool(input, imval.shape[1:], maxpoolshp)
-                return output
+                assert (N.abs(my_output_val.flatten()-output_val.flatten())<1e-5).all()
+                time1=time.time()
+                output_val = f2(imval)
+                tpytot+=[time.time()-time1]
+                assert (N.abs(my_output_val.flatten()-output_val.flatten())<1e-5).all()
+                output_val = f3(imval)
 
         print 'Numpy processing time: %.3fs'%sum(ntot),ntot
         print 'c Theano(DownsampleFactorMax) processing time: %.3fs'%sum(tctot),tctot
@@ -76,29 +74,21 @@ class TestDownSample(unittest.TestCase):
         print 'speed up c theano(DownsampleFactorMax) vs manual: %.3f'%d.mean(),d
         d=N.asarray(ntot)/tpytot
         print 'speed up py theano(DownsampleFactorMax) vs manual: %.3f'%d.mean(),d
-        print 'verify_grad time %.3f'%sum(gtot),
 
-    def test_maxpool_grad(self):
+    def test_DownsampleFactorMax_grad(self):
         # generate flatted images
-        maxpoolshps = ((1,1),(2,2),(3,3),(2,3))
-        imval = N.random.rand(3,7,10,10) * 10.0 #more variance means numeric gradient will be more accurate
+        maxpoolshps = ((1,1),(3,2),(2,3))
+        imval = N.random.rand(2,3,3,4) * 10.0 #more variance means numeric gradient will be more accurate
         do_theano=True
-        images = T.dmatrix()
-        dmatrix4=T.TensorType('float64', (False, False, False, False))
-        images4=dmatrix4()
         for maxpoolshp in maxpoolshps:
-            print 'maxpoolshp', maxpoolshp
+            for border in [True,False]:
+                print 'maxpoolshp', maxpoolshp, 'border', border
                 def mp(input):
-                output, outshp = max_pool(input, imval.shape[1:], maxpoolshp)
-                return output
-            print >> sys.stderr, 'max_pool verify_grad requires unusually large tolerance... is it correct?'
-            utt.verify_grad(mp, [imval.reshape(imval.shape[0],-1)], tol=1e-2)
+                    return DownsampleFactorMax(maxpoolshp, ignore_border=border)(input)
+                utt.verify_grad(mp, [imval])
 
 if __name__ == '__main__':
-    t = TestSP("test_convolution")
-    t = TestSP("test_maxpool").run()
-#    t.test_convolution()
-#    t.test_multilayer_conv()
+    t = TestDownsampleFactorMax("test_maxpool").run()
     #t.test_maxpool()
     from theano.tests import main
 #    main("test_sp")