Ran code through pep8 and fixed all occurrences of E251 unexpected spaces around keyword / parameter equals. Fixed indentation of comments in rnnrbm.py.

Author: mspandit

code/SdA.py

@@ -59,11 +59,11 @@ class SdA(object):
 
     def __init__(self, 
         numpy_rng, 
-        theano_rng = None, 
-        n_ins = 784,
-        hidden_layers_sizes = [500, 500], 
-        n_outs = 10,
-        corruption_levels = [0.1, 0.1]
+        theano_rng=None, 
+        n_ins=784,
+        hidden_layers_sizes=[500, 500], 
+        n_outs=10,
+        corruption_levels=[0.1, 0.1]
     ):
         """ This class is made to support a variable number of layers.
 
@@ -246,9 +246,9 @@ def build_finetune_functions(self, datasets, batch_size, learning_rate):
         (test_set_x, test_set_y) = datasets[2]
 
         # compute number of minibatches for training, validation and testing
-        n_valid_batches = valid_set_x.get_value(borrow = True).shape[0]
+        n_valid_batches = valid_set_x.get_value(borrow=True).shape[0]
         n_valid_batches /= batch_size
-        n_test_batches = test_set_x.get_value(borrow = True).shape[0]
+        n_test_batches = test_set_x.get_value(borrow=True).shape[0]
         n_test_batches /= batch_size
 
         index = T.lscalar('index')  # index to a [mini]batch
@@ -263,30 +263,30 @@ def build_finetune_functions(self, datasets, batch_size, learning_rate):
         ]
 
         train_fn = theano.function(
-            inputs = [index],
-            outputs = self.finetune_cost,
-            updates = updates,
-            givens = {
+            inputs=[index],
+            outputs=self.finetune_cost,
+            updates=updates,
+            givens={
                 self.x: train_set_x[index * batch_size : (index + 1) * batch_size],
                 self.y: train_set_y[index * batch_size : (index + 1) * batch_size]
             },
-            name = 'train'
+            name='train'
         )
 
         test_score_i = theano.function(
             [index], 
             self.errors,
-            givens = {
+            givens={
                self.x: test_set_x[index * batch_size : (index + 1) * batch_size],
                self.y: test_set_y[index * batch_size : (index + 1) * batch_size]
             },
-            name = 'test'
+            name='test'
         )
 
         valid_score_i = theano.function(
             [index], 
             self.errors,
-            givens = {
+            givens={
                 self.x: valid_set_x[index * batch_size : (index + 1) * batch_size],
                 self.y: valid_set_y[index * batch_size : (index + 1) * batch_size]
             },
@@ -345,10 +345,10 @@ def test_SdA(finetune_lr=0.1, pretraining_epochs=15,
     print '... building the model'
     # construct the stacked denoising autoencoder class
     sda = SdA(
-        numpy_rng = numpy_rng, 
-        n_ins = 28 * 28,
-        hidden_layers_sizes = [1000, 1000, 1000],
-        n_outs = 10
+        numpy_rng=numpy_rng, 
+        n_ins=28 * 28,
+        hidden_layers_sizes=[1000, 1000, 1000],
+        n_outs=10
     )
 
     #########################

code/convolutional_mlp.py

@@ -78,10 +78,10 @@ def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):
         W_bound = numpy.sqrt(6. / (fan_in + fan_out))
         self.W = theano.shared(
             numpy.asarray(
-                rng.uniform(low = -W_bound, high = W_bound, size = filter_shape),
-                dtype = theano.config.floatX
+                rng.uniform(low=-W_bound, high=W_bound, size=filter_shape),
+                dtype=theano.config.floatX
             ),
-            borrow = True
+            borrow=True
         )
 
         # the bias is a 1D tensor -- one bias per output feature map
@@ -90,17 +90,17 @@ def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):
 
         # convolve input feature maps with filters
         conv_out = conv.conv2d(
-            input = input, 
-            filters = self.W,
-            filter_shape = filter_shape, 
-            image_shape = image_shape
+            input=input, 
+            filters=self.W,
+            filter_shape=filter_shape, 
+            image_shape=image_shape
         )
 
         # downsample each feature map individually, using maxpooling
         pooled_out = downsample.max_pool_2d(
-            input = conv_out,
-            ds = poolsize, 
-            ignore_border = True
+            input=conv_out,
+            ds=poolsize, 
+            ignore_border=True
         )
 
         # add the bias term. Since the bias is a vector (1D array), we first
@@ -141,9 +141,9 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     test_set_x, test_set_y = datasets[2]
 
     # compute number of minibatches for training, validation and testing
-    n_train_batches = train_set_x.get_value(borrow = True).shape[0]
-    n_valid_batches = valid_set_x.get_value(borrow = True).shape[0]
-    n_test_batches = test_set_x.get_value(borrow = True).shape[0]
+    n_train_batches = train_set_x.get_value(borrow=True).shape[0]
+    n_valid_batches = valid_set_x.get_value(borrow=True).shape[0]
+    n_test_batches = test_set_x.get_value(borrow=True).shape[0]
     n_train_batches /= batch_size
     n_valid_batches /= batch_size
     n_test_batches /= batch_size
@@ -171,10 +171,10 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     # 4D output tensor is thus of shape (batch_size,nkerns[0],12,12)
     layer0 = LeNetConvPoolLayer(
         rng, 
-        input = layer0_input,
-        image_shape = (batch_size, 1, 28, 28),
-        filter_shape = (nkerns[0], 1, 5, 5),
-        poolsize = (2, 2)
+        input=layer0_input,
+        image_shape=(batch_size, 1, 28, 28),
+        filter_shape=(nkerns[0], 1, 5, 5),
+        poolsize=(2, 2)
     )
 
     # Construct the second convolutional pooling layer
@@ -183,10 +183,10 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     # 4D output tensor is thus of shape (nkerns[0],nkerns[1],4,4)
     layer1 = LeNetConvPoolLayer(
         rng, 
-        input = layer0.output,
-        image_shape = (batch_size, nkerns[0], 12, 12),
-        filter_shape = (nkerns[1], nkerns[0], 5, 5), 
-        poolsize = (2, 2)
+        input=layer0.output,
+        image_shape=(batch_size, nkerns[0], 12, 12),
+        filter_shape=(nkerns[1], nkerns[0], 5, 5), 
+        poolsize=(2, 2)
     )
 
     # the HiddenLayer being fully-connected, it operates on 2D matrices of
@@ -197,14 +197,14 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     # construct a fully-connected sigmoidal layer
     layer2 = HiddenLayer(
         rng, 
-        input = layer2_input, 
-        n_in = nkerns[1] * 4 * 4,
-        n_out = 500, 
-        activation = T.tanh
+        input=layer2_input, 
+        n_in=nkerns[1] * 4 * 4,
+        n_out=500, 
+        activation=T.tanh
     )
 
     # classify the values of the fully-connected sigmoidal layer
-    layer3 = LogisticRegression(input = layer2.output, n_in = 500, n_out = 10)
+    layer3 = LogisticRegression(input=layer2.output, n_in=500, n_out=10)
 
     # the cost we minimize during training is the NLL of the model
     cost = layer3.negative_log_likelihood(y)
@@ -213,7 +213,7 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     test_model = theano.function(
         [index], 
         layer3.errors(y),
-        givens = {
+        givens={
             x: test_set_x[index * batch_size : (index + 1) * batch_size],
             y: test_set_y[index * batch_size : (index + 1) * batch_size]
         }
@@ -222,7 +222,7 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     validate_model = theano.function(
         [index], 
         layer3.errors(y),
-        givens = {
+        givens={
             x: valid_set_x[index * batch_size : (index + 1) * batch_size],
             y: valid_set_y[index * batch_size : (index + 1) * batch_size]
         }
@@ -247,8 +247,8 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     train_model = theano.function(
         [index], 
         cost, 
-        updates = updates,
-        givens = {
+        updates=updates,
+        givens={
             x: train_set_x[index * batch_size : (index + 1) * batch_size],
             y: train_set_y[index * batch_size : (index + 1) * batch_size]
         }

code/dA.py

@@ -78,13 +78,13 @@ class dA(object):
     def __init__(
         self, 
         numpy_rng, 
-        theano_rng = None, 
-        input = None,
-        n_visible = 784, 
-        n_hidden = 500,
-        W = None, 
-        bhid = None, 
-        bvis = None
+        theano_rng=None, 
+        input=None,
+        n_visible=784, 
+        n_hidden=500,
+        W=None, 
+        bhid=None, 
+        bvis=None
     ):
         """
         Initialize the dA class by specifying the number of visible units (the
@@ -287,11 +287,11 @@ def test_dA(learning_rate=0.1, training_epochs=15,
     theano_rng = RandomStreams(rng.randint(2 ** 30))
 
     da = dA(
-        numpy_rng = rng, 
-        theano_rng = theano_rng, 
-        input = x,
-        n_visible = 28 * 28, 
-        n_hidden = 500
+        numpy_rng=rng, 
+        theano_rng=theano_rng, 
+        input=x,
+        n_visible=28 * 28, 
+        n_hidden=500
     )
 
     cost, updates = da.get_cost_updates(
@@ -302,8 +302,8 @@ def test_dA(learning_rate=0.1, training_epochs=15,
     train_da = theano.function(
         [index], 
         cost, 
-        updates = updates,
-        givens = {
+        updates=updates,
+        givens={
             x: train_set_x[index * batch_size : (index + 1) * batch_size]
         }
     )
@@ -344,15 +344,15 @@ def test_dA(learning_rate=0.1, training_epochs=15,
     theano_rng = RandomStreams(rng.randint(2 ** 30))
 
     da = dA(
-        numpy_rng = rng, 
-        theano_rng = theano_rng, 
-        input = x,
-        n_visible = 28 * 28, 
-        n_hidden = 500
+        numpy_rng=rng, 
+        theano_rng=theano_rng, 
+        input=x,
+        n_visible=28 * 28, 
+        n_hidden=500
     )
 
     cost, updates = da.get_cost_updates(
-        corruption_level = 0.3,
+        corruption_level=0.3,
         learning_rate=learning_rate
     )
 

code/logistic_sgd.py

@@ -75,21 +75,21 @@ def __init__(self, input, n_in, n_out):
 
         # initialize with 0 the weights W as a matrix of shape (n_in, n_out)
         self.W = theano.shared(
-            value = numpy.zeros(
+            value=numpy.zeros(
                 (n_in, n_out),
-                dtype = theano.config.floatX
+                dtype=theano.config.floatX
             ),
-            name = 'W', 
-            borrow = True
+            name='W', 
+            borrow=True
         )
         # initialize the baises b as a vector of n_out 0s
         self.b = theano.shared(
-            value = numpy.zeros(
+            value=numpy.zeros(
                 (n_out,),
-                dtype = theano.config.floatX
+                dtype=theano.config.floatX
             ),
-            name = 'b', 
-            borrow = True
+            name='b', 
+            borrow=True
         )
 
         # symbolic expression for computing the matrix of class-membership probabilities
@@ -101,7 +101,7 @@ def __init__(self, input, n_in, n_out):
 
         # symbolic description of how to compute prediction as class whose probability
         # is maximal
-        self.y_pred = T.argmax(self.p_y_given_x, axis = 1)
+        self.y_pred = T.argmax(self.p_y_given_x, axis=1)
 
         # parameters of the model
         self.params = [self.W, self.b]
@@ -277,7 +277,7 @@ def sgd_optimization_mnist(learning_rate=0.13, n_epochs=1000,
 
     # construct the logistic regression class
     # Each MNIST image has size 28*28
-    classifier = LogisticRegression(input = x, n_in = 28 * 28, n_out = 10)
+    classifier = LogisticRegression(input=x, n_in=28 * 28, n_out=10)
 
     # the cost we minimize during training is the negative log likelihood of
     # the model in symbolic format
@@ -286,26 +286,26 @@ def sgd_optimization_mnist(learning_rate=0.13, n_epochs=1000,
     # compiling a Theano function that computes the mistakes that are made by
     # the model on a minibatch
     test_model = theano.function(
-        inputs = [index],
-        outputs = classifier.errors(y),
-        givens = {
+        inputs=[index],
+        outputs=classifier.errors(y),
+        givens={
             x: test_set_x[index * batch_size : (index + 1) * batch_size],
             y: test_set_y[index * batch_size : (index + 1) * batch_size]
         }
     )
 
     validate_model = theano.function(
-        inputs = [index],
-        outputs = classifier.errors(y),
-        givens = {
+        inputs=[index],
+        outputs=classifier.errors(y),
+        givens={
             x: valid_set_x[index * batch_size : (index + 1) * batch_size],
             y: valid_set_y[index * batch_size : (index + 1) * batch_size]
         }
     )
 
     # compute the gradient of cost with respect to theta = (W,b)
-    g_W = T.grad(cost = cost, wrt = classifier.W)
-    g_b = T.grad(cost = cost, wrt = classifier.b)
+    g_W = T.grad(cost=cost, wrt=classifier.W)
+    g_b = T.grad(cost=cost, wrt=classifier.b)
 
     # specify how to update the parameters of the model as a list of
     # (variable, update expression) pairs.
@@ -316,10 +316,10 @@ def sgd_optimization_mnist(learning_rate=0.13, n_epochs=1000,
     # the same time updates the parameter of the model based on the rules
     # defined in `updates`
     train_model = theano.function(
-        inputs = [index],
-        outputs = cost,
-        updates = updates,
-        givens = {
+        inputs=[index],
+        outputs=cost,
+        updates=updates,
+        givens={
             x: train_set_x[index * batch_size : (index + 1) * batch_size],
             y: train_set_y[index * batch_size : (index + 1) * batch_size]
         }