pep8

Author: nouiz

doc/DBN.txt

@@ -146,42 +146,42 @@ classification.
 
     class DBN(object):
 
-        def __init__(self, numpy_rng, theano_rng = None, n_ins = 784,
-                    hidden_layers_sizes=[500,500], n_outs = 10):
+        def __init__(self, numpy_rng, theano_rng=None, n_ins=784,
+                    hidden_layers_sizes=[500, 500], n_outs=10):
             """This class is made to support a variable number of layers. 
 
             :type numpy_rng: numpy.random.RandomState
-            :param numpy_rng: numpy random number generator used to draw initial 
+            :param numpy_rng: numpy random number generator used to draw initial
                     weights
 
             :type theano_rng: theano.tensor.shared_randomstreams.RandomStreams
-            :param theano_rng: Theano random generator; if None is given one is 
+            :param theano_rng: Theano random generator; if None is given one is
                            generated based on a seed drawn from `rng`
 
             :type n_ins: int
             :param n_ins: dimension of the input to the DBN
 
             :type n_layers_sizes: list of ints
-            :param n_layers_sizes: intermediate layers size, must contain 
+            :param n_layers_sizes: intermediate layers size, must contain
                                at least one value
 
             :type n_outs: int
             :param n_outs: dimension of the output of the network
             """
 
             self.sigmoid_layers = []
-            self.rbm_layers     = []
-            self.params         = []
-            self.n_layers       = len(hidden_layers_sizes)
+            self.rbm_layers = []
+            self.params = []
+            self.n_layers = len(hidden_layers_sizes)
 
             assert self.n_layers > 0
 
             if not theano_rng:
-                theano_rng = RandomStreams(numpy_rng.randint(2**30))
+                theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
 
             # allocate symbolic variables for the data
-            self.x  = T.matrix('x')  # the data is presented as rasterized images
-            self.y  = T.ivector('y') # the labels are presented as 1D vector of 
+            self.x = T.matrix('x')  # the data is presented as rasterized images
+            self.y = T.ivector('y')  # the labels are presented as 1D vector of
                                      # [int] labels
 
 ``self.sigmoid_layers`` will store the feed-forward graphs which together form
@@ -199,28 +199,28 @@ hidden bias with its corresponding sigmoid layer.
 
 .. code-block:: python
 
-        for i in xrange( self.n_layers ):
+        for i in xrange(self.n_layers):
             # construct the sigmoidal layer
 
-            # the size of the input is either the number of hidden units of the layer below or
-            # the input size if we are on the first layer
-            if i == 0 :
+            # the size of the input is either the number of hidden units of the
+            # layer below or the input size if we are on the first layer
+            if i == 0:
                 input_size = n_ins
             else:
-                input_size = hidden_layers_sizes[i-1]
+                input_size = hidden_layers_sizes[i - 1]
 
-            # the input to this layer is either the activation of the hidden layer below or the
-            # input of the DBN if you are on the first layer
-            if i == 0 : 
+            # the input to this layer is either the activation of the hidden
+            # layer below or the input of the DBN if you are on the first layer
+            if i == 0:
                 layer_input = self.x
             else:
                 layer_input = self.sigmoid_layers[-1].output
 
-            sigmoid_layer = HiddenLayer(rng   = numpy_rng, 
-                                        input = layer_input, 
-                                        n_in  = input_size, 
-                                        n_out = hidden_layers_sizes[i],
-                                        activation = T.nnet.sigmoid)
+            sigmoid_layer = HiddenLayer(rng=numpy_rng,
+                                        input=layer_input,
+                                        n_in=input_size,
+                                        n_out=hidden_layers_sizes[i],
+                                        activation=T.nnet.sigmoid)
 
             # add the layer to our list of layers 
             self.sigmoid_layers.append(sigmoid_layer)
@@ -231,13 +231,14 @@ hidden bias with its corresponding sigmoid layer.
             self.params.extend(sigmoid_layer.params)
 
             # Construct an RBM that shared weights with this layer
-            rbm_layer = RBM(numpy_rng = numpy_rng, theano_rng = theano_rng, 
-                            input = layer_input, 
-                            n_visible = input_size, 
-                            n_hidden  = hidden_layers_sizes[i],  
-                            W = sigmoid_layer.W, 
-                            hbias = sigmoid_layer.b)
-            self.rbm_layers.append(rbm_layer)        
+            rbm_layer = RBM(numpy_rng=numpy_rng,
+                            theano_rng=theano_rng,
+                            input=layer_input, 
+                            n_visible=input_size, 
+                            n_hidden=hidden_layers_sizes[i],  
+                            W=sigmoid_layer.W, 
+                            hbias=sigmoid_layer.b)
+            self.rbm_layers.append(rbm_layer)
 
 
 All that is left is to stack one last logistic regression layer in order to
@@ -247,14 +248,14 @@ form an MLP. We will use the ``LogisticRegression`` class introduced in
 .. code-block:: python
 
         # We now need to add a logistic layer on top of the MLP
-        self.logLayer = LogisticRegression(\
-                         input = self.sigmoid_layers[-1].output,\
-                         n_in = hidden_layers_sizes[-1], n_out = n_outs)
+        self.logLayer = LogisticRegression(
+                         input=self.sigmoid_layers[-1].output,
+                         n_in=hidden_layers_sizes[-1], n_out=n_outs)
         self.params.extend(self.logLayer.params)
 
-        # construct a function that implements one step of fine-tuning compute the cost for
-        # second phase of training, defined as the negative log likelihood 
-        # of the logistic regression (output) layer
+        # construct a function that implements one step of fine-tuning compute
+        # the cost for second phase of training, defined as the negative log
+        # likelihood of the logistic regression (output) layer
         self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)
 
         # compute the gradients with respect to the model parameters
@@ -284,21 +285,21 @@ function which implements one step of training for the ``RBM`` at layer
         '''
 
         # index to a [mini]batch
-        index            = T.lscalar('index')   # index to a minibatch
+        index = T.lscalar('index')  # index to a minibatch
 
 In order to be able to change the learning rate during training, we associate a
 Theano variable to it that has a default value.
 
 .. code-block:: python
 
-        learning_rate    = T.scalar('lr')    # learning rate 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`
-        batch_end = batch_begin+batch_size
+        batch_end = batch_begin + batch_size
 
         pretrain_fns = []
         for rbm in self.rbm_layers:
@@ -311,13 +312,14 @@ Theano variable to it that has a default value.
             # compile the Theano function; check if k is also a Theano
             # variable, if so added to the inputs of the function
             if isinstance(k, theano.Variable):
-                inputs = [ index, theano.Param(learning_rate, default=0.1),k]
+                inputs = [index, theano.Param(learning_rate, default=0.1), k]
             else:
-                inputs = [ index, theano.Param(learning_rate, default=0.1)]
-            fn = theano.function(inputs = inputs,
-                    outputs = cost, 
-                    updates = updates,
-                    givens  = {self.x :train_set_x[batch_begin:batch_end]})
+                inputs =  index, theano.Param(learning_rate, default=0.1)]
+            fn = theano.function(inputs=inputs,
+                                 outputs=cost, 
+                                  updates=updates,
+                                  givens={self.x: train_set_x[batch_begin:
+                                                              batch_end]})
             # append `fn` to the list of functions
             pretrain_fns.append(fn)
 
@@ -355,7 +357,7 @@ and a ``test_model`` function).
 
         (train_set_x, train_set_y) = datasets[0]
         (valid_set_x, valid_set_y) = datasets[1]
-        (test_set_x , test_set_y ) = datasets[2]
+        (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] / batch_size
@@ -371,22 +373,22 @@ and a ``test_model`` function).
         for param, gparam in zip(self.params, gparams):
             updates[param] = param - gparam*learning_rate
 
-        train_fn = theano.function(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]})
+        train_fn = theano.function(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]})
 
         test_score_i = theano.function([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]})
+                 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]})
 
         valid_score_i = theano.function([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]})
+              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]})
 
         # Create a function that scans the entire validation set
         def valid_score():
@@ -415,9 +417,9 @@ The few lines of code below constructs the deep belief network :
     numpy_rng = numpy.random.RandomState(123)
     print '... building the model'
     # construct the Deep Belief Network
-    dbn = DBN(numpy_rng = numpy_rng, n_ins = 28*28, 
-              hidden_layers_sizes = [1000,1000,1000],
-              n_outs = 10)
+    dbn = DBN(numpy_rng=numpy_rng, n_ins=28 * 28, 
+              hidden_layers_sizes=[1000, 1000, 1000],
+              n_outs=10)
 
 
 
@@ -440,21 +442,21 @@ given by ``pretraining_epochs``.
     print '... getting the pretraining functions'
     # We are using CD-1 here
     pretraining_fns = dbn.pretraining_functions(
-            train_set_x   = train_set_x, 
-            batch_size    = batch_size,
-            k             = k) 
+            train_set_x=train_set_x, 
+            batch_size=batch_size,
+            k=k) 
 
     print '... pre-training the model'
     start_time = time.clock()  
-    ## Pre-train layer-wise 
+    ## Pre-train layer-wise
     for i in xrange(dbn.n_layers):
-        # go through pretraining epochs 
+        # go through pretraining epochs
         for epoch in xrange(pretraining_epochs):
             # go through the training set
             c = []
             for batch_index in xrange(n_train_batches):
-                c.append(pretraining_fns[i](index = batch_index, 
-                         lr = pretrain_lr ) )
+                c.append(pretraining_fns[i](index=batch_index, 
+                                            lr=pretrain_lr))
             print 'Pre-training layer %i, epoch %d, cost '%(i,epoch),numpy.mean(c)
 
     end_time = time.clock()