some pep8

theano/scan_module/tests/test_scan.py

@@ -86,7 +86,7 @@ class multiple_outputs_numeric_grad:
                     dtype_eps = _eps
 
         self.ndarray_mask = ndarray_mask
-        #'''
+        # '''
         # Compute clean output:
         f_x = f(*pt)
         gx = []
@@ -148,7 +148,7 @@ class multiple_outputs_numeric_grad:
             return numpy.inf, 0
 
 
-#TODO: Test this function, and if it works,
+# TODO: Test this function, and if it works,
 # use it with the normal verify_grad rather than the
 # copy-and-pasted one above.
 # Also - add a reference to this technique in the
@@ -201,7 +201,6 @@ def grab_scan_node(output):
 
 
 class T_Scan(unittest.TestCase):
-#class T_Scan(object):
 
     def setUp(self):
         utt.seed_rng()
@@ -230,7 +229,7 @@ class T_Scan(unittest.TestCase):
                                 updates=updates,
                                 allow_input_downcast=True)
 
-        ### TESTING PICKLE-ing this function
+        # TESTING PICKLE-ing this function
         origdir = os.getcwd()
         tmpdir = None
         try:
@@ -367,7 +366,7 @@ class T_Scan(unittest.TestCase):
     # This first version test the first case in the optimizer to the gpu.
     def test_one_sequence_one_output_weights_gpu1(self):
         from theano.sandbox import cuda
-        if cuda.cuda_available == False:
+        if not cuda.cuda_available:
             raise SkipTest('Optional package cuda disabled')
 
         def f_rnn(u_t, x_tm1, W_in, W):
@@ -447,7 +446,7 @@ class T_Scan(unittest.TestCase):
     # This second version test the second case in the optimizer to the gpu.
     def test_one_sequence_one_output_weights_gpu2(self):
         from theano.sandbox import cuda
-        if cuda.cuda_available == False:
+        if not cuda.cuda_available:
             raise SkipTest('Optional package cuda disabled')
 
         def f_rnn(u_t, x_tm1, W_in, W):
@@ -511,7 +510,7 @@ class T_Scan(unittest.TestCase):
     # outputs when is running on GPU
     def test_gpu3_mixture_dtype_outputs(self):
         from theano.sandbox import cuda
-        if cuda.cuda_available == False:
+        if not cuda.cuda_available:
             raise SkipTest('Optional package cuda disabled')
 
         def f_rnn(u_t, x_tm1, W_in, W):
@@ -595,8 +594,8 @@ class T_Scan(unittest.TestCase):
         v_out = numpy.zeros((4,))
         v_out[0] = v_u[0] * W_in.get_value() + v_x0 * W.get_value()
         for step in xrange(1, 4):
-            v_out[step] = v_u[step] * W_in.get_value() + \
-                    v_out[step - 1] * W.get_value()
+            v_out[step] = (v_u[step] * W_in.get_value() +
+                           v_out[step - 1] * W.get_value())
 
         theano_values = f3(v_u, v_x0)
         assert numpy.allclose(theano_values, v_out)
@@ -624,7 +623,7 @@ class T_Scan(unittest.TestCase):
         y0 = theano.tensor.scalar('y0')
 
         def f_rnn_cmpl(u1_t, u2_t, x_tm1, y_tm1, W_in1):
-            return [theano.dot(u1_t, W_in1) + u2_t * W_in2 + \
+            return [theano.dot(u1_t, W_in1) + u2_t * W_in2 +
                     theano.dot(x_tm1, W), theano.dot(x_tm1, W_out)]
 
         outputs, updates = theano.scan(f_rnn_cmpl,
@@ -643,12 +642,12 @@ class T_Scan(unittest.TestCase):
         # compute the values in numpy
         v_x = numpy.zeros((3, 2), dtype=theano.config.floatX)
         v_y = numpy.zeros((3,), dtype=theano.config.floatX)
-        v_x[0] = numpy.dot(v_u1[0], vW_in1) + v_u2[0] * vW_in2 + \
-                    numpy.dot(v_x0, vW)
+        v_x[0] = (numpy.dot(v_u1[0], vW_in1) + v_u2[0] * vW_in2 +
+                  numpy.dot(v_x0, vW))
         v_y[0] = numpy.dot(v_x0, vWout)
         for i in xrange(1, 3):
-            v_x[i] = numpy.dot(v_u1[i], vW_in1) + v_u2[i] * vW_in2 + \
-                        numpy.dot(v_x[i - 1], vW)
+            v_x[i] = (numpy.dot(v_u1[i], vW_in1) + v_u2[i] * vW_in2 +
+                      numpy.dot(v_x[i - 1], vW))
             v_y[i] = numpy.dot(v_x[i - 1], vWout)
 
         (theano_x, theano_y) = f4(v_u1, v_u2, v_x0, v_y0, vW_in1)
@@ -684,8 +683,8 @@ class T_Scan(unittest.TestCase):
                        y_tm1,
                        y_tm3,
                        W_in1):
-            return [theano.dot(u1_t, W_in1) + \
-                        (u2_t + u2_tm1 * u2_tp1) * W_in2 + \
+            return [theano.dot(u1_t, W_in1) +
+                    (u2_t + u2_tm1 * u2_tp1) * W_in2 +
                     theano.dot(x_tm1, W),
                     (y_tm1 + y_tm3) * theano.dot(x_tm1, W_out),
                     theano.dot(u1_t, W_in1)]
@@ -891,10 +890,10 @@ class T_Scan(unittest.TestCase):
         numpy_x0[0] = vu0[0] * vW_in + vx0 * vW + vu1[0] * vu2[0]
         numpy_x1[0] = vu0[0] * vW_in + vx1 * vW + vu1[0] + vu2[0]
         for i in xrange(1, 3):
-            numpy_x0[i] = vu0[i] * vW_in + numpy_x0[i - 1] * vW + \
-                    vu1[i] * vu2[i]
-            numpy_x1[i] = vu0[i] * vW_in + numpy_x1[i - 1] * vW + \
-                    vu1[i] + vu2[i]
+            numpy_x0[i] = (vu0[i] * vW_in + numpy_x0[i - 1] * vW +
+                           vu1[i] * vu2[i])
+            numpy_x1[i] = (vu0[i] * vW_in + numpy_x1[i - 1] * vW +
+                           vu1[i] + vu2[i])
 
         # note theano computes inplace, so call function after numpy
         # equivalent is done
@@ -908,8 +907,8 @@ class T_Scan(unittest.TestCase):
         # Old way of doing inplace operations is deprecated .. tests don't
         # make sense anymore.
 
-        ##utt.assert_allclose( theano_x0 , vu2)
-        ## utt.assert_allclose( theano_x1 , vu1)
+        ## utt.assert_allclose(theano_x0 , vu2)
+        ## utt.assert_allclose(theano_x1 , vu1)
 
     # simple rnn ; compute inplace version 2
     def test_inplace2(self):
@@ -971,10 +970,10 @@ class T_Scan(unittest.TestCase):
         numpy_x0[0] = vu0[0] * vW_in + vx0 * vW + vu1[0] * vu1[1]
         numpy_x1[0] = vu0[0] * vW_in + vx1 * vW + vu2[0] + vu2[1] + vu2[2]
         for i in xrange(1, 3):
-            numpy_x0[i] = vu0[i] * vW_in + numpy_x0[i - 1] * vW + \
-                    vu1[i] * vu1[i + 1]
-            numpy_x1[i] = vu0[i] * vW_in + numpy_x1[i - 1] * vW + \
-                    vu2[i] + vu2[i + 1] + vu2[i + 2]
+            numpy_x0[i] = (vu0[i] * vW_in + numpy_x0[i - 1] * vW +
+                           vu1[i] * vu1[i + 1])
+            numpy_x1[i] = (vu0[i] * vW_in + numpy_x1[i - 1] * vW +
+                           vu2[i] + vu2[i + 1] + vu2[i + 2])
 
         # note theano computes inplace, so call function after numpy
         # equivalent is done
@@ -1069,8 +1068,8 @@ class T_Scan(unittest.TestCase):
         y1 = theano.shared(vy1, 'y1')
 
         def f(u1_t, u2_t, y0_tm3, y0_tm2, y0_tm1, y1_tm1):
-            y0_t = theano.dot(theano.dot(u1_t, W1), W2) + 0.1 * y0_tm1 + \
-                    0.33 * y0_tm2 + 0.17 * y0_tm3
+            y0_t = (theano.dot(theano.dot(u1_t, W1), W2) + 0.1 * y0_tm1 +
+                    0.33 * y0_tm2 + 0.17 * y0_tm3)
             y1_t = theano.dot(u2_t, W2) + y1_tm1
             y2_t = theano.dot(u1_t, W1)
             nwW1 = W1 + .1
@@ -1106,14 +1105,13 @@ class T_Scan(unittest.TestCase):
         numpy_W1 = vW1.copy()
         numpy_W2 = vW2.copy()
         for idx in xrange(3):
-            numpy_y0[idx + 3] = numpy.dot(\
-                                          numpy.dot(vu1[idx, :], numpy_W1), \
+            numpy_y0[idx + 3] = numpy.dot(numpy.dot(vu1[idx, :], numpy_W1),
                                           numpy_W2) + \
                                 0.1 * numpy_y0[idx + 2] + \
                                 0.33 * numpy_y0[idx + 1] + \
                                 0.17 * numpy_y0[idx]
-            numpy_y1[idx + 1] = numpy.dot(vu2[idx, :], numpy_W2) +\
-                                numpy_y1[idx]
+            numpy_y1[idx + 1] = (numpy.dot(vu2[idx, :], numpy_W2) +
+                                 numpy_y1[idx])
             numpy_y2[idx] = numpy.dot(vu1[idx, :], numpy_W1)
             numpy_W1 = numpy_W1 + .1
             numpy_W2 = numpy_W2 + .05
@@ -1196,7 +1194,7 @@ class T_Scan(unittest.TestCase):
 
     def test_cuda_gibbs_chain(self):
         from theano.sandbox import cuda
-        if cuda.cuda_available == False:
+        if not cuda.cuda_available:
             raise SkipTest('Optional package cuda disabled')
 
         rng = numpy.random.RandomState(utt.fetch_seed())