Minimized lines > 79 characters, trailing whitespace, and whitespace before :

Author: mspandit

code/SdA.py

@@ -58,11 +58,11 @@ class SdA(object):
     """
 
     def __init__(
-        self, 
-        numpy_rng, 
-        theano_rng=None, 
+        self,
+        numpy_rng,
+        theano_rng=None,
         n_ins=784,
-        hidden_layers_sizes=[500, 500], 
+        hidden_layers_sizes=[500, 500],
         n_outs=10,
         corruption_levels=[0.1, 0.1]
     ):
@@ -268,28 +268,40 @@ def build_finetune_functions(self, datasets, batch_size, learning_rate):
             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]
+                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'
         )
 
         test_score_i = theano.function(
-            [index], 
+            [index],
             self.errors,
             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]
+               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'
         )
 
         valid_score_i = theano.function(
-            [index], 
+            [index],
             self.errors,
             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]
+                self.x: valid_set_x[
+                    index * batch_size: (index + 1) * batch_size
+                ],
+                self.y: valid_set_y[
+                    index * batch_size: (index + 1) * batch_size
+                ]
             },
             name='valid'
         )
@@ -346,7 +358,7 @@ 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, 
+        numpy_rng=numpy_rng,
         n_ins=28 * 28,
         hidden_layers_sizes=[1000, 1000, 1000],
         n_outs=10

code/cA.py

@@ -12,7 +12,7 @@
  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

code/convolutional_mlp.py

@@ -90,16 +90,16 @@ def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):
 
         # convolve input feature maps with filters
         conv_out = conv.conv2d(
-            input=input, 
+            input=input,
             filters=self.W,
-            filter_shape=filter_shape, 
+            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, 
+            ds=poolsize,
             ignore_border=True
         )
 
@@ -170,7 +170,7 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     # 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, 
+        rng,
         input=layer0_input,
         image_shape=(batch_size, 1, 28, 28),
         filter_shape=(nkerns[0], 1, 5, 5),
@@ -182,10 +182,10 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     # 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, 
+        rng,
         input=layer0.output,
         image_shape=(batch_size, nkerns[0], 12, 12),
-        filter_shape=(nkerns[1], nkerns[0], 5, 5), 
+        filter_shape=(nkerns[1], nkerns[0], 5, 5),
         poolsize=(2, 2)
     )
 
@@ -196,10 +196,10 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
 
     # construct a fully-connected sigmoidal layer
     layer2 = HiddenLayer(
-        rng, 
-        input=layer2_input, 
+        rng,
+        input=layer2_input,
         n_in=nkerns[1] * 4 * 4,
-        n_out=500, 
+        n_out=500,
         activation=T.tanh
     )
 
@@ -211,20 +211,20 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
 
     # create a function to compute the mistakes that are made by the model
     test_model = theano.function(
-        [index], 
+        [index],
         layer3.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]
+            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(
-        [index], 
+        [index],
         layer3.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]
+            x: valid_set_x[index * batch_size: (index + 1) * batch_size],
+            y: valid_set_y[index * batch_size: (index + 1) * batch_size]
         }
     )
 
@@ -245,12 +245,12 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     ]
 
     train_model = theano.function(
-        [index], 
-        cost, 
+        [index],
+        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]
+            x: train_set_x[index * batch_size: (index + 1) * batch_size],
+            y: train_set_y[index * batch_size: (index + 1) * batch_size]
         }
     )
 
@@ -312,10 +312,13 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
                     best_iter = iter
 
                     # test it on the test set
-                    test_losses = [test_model(i) for i in xrange(n_test_batches)]
+                    test_losses = [
+                        test_model(i)
+                        for i in xrange(n_test_batches)
+                    ]
                     test_score = numpy.mean(test_losses)
-                    print(('     epoch %i, minibatch %i/%i, test error of best '
-                           'model %f %%') %
+                    print(('     epoch %i, minibatch %i/%i, test error of '
+                           'best model %f %%') %
                           (epoch, minibatch_index + 1, n_train_batches,
                            test_score * 100.))
 

code/dA.py

@@ -76,14 +76,14 @@ class dA(object):
     """
 
     def __init__(
-        self, 
-        numpy_rng, 
-        theano_rng=None, 
+        self,
+        numpy_rng,
+        theano_rng=None,
         input=None,
-        n_visible=784, 
+        n_visible=784,
         n_hidden=500,
-        W=None, 
-        bhid=None, 
+        W=None,
+        bhid=None,
         bvis=None
     ):
         """
@@ -287,10 +287,10 @@ 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, 
+        numpy_rng=rng,
+        theano_rng=theano_rng,
         input=x,
-        n_visible=28 * 28, 
+        n_visible=28 * 28,
         n_hidden=500
     )
 
@@ -300,11 +300,11 @@ def test_dA(learning_rate=0.1, training_epochs=15,
     )
 
     train_da = theano.function(
-        [index], 
-        cost, 
+        [index],
+        cost,
         updates=updates,
         givens={
-            x: train_set_x[index * batch_size : (index + 1) * batch_size]
+            x: train_set_x[index * batch_size: (index + 1) * batch_size]
         }
     )
 
@@ -344,10 +344,10 @@ 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, 
+        numpy_rng=rng,
+        theano_rng=theano_rng,
         input=x,
-        n_visible=28 * 28, 
+        n_visible=28 * 28,
         n_hidden=500
     )
 

code/logistic_sgd.py

@@ -79,7 +79,7 @@ def __init__(self, input, n_in, n_out):
                 (n_in, n_out),
                 dtype=theano.config.floatX
             ),
-            name='W', 
+            name='W',
             borrow=True
         )
         # initialize the baises b as a vector of n_out 0s
@@ -88,19 +88,22 @@ def __init__(self, input, n_in, n_out):
                 (n_out,),
                 dtype=theano.config.floatX
             ),
-            name='b', 
+            name='b',
             borrow=True
         )
 
-        # symbolic expression for computing the matrix of class-membership probabilities
+        # symbolic expression for computing the matrix of class-membership
+        # probabilities
         # Where:
-        # W is a matrix where column-k represent the separation hyper plain for class-k
+        # W is a matrix where column-k represent the separation hyper plain for
+        # class-k
         # x is a matrix where row-j  represents input training sample-j
-        # b is a vector where element-k represent the free parameter of hyper plain-k
+        # b is a vector where element-k represent the free parameter of hyper
+        # plain-k
         self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)
 
-        # symbolic description of how to compute prediction as class whose probability
-        # is maximal
+        # 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)
 
         # parameters of the model
@@ -173,13 +176,20 @@ def load_data(dataset):
     data_dir, data_file = os.path.split(dataset)
     if data_dir == "" and not os.path.isfile(dataset):
         # Check if dataset is in the data directory.
-        new_path = os.path.join(os.path.split(__file__)[0], "..", "data", dataset)
+        new_path = os.path.join(
+            os.path.split(__file__)[0],
+            "..",
+            "data",
+            dataset
+        )
         if os.path.isfile(new_path) or data_file == 'mnist.pkl.gz':
             dataset = new_path
 
     if (not os.path.isfile(dataset)) and data_file == 'mnist.pkl.gz':
         import urllib
-        origin = 'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz'
+        origin = (
+            'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz'
+        )
         print 'Downloading data from %s' % origin
         urllib.urlretrieve(origin, dataset)
 
@@ -289,17 +299,17 @@ def sgd_optimization_mnist(learning_rate=0.13, n_epochs=1000,
         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]
+            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={
-            x: valid_set_x[index * batch_size : (index + 1) * batch_size],
-            y: valid_set_y[index * batch_size : (index + 1) * batch_size]
+            x: valid_set_x[index * batch_size: (index + 1) * batch_size],
+            y: valid_set_y[index * batch_size: (index + 1) * batch_size]
         }
     )
 
@@ -320,8 +330,8 @@ def sgd_optimization_mnist(learning_rate=0.13, n_epochs=1000,
         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]
+            x: train_set_x[index * batch_size: (index + 1) * batch_size],
+            y: train_set_y[index * batch_size: (index + 1) * batch_size]
         }
     )