Fix a bunch of flake8/pep8 errors

Author: lamblin

code/DBN.py

@@ -1,7 +1,5 @@
 """
 """
-import cPickle
-import gzip
 import os
 import sys
 import time
@@ -372,7 +370,6 @@ def test_DBN(finetune_lr=0.1, pretraining_epochs=100,
                                   # on the validation set; in this case we
                                   # check every epoch
 
-    best_params = None
     best_validation_loss = numpy.inf
     test_score = 0.
     start_time = time.clock()
@@ -430,9 +427,10 @@ def test_DBN(finetune_lr=0.1, pretraining_epochs=100,
     end_time = time.clock()
     print(
         (
-            'Optimization complete with best validation score of %f %%,'
+            'Optimization complete with best validation score of %f %%, '
+            'obtained at iteration %i, '
             'with test performance %f %%'
-        ) % (best_validation_loss * 100., test_score * 100.)
+        ) % (best_validation_loss * 100., best_iter + 1, test_score * 100.)
     )
     print >> sys.stderr, ('The fine tuning code for file ' +
                           os.path.split(__file__)[1] +

code/SdA.py

@@ -29,8 +29,6 @@
    Systems 19, 2007
 
 """
-import cPickle
-import gzip
 import os
 import sys
 import time
@@ -202,8 +200,6 @@ def pretraining_functions(self, train_set_x, batch_size):
         index = T.lscalar('index')  # index to a minibatch
         corruption_level = T.scalar('corruption')  # % of corruption to use
         learning_rate = T.scalar('lr')  # learning rate to use
-        # number of batches
-        n_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size
         # begining of a batch, given `index`
         batch_begin = index * batch_size
         # ending of a batch given `index`
@@ -429,7 +425,6 @@ def test_SdA(finetune_lr=0.1, pretraining_epochs=15,
                                   # on the validation set; in this case we
                                   # check every epoch
 
-    best_params = None
     best_validation_loss = numpy.inf
     test_score = 0.
     start_time = time.clock()
@@ -479,10 +474,11 @@ def test_SdA(finetune_lr=0.1, pretraining_epochs=15,
     end_time = time.clock()
     print(
         (
-            'Optimization complete with best validation score of %f %%,'
+            'Optimization complete with best validation score of %f %%, '
+            'on iteration %i, '
             'with test performance %f %%'
         )
-        % (best_validation_loss * 100., test_score * 100.)
+        % (best_validation_loss * 100., best_iter + 1, test_score * 100.)
     )
     print >> sys.stderr, ('The training code for file ' +
                           os.path.split(__file__)[1] +

code/cA.py

@@ -12,7 +12,8 @@
  squared Frobenius norm of the Jacobian of the hidden mapping h with
  respect to the visible units yields the contractive auto-encoder:
 
-      - \sum_{k=1}^d[ x_k \log z_k + (1-x_k) \log( 1-z_k)] + \| \frac{\partial h(x)}{\partial x} \|^2
+      - \sum_{k=1}^d[ x_k \log z_k + (1-x_k) \log( 1-z_k)]
+      + \| \frac{\partial h(x)}{\partial x} \|^2
 
  References :
    - S. Rifai, P. Vincent, X. Muller, X. Glorot, Y. Bengio: Contractive
@@ -27,8 +28,6 @@
    Systems 19, 2007
 
 """
-import cPickle
-import gzip
 import os
 import sys
 import time
@@ -79,11 +78,11 @@ class cA(object):
 
     def __init__(self, numpy_rng, input=None, n_visible=784, n_hidden=100,
                  n_batchsize=1, W=None, bhid=None, bvis=None):
-        """Initialize the cA class by specifying the number of visible units (the
-        dimension d of the input ), the number of hidden units ( the dimension
-        d' of the latent or hidden space ) and the contraction level. The
-        constructor also receives symbolic variables for the input, weights and
-        bias.
+        """Initialize the cA class by specifying the number of visible units
+        (the dimension d of the input), the number of hidden units (the
+        dimension d' of the latent or hidden space) and the contraction level.
+        The constructor also receives symbolic variables for the input, weights
+        and bias.
 
         :type numpy_rng: numpy.random.RandomState
         :param numpy_rng: number random generator used to generate weights
@@ -161,7 +160,7 @@ def __init__(self, numpy_rng, input=None, n_visible=784, n_hidden=100,
         self.W_prime = self.W.T
 
         # if no input is given, generate a variable representing the input
-        if input == None:
+        if input is None:
             # we use a matrix because we expect a minibatch of several
             # examples, each example being a row
             self.x = T.dmatrix(name='input')

code/convolutional_mlp.py

@@ -21,8 +21,6 @@
    http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf
 
 """
-import cPickle
-import gzip
 import os
 import sys
 import time
@@ -53,14 +51,14 @@ def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):
 
         :type filter_shape: tuple or list of length 4
         :param filter_shape: (number of filters, num input feature maps,
-                              filter height,filter width)
+                              filter height, filter width)
 
         :type image_shape: tuple or list of length 4
         :param image_shape: (batch size, num input feature maps,
                              image height, image width)
 
         :type poolsize: tuple or list of length 2
-        :param poolsize: the downsampling (pooling) factor (#rows,#cols)
+        :param poolsize: the downsampling (pooling) factor (#rows, #cols)
         """
 
         assert image_shape[1] == filter_shape[1]
@@ -104,7 +102,7 @@ def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):
         )
 
         # add the bias term. Since the bias is a vector (1D array), we first
-        # reshape it to a tensor of shape (1,n_filters,1,1). Each bias will
+        # reshape it to a tensor of shape (1, n_filters, 1, 1). Each bias will
         # thus be broadcasted across mini-batches and feature map
         # width & height
         self.output = T.tanh(pooled_out + self.b.dimshuffle('x', 0, 'x', 'x'))
@@ -155,21 +153,21 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     x = T.matrix('x')   # the data is presented as rasterized images
     y = T.ivector('y')  # the labels are presented as 1D vector of
                         # [int] labels
-    ishape = (28, 28)  # this is the size of MNIST images
 
     ######################
     # BUILD ACTUAL MODEL #
     ######################
     print '... building the model'
 
-    # Reshape matrix of rasterized images of shape (batch_size,28*28)
+    # Reshape matrix of rasterized images of shape (batch_size, 28 * 28)
     # to a 4D tensor, compatible with our LeNetConvPoolLayer
+    # (28, 28) is the size of MNIST images.
     layer0_input = x.reshape((batch_size, 1, 28, 28))
 
     # Construct the first convolutional pooling layer:
-    # filtering reduces the image size to (28-5+1,28-5+1)=(24,24)
-    # maxpooling reduces this further to (24/2,24/2) = (12,12)
-    # 4D output tensor is thus of shape (batch_size,nkerns[0],12,12)
+    # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24)
+    # maxpooling reduces this further to (24/2, 24/2) = (12, 12)
+    # 4D output tensor is thus of shape (batch_size, nkerns[0], 12, 12)
     layer0 = LeNetConvPoolLayer(
         rng,
         input=layer0_input,
@@ -179,9 +177,9 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     )
 
     # Construct the second convolutional pooling layer
-    # filtering reduces the image size to (12-5+1,12-5+1)=(8,8)
-    # maxpooling reduces this further to (8/2,8/2) = (4,4)
-    # 4D output tensor is thus of shape (nkerns[0],nkerns[1],4,4)
+    # filtering reduces the image size to (12-5+1, 12-5+1) = (8, 8)
+    # maxpooling reduces this further to (8/2, 8/2) = (4, 4)
+    # 4D output tensor is thus of shape (nkerns[0], nkerns[1], 4, 4)
     layer1 = LeNetConvPoolLayer(
         rng,
         input=layer0.output,
@@ -240,7 +238,7 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     # SGD Since this model has many parameters, it would be tedious to
     # manually create an update rule for each model parameter. We thus
     # create the updates list by automatically looping over all
-    # (params[i],grads[i]) pairs.
+    # (params[i], grads[i]) pairs.
     updates = [
         (param_i, param_i - learning_rate * grad_i)
         for param_i, grad_i in zip(params, grads)
@@ -273,7 +271,6 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
                                   # on the validation set; in this case we
                                   # check every epoch
 
-    best_params = None
     best_validation_loss = numpy.inf
     best_iter = 0
     test_score = 0.
@@ -331,7 +328,7 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
 
     end_time = time.clock()
     print('Optimization complete.')
-    print('Best validation score of %f %% obtained at iteration %i,'
+    print('Best validation score of %f %% obtained at iteration %i, '
           'with test performance %f %%' %
           (best_validation_loss * 100., best_iter + 1, test_score * 100.))
     print >> sys.stderr, ('The code for file ' +

code/dA.py

@@ -30,8 +30,6 @@
 
 """
 
-import cPickle
-import gzip
 import os
 import sys
 import time
@@ -185,7 +183,7 @@ def __init__(
         self.W_prime = self.W.T
         self.theano_rng = theano_rng
         # if no input is given, generate a variable representing the input
-        if input == None:
+        if input is None:
             # we use a matrix because we expect a minibatch of several
             # examples, each example being a row
             self.x = T.dmatrix(name='input')

code/hmc/hmc.py

@@ -8,8 +8,8 @@
 from theano import tensor as TT
 import theano
 
-sharedX = lambda X, name: \
-        shared(numpy.asarray(X, dtype=theano.config.floatX), name=name)
+sharedX = (lambda X, name:
+           shared(numpy.asarray(X, dtype=theano.config.floatX), name=name))
 
 
 def kinetic_energy(vel):
@@ -145,13 +145,14 @@ def leapfrog(pos, vel, step):
 
     # perform leapfrog updates: the scan op is used to repeatedly compute
     # vel(t + (m-1/2)*stepsize) and pos(t + m*stepsize) for m in [2,n_steps].
-    (all_pos, all_vel), scan_updates = theano.scan(leapfrog,
-            outputs_info=[
-                dict(initial=pos_full_step),
-                dict(initial=vel_half_step),
-                ],
-            non_sequences=[stepsize],
-            n_steps=n_steps - 1)
+    (all_pos, all_vel), scan_updates = theano.scan(
+        leapfrog,
+        outputs_info=[
+            dict(initial=pos_full_step),
+            dict(initial=vel_half_step),
+        ],
+        non_sequences=[stepsize],
+        n_steps=n_steps - 1)
     final_pos = all_pos[-1]
     final_vel = all_vel[-1]
     # NOTE: Scan always returns an updates dictionary, in case the
@@ -171,6 +172,7 @@ def leapfrog(pos, vel, step):
     # return new proposal state
     return final_pos, final_vel
 
+
 # start-snippet-1
 def hmc_move(s_rng, positions, energy_fn, stepsize, n_steps):
     """
@@ -224,10 +226,11 @@ def hmc_move(s_rng, positions, energy_fn, stepsize, n_steps):
     # end-snippet-4
     return accept, final_pos
 
+
 # start-snippet-5
 def hmc_updates(positions, stepsize, avg_acceptance_rate, final_pos, accept,
-                 target_acceptance_rate, stepsize_inc, stepsize_dec,
-                 stepsize_min, stepsize_max, avg_acceptance_slowness):
+                target_acceptance_rate, stepsize_inc, stepsize_dec,
+                stepsize_min, stepsize_max, avg_acceptance_slowness):
     """This function is executed after `n_steps` of HMC sampling
     (`hmc_move` function). It creates the updates dictionary used by
     the `simulate` function. It takes care of updating: the position
@@ -293,14 +296,15 @@ def hmc_updates(positions, stepsize, avg_acceptance_rate, final_pos, accept,
     # perform exponential moving average
     mean_dtype = theano.scalar.upcast(accept.dtype, avg_acceptance_rate.dtype)
     new_acceptance_rate = TT.add(
-            avg_acceptance_slowness * avg_acceptance_rate,
-            (1.0 - avg_acceptance_slowness) * accept.mean(dtype=mean_dtype))
+        avg_acceptance_slowness * avg_acceptance_rate,
+        (1.0 - avg_acceptance_slowness) * accept.mean(dtype=mean_dtype))
     # end-snippet-6 start-snippet-8
     return [(positions, new_positions),
             (stepsize, new_stepsize),
             (avg_acceptance_rate, new_acceptance_rate)]
     # end-snippet-8
 
+
 class HMC_sampler(object):
     """
     Convenience wrapper for performing Hybrid Monte Carlo (HMC). It creates the
@@ -322,11 +326,11 @@ def __init__(self, **kwargs):
 
     @classmethod
     def new_from_shared_positions(
-        cls, 
-        shared_positions, 
+        cls,
+        shared_positions,
         energy_fn,
-        initial_stepsize=0.01, 
-        target_acceptance_rate=.9, 
+        initial_stepsize=0.01,
+        target_acceptance_rate=.9,
         n_steps=20,
         stepsize_dec=0.98,
         stepsize_min=0.001,
@@ -350,8 +354,6 @@ def new_from_shared_positions(
             sampling to work.
 
         """
-        batchsize = shared_positions.shape[0]
-
         # allocate shared variables
         stepsize = sharedX(initial_stepsize, 'hmc_stepsize')
         avg_acceptance_rate = sharedX(target_acceptance_rate,
@@ -360,40 +362,40 @@ def new_from_shared_positions(
 
         # define graph for an `n_steps` HMC simulation
         accept, final_pos = hmc_move(
-                s_rng,
-                shared_positions,
-                energy_fn,
-                stepsize,
-                n_steps)
+            s_rng,
+            shared_positions,
+            energy_fn,
+            stepsize,
+            n_steps)
 
         # define the dictionary of updates, to apply on every `simulate` call
         simulate_updates = hmc_updates(
-                shared_positions,
-                stepsize,
-                avg_acceptance_rate,
-                final_pos=final_pos,
-                accept=accept,
-                stepsize_min=stepsize_min,
-                stepsize_max=stepsize_max,
-                stepsize_inc=stepsize_inc,
-                stepsize_dec=stepsize_dec,
-                target_acceptance_rate=target_acceptance_rate,
-                avg_acceptance_slowness=avg_acceptance_slowness)
+            shared_positions,
+            stepsize,
+            avg_acceptance_rate,
+            final_pos=final_pos,
+            accept=accept,
+            stepsize_min=stepsize_min,
+            stepsize_max=stepsize_max,
+            stepsize_inc=stepsize_inc,
+            stepsize_dec=stepsize_dec,
+            target_acceptance_rate=target_acceptance_rate,
+            avg_acceptance_slowness=avg_acceptance_slowness)
 
         # compile theano function
         simulate = function([], [], updates=simulate_updates)
 
         # create HMC_sampler object with the following attributes ...
         return cls(
-                positions=shared_positions,
-                stepsize=stepsize,
-                stepsize_min=stepsize_min,
-                stepsize_max=stepsize_max,
-                avg_acceptance_rate=avg_acceptance_rate,
-                target_acceptance_rate=target_acceptance_rate,
-                s_rng=s_rng,
-                _updates=simulate_updates,
-                simulate=simulate)
+            positions=shared_positions,
+            stepsize=stepsize,
+            stepsize_min=stepsize_min,
+            stepsize_max=stepsize_max,
+            avg_acceptance_rate=avg_acceptance_rate,
+            target_acceptance_rate=target_acceptance_rate,
+            s_rng=s_rng,
+            _updates=simulate_updates,
+            simulate=simulate)
 
     def draw(self, **kwargs):
         """