PEP8 fixes

Author: lamblin

pylearn2/models/mlp.py

@@ -2673,7 +2673,7 @@ def get_monitoring_channels_from_state(self, state, target,
         rval = self._get_monitoring_channels_for_activations(state)
 
         return rval
-    
+
     def cost(self, Y, Y_hat):
         """
         Parameters
@@ -2682,7 +2682,7 @@ def cost(self, Y, Y_hat):
             Output of `fprop`
         Y_hat : theano.gof.Variable
             Targets
-        batch_axis : integer 
+        batch_axis : integer
             axis representing batch dimension
 
         Returns
@@ -2694,8 +2694,6 @@ def cost(self, Y, Y_hat):
             str(type(self)) + " does not implement cost function.")
 
 
-
-
 class IdentityConvNonlinearity(ConvNonlinearity):
 
     """
@@ -2722,16 +2720,15 @@ def get_monitoring_channels_from_state(self,
             rval["misclass"] = T.cast(incorrect, config.floatX).mean()
 
         return rval
-    
+
     @wraps(ConvNonlinearity.cost)
     def cost(self, Y, Y_hat, batch_axis):
         """
         Notes
         -----
-        Mean squared error across batches 
+        Mean squared error across batches
         """
-        return T.sum(T.mean(T.sqr(Y-Y_hat), axis = batch_axis))
-
+        return T.sum(T.mean(T.sqr(Y-Y_hat), axis=batch_axis))
 
 
 class RectifierConvNonlinearity(ConvNonlinearity):
@@ -2849,7 +2846,7 @@ def get_monitoring_channels_from_state(self, state, target,
             rval['per_output_f1_min'] = f1.min()
 
         return rval
-        
+
     @wraps(ConvNonlinearity.cost)
     def cost(self, Y, Y_hat, batch_axis):
         """
@@ -2886,8 +2883,6 @@ def cost(self, Y, Y_hat, batch_axis):
         raise NotImplementedError(
             str(type(self)) + " does not implement cost function.")
 
-         
-
 
 class ConvElemwise(Layer):
     """
@@ -3304,18 +3299,18 @@ def fprop(self, state_below):
             p = self.output_normalization(p)
 
         return p
-       
+
     @wraps(Layer.cost)
     def cost(self, Y, Y_hat):
         """
         Notes
         -----
         The cost method calls self.nonlin.cost
-        """              
-    
+        """
+
         batch_axis = self.output_space.get_batch_axis()
         return self.nonlin.cost(Y=Y, Y_hat=Y_hat, batch_axis=batch_axis)
-        
+
 
 class ConvRectifiedLinear(ConvElemwise):
 

pylearn2/models/tests/test_convelemwise_cost.py

@@ -1,21 +1,21 @@
 """
 Note: Cost functions are not implemented for RectifierConvNonlinearity,
-TanhConvNonlinearity, RectifiedLinear, and Tanh.  Here we verify that the 
+TanhConvNonlinearity, RectifiedLinear, and Tanh.  Here we verify that the
 implemented cost functions for convolutional layers give the correct output
 by comparing to standard MLP's.
 """
 
 import numpy as np
 import theano
-import theano.tensor as T
 from pylearn2.models.mlp import MLP
 from pylearn2.models.mlp import Sigmoid, Tanh, Linear, RectifiedLinear
 from pylearn2.models.mlp import ConvElemwise
 from pylearn2.space import Conv2DSpace
 from pylearn2.models.mlp import SigmoidConvNonlinearity
 from pylearn2.models.mlp import TanhConvNonlinearity
 from pylearn2.models.mlp import IdentityConvNonlinearity
-from pylearn2.models.mlp import  RectifierConvNonlinearity
+from pylearn2.models.mlp import RectifierConvNonlinearity
+
 
 def check_implemented_case(ConvNonlinearity, MLPNonlinearity):
 
@@ -30,43 +30,51 @@ def check_implemented_case(ConvNonlinearity, MLPNonlinearity):
     batch_size = 103
 
     x = np.random.rand(batch_size, r, s, 1)
-    y = np.random.randint(2, size = [batch_size, output_channels, 1 ,1])
+    y = np.random.randint(2, size=[batch_size, output_channels, 1, 1])
 
     x = x.astype('float32')
     y = y.astype('float32')
 
     x_mlp = x.flatten().reshape(batch_size, nvis)
     y_mlp = y.flatten().reshape(batch_size, output_channels)
 
-    # Initialize convnet with random weights.  
+    # Initialize convnet with random weights.
 
     conv_model = MLP(
-        input_space = Conv2DSpace(shape = shape, axes = ['b', 0, 1, 'c'], num_channels = 1),
-        layers = [ConvElemwise(layer_name='conv', nonlinearity = ConvNonlinearity, \
-                  output_channels = output_channels, kernel_shape = shape, \
-                  pool_shape = [1,1], pool_stride = shape, irange= 1.0)],
-        batch_size = batch_size
+        input_space=Conv2DSpace(shape=shape,
+                                axes=['b', 0, 1, 'c'],
+                                num_channels=1),
+        layers=[ConvElemwise(layer_name='conv',
+                             nonlinearity=ConvNonlinearity,
+                             output_channels=output_channels,
+                             kernel_shape=shape,
+                             pool_shape=[1, 1],
+                             pool_stride=shape,
+                             irange=1.0)],
+        batch_size=batch_size
     )
 
     X = conv_model.get_input_space().make_theano_batch()
     Y = conv_model.get_target_space().make_theano_batch()
     Y_hat = conv_model.fprop(X)
     g = theano.function([X], Y_hat)
 
-    # Construct an equivalent MLP which gives the same output after flattening both.
-
+    # Construct an equivalent MLP which gives the same output
+    # after flattening both.
     mlp_model = MLP(
-        layers = [MLPNonlinearity(dim = output_channels, layer_name = 'mlp', irange = 1.0)],
-        batch_size = batch_size,
-        nvis = nvis
+        layers=[MLPNonlinearity(dim=output_channels,
+                                layer_name='mlp',
+                                irange=1.0)],
+        batch_size=batch_size,
+        nvis=nvis
     )
 
     W, b = conv_model.get_param_values()
 
     W = W.astype('float32')
     b = b.astype('float32')
 
-    W_mlp = np.zeros(shape = (output_channels, nvis))
+    W_mlp = np.zeros(shape=(output_channels, nvis))
     for k in range(output_channels):
         W_mlp[k] = W[k, 0].flatten()[::-1]
     W_mlp = W_mlp.T
@@ -82,42 +90,47 @@ def check_implemented_case(ConvNonlinearity, MLPNonlinearity):
     Y1_hat = mlp_model.fprop(X1)
     f = theano.function([X1], Y1_hat)
 
-
     # Check that the two models give the same output
-    assert np.linalg.norm(f(x_mlp).flatten() -  g(x).flatten()) < 10**-3
+    assert np.linalg.norm(f(x_mlp).flatten() - g(x).flatten()) < 10**-3
 
     # Check that the two models have the same costs:
     mlp_cost = theano.function([X1, Y1], mlp_model.cost(Y1, Y1_hat))
     conv_cost = theano.function([X, Y], conv_model.cost(Y, Y_hat))
 
-    assert np.linalg.norm(conv_cost(x,y) - mlp_cost(x_mlp, y_mlp)) < 10**-3
+    assert np.linalg.norm(conv_cost(x, y) - mlp_cost(x_mlp, y_mlp)) < 10**-3
 
 
 def check_unimplemented_case(ConvNonlinearity):
 
     conv_model = MLP(
-        input_space = Conv2DSpace(shape = [1,1], axes = ['b', 0, 1, 'c'], num_channels = 1),
-        layers = [ConvElemwise(layer_name='conv', nonlinearity = ConvNonlinearity, \
-                  output_channels = 1, kernel_shape = [1,1], \
-                  pool_shape = [1,1], pool_stride = [1,1], irange= 1.0)],
-        batch_size = 1
-    )        
+        input_space=Conv2DSpace(shape=[1, 1],
+                                axes=['b', 0, 1, 'c'],
+                                num_channels=1),
+        layers=[ConvElemwise(layer_name='conv',
+                             nonlinearity=ConvNonlinearity,
+                             output_channels=1,
+                             kernel_shape=[1, 1],
+                             pool_shape=[1, 1],
+                             pool_stride=[1, 1],
+                             irange=1.0)],
+        batch_size=1
+    )
 
     X = conv_model.get_input_space().make_theano_batch()
     Y = conv_model.get_target_space().make_theano_batch()
     Y_hat = conv_model.fprop(X)
 
-    assert np.testing.assert_raises(NotImplementedError, conv_model.cost(Y, Y_hat))
-
+    assert np.testing.assert_raises(NotImplementedError,
+                                    conv_model.cost, Y, Y_hat)
 
 
 def test_all_costs():
 
-    ImplementedCases = [[SigmoidConvNonlinearity(), Sigmoid], \
+    ImplementedCases = [[SigmoidConvNonlinearity(), Sigmoid],
                         [IdentityConvNonlinearity(), Linear]]
 
-    UnimplementedCases = [[TanhConvNonlinearity(), Tanh], \
-                           [RectifierConvNonlinearity, RectifiedLinear]]
+    UnimplementedCases = [[TanhConvNonlinearity(), Tanh],
+                          [RectifierConvNonlinearity, RectifiedLinear]]
 
     for ConvNonlinearity, MLPNonlinearity in UnimplementedCases:
         check_unimplemented_case(ConvNonlinearity)