pep8

theano/sandbox/cuda/tests/test_gemmcorr3d.py

@@ -10,7 +10,8 @@ import theano.sandbox.cuda as cuda_ndarray
 if not cuda_ndarray.cuda_available:
     raise SkipTest('Optional package cuda not available')
 from theano.sandbox.cuda import float32_shared_constructor as shared
-from  theano.sandbox.cuda.blas import GpuCorr3dMM, GpuCorr3dMM_gradWeights, GpuCorr3dMM_gradInputs
+from theano.sandbox.cuda.blas import (
+    GpuCorr3dMM, GpuCorr3dMM_gradWeights, GpuCorr3dMM_gradInputs)
 from theano.sandbox.cuda.basic_ops import gpu_contiguous
 
 if theano.config.mode == 'FAST_COMPILE':
@@ -31,9 +32,10 @@ class TestCorr3DMM(unittest.TestCase):
         bias = shared(numpy.zeros(filters_shape[0]).astype('float32'))
         conv_ref = theano.tensor.nnet.conv3D(V=inputs, W=filters,
                                              b=bias, d=subsample)
-        conv = GpuCorr3dMM(border_mode = "valid",
-                           subsample=subsample)(inputs.dimshuffle(0, 4, 1, 2, 3),
-                                                filters.dimshuffle(0, 4, 1, 2, 3))
+        conv = GpuCorr3dMM(border_mode="valid",
+                           subsample=subsample)(
+                               inputs.dimshuffle(0, 4, 1, 2, 3),
+                               filters.dimshuffle(0, 4, 1, 2, 3))
         conv = conv.dimshuffle(0, 2, 3, 4, 1)
 
         f_ref = theano.function([], conv_ref)
@@ -66,24 +68,23 @@ class TestCorr3DMM(unittest.TestCase):
                             subsample=(1, 2, 3))
 
     def run_gradweight(self, inputs_shape, filters_shape, dCdH_shape,
-                        subsample=(1, 1, 1)):
+                       subsample=(1, 1, 1)):
         inputs_val = numpy.random.random(inputs_shape).astype('float32')
         dCdH_val = numpy.random.random(dCdH_shape).astype('float32')
         inputs = shared(inputs_val)
         dCdH = shared(dCdH_val)
 
         conv = theano.tensor.nnet.convGrad3D(V=inputs, dCdH=dCdH,
-                                              WShape=filters_shape,
-                                              d=subsample)
+                                             WShape=filters_shape,
+                                             d=subsample)
         img = gpu_contiguous(inputs.dimshuffle(0, 4, 1, 2, 3))
         topgrad = gpu_contiguous(dCdH.dimshuffle(0, 4, 1, 2, 3))
         if (subsample == (1, 1, 1)):
             conv_gemm = GpuCorr3dMM_gradWeights(subsample=subsample)(img,
                                                                      topgrad)
         else:
-            conv_gemm = GpuCorr3dMM_gradWeights(subsample=subsample)(img,
-                                                                     topgrad,
-                                                                     shape=filters_shape[1:4])
+            conv_gemm = GpuCorr3dMM_gradWeights(subsample=subsample)(
+                img, topgrad, shape=filters_shape[1:4])
         conv_gemm = conv_gemm.dimshuffle(0, 2, 3, 4, 1)
         f_ref = theano.function([], conv)
         f = theano.function([], conv_gemm, mode=mode_with_gpu)
@@ -124,7 +125,7 @@ class TestCorr3DMM(unittest.TestCase):
         f_ref = theano.function([], conv)
         res_ref = f_ref()
 
-        ### Get bottom shape using convTransp3D
+        # Get bottom shape using convTransp3D
         bottom_shape = res_ref.shape
         bottom_val = numpy.random.random(bottom_shape).astype('float32')
         bottom = shared(bottom_val)
@@ -132,10 +133,12 @@ class TestCorr3DMM(unittest.TestCase):
         weight = gpu_contiguous(filters.dimshuffle(0, 4, 1, 2, 3))
         top = gpu_contiguous(inputs.dimshuffle(0, 4, 1, 2, 3))
         if (subsample == (1, 1, 1)):
-            conv_gemm = GpuCorr3dMM_gradInputs(subsample=subsample)(kern=weight, topgrad=top)
+            conv_gemm = GpuCorr3dMM_gradInputs(subsample=subsample)(
+                kern=weight, topgrad=top)
         else:
-            conv_gemm = GpuCorr3dMM_gradInputs(subsample=subsample)(kern=weight, topgrad=top,
-                                                                    shape=bottom.shape[1:4])
+            conv_gemm = GpuCorr3dMM_gradInputs(subsample=subsample)(
+                kern=weight, topgrad=top,
+                shape=bottom.shape[1:4])
         conv_gemm = conv_gemm.dimshuffle(0, 2, 3, 4, 1)
         f = theano.function([], conv_gemm, mode=mode_with_gpu)
 
@@ -147,14 +150,13 @@ class TestCorr3DMM(unittest.TestCase):
                            filters_shape=(10, 6, 12, 4, 1))
         self.run_gradinput(inputs_shape=(16, 15, 12, 12, 10),
                            filters_shape=(10, 6, 12, 4, 1),
-                           subsample=(2,2,2))
+                           subsample=(2, 2, 2))
         self.run_gradinput(inputs_shape=(16, 15, 12, 12, 10),
                            filters_shape=(10, 6, 12, 4, 1),
-                           subsample=(3,3,3))
+                           subsample=(3, 3, 3))
         self.run_gradinput(inputs_shape=(16, 15, 12, 12, 10),
                            filters_shape=(10, 6, 12, 4, 1),
-                           subsample=(3,1,2))
-
+                           subsample=(3, 1, 2))
 
     def test_opt_conv3d_gemm(self):
         inputs_shape = (16, 20, 32, 16, 1)
@@ -168,7 +170,7 @@ class TestCorr3DMM(unittest.TestCase):
         bias = shared(numpy.zeros(filters_shape[0]).astype('float32'))
 
         conv = theano.tensor.nnet.conv3D(V=inputs, W=filters,
-                                         b=bias, d=(1,1,1))
+                                         b=bias, d=(1, 1, 1))
         mode = mode_with_gpu.including('conv3d_gemm')
 
         f_ref = theano.function([], conv)
@@ -195,7 +197,7 @@ class TestCorr3DMM(unittest.TestCase):
 
         conv = theano.tensor.nnet.convGrad3D(V=inputs, dCdH=dCdH,
                                              WShape=filters_shape,
-                                             d=(1,1,1))
+                                             d=(1, 1, 1))
         mode = mode_with_gpu.including('convgrad3d_gemm')
 
         f_ref = theano.function([], conv)
@@ -209,7 +211,6 @@ class TestCorr3DMM(unittest.TestCase):
         res_gemm = f_gemm()
         utt.assert_allclose(res_ref, res_gemm)
 
-
     def test_opt_convtransp3d_gemm(self):
         inputs_shape = (16, 15, 12, 12, 10)
         filters_shape = (10, 6, 12, 4, 1)
@@ -221,7 +222,7 @@ class TestCorr3DMM(unittest.TestCase):
         inputs = shared(inputs_val)
         filters = shared(filters_val)
 
-        conv = theano.tensor.nnet.convTransp3D(W=filters, b=bias, d=(1,1,1),
+        conv = theano.tensor.nnet.convTransp3D(W=filters, b=bias, d=(1, 1, 1),
                                                H=inputs)
         mode = mode_with_gpu.including('convtransp3d_gemm')
 
@@ -235,4 +236,3 @@ class TestCorr3DMM(unittest.TestCase):
         res_ref = f_ref()
         res_gemm = f_gemm()
         utt.assert_allclose(res_ref, res_gemm)
-