pep8

theano/tensor/signal/downsample.py

@@ -26,11 +26,13 @@ def max_pool_2d(input, ds, ignore_border=False):
     patches of size (ds[0],ds[1])
 
     :type input: N-D theano tensor of input images.
-    :param input: input images. Max pooling will be done over the 2 last dimensions.
+    :param input: input images. Max pooling will be done over the 2 last
+        dimensions.
     :type ds: tuple of length 2
-    :param ds: factor by which to downscale. (2,2) will halve the image in each dimension.
-    :param ignore_border: boolean value. When True, (5,5) input with ds=(2,2) will generate a
-      (2,2) output. (3,3) otherwise.
+    :param ds: factor by which to downscale. (2,2) will halve the image in
+        each dimension.
+    :param ignore_border: boolean value. When True, (5,5) input with ds=(2,2)
+        will generate a (2,2) output. (3,3) otherwise.
     """
     if input.ndim < 2:
         raise NotImplementedError('max_pool_2d requires a dimension >= 2')
@@ -44,7 +46,7 @@ def max_pool_2d(input, ds, ignore_border=False):
 
     # store as 4D tensor with shape: (batch_size,1,height,width)
     new_shape = tensor.cast(tensor.join(0, batch_size,
-                                        tensor.as_tensor([1,]),
+                                        tensor.as_tensor([1]),
                                         img_shape), 'int64')
     input_4D = tensor.reshape(input, new_shape, ndim=4)
 
@@ -67,27 +69,29 @@ class DownsampleFactorMax(Op):
 
     @staticmethod
     def out_shape(imgshape, ds, ignore_border=False):
-        """Return the shape of the output from this op, for input of given shape and flags.
+        """Return the shape of the output from this op, for input of given
+        shape and flags.
 
-        :param imgshape: the shape of a tensor of images. The last two elements are interpreted
-        as the number of rows, and the number of cols.
+        :param imgshape: the shape of a tensor of images. The last two elements
+            are interpreted as the number of rows, and the number of cols.
         :type imgshape: tuple, list, or similar of integer or
             scalar Theano variable.
 
         :param ds: downsample factor over rows and columns
         :type ds: list or tuple of two ints
 
-        :param ignore_border: if ds doesn't divide imgshape, do we include an extra row/col of
-        partial downsampling (False) or ignore it (True).
+        :param ignore_border: if ds doesn't divide imgshape, do we include an
+            extra row/col of partial downsampling (False) or ignore it (True).
         :type ignore_border: bool
 
         :rtype: list
-        :returns: the shape of the output from this op, for input of given shape.  This will
-        have the same length as imgshape, but with last two elements reduced as per the
-        downsampling & ignore_border flags.
+        :returns: the shape of the output from this op, for input of given
+            shape.  This will have the same length as imgshape, but with last
+            two elements reduced as per the downsampling & ignore_border flags.
         """
         if len(imgshape) < 2:
-            raise TypeError('imgshape must have at least two elements (rows, cols)')
+            raise TypeError('imgshape must have at least two elements '
+                            '(rows, cols)')
         r, c = imgshape[-2:]
         rval = list(imgshape[:-2]) + [r // ds[0], c // ds[1]]
 
@@ -107,8 +111,9 @@ class DownsampleFactorMax(Op):
         :param ds: downsample factor over rows and columns
         :type ds: list or tuple of two ints
 
-        :param ignore_border: if ds doesn't divide imgshape, do we include an extra row/col of
-        partial downsampling (False) or ignore it (True).
+        :param ignore_border: if ds doesn't divide imgshape, do we include
+            an extra row/col of partial downsampling (False) or
+            ignore it (True).
         :type ignore_border: bool
 
         TODO: why is poolsize an op parameter here?
@@ -302,9 +307,10 @@ class DownsampleFactorMaxGrad(Op):
                     zi = i // ds0
                     for j in xrange(shape3):
                         zj = j // ds1
-                        if (maxout[n,k,zi,zj] == x[n,k,i,j]):
-                            gx[n,k,i,j] = gz[n,k,zi,zj]
-                        else: gx[n,k,i,j] = 0
+                        if (maxout[n, k, zi, zj] == x[n, k, i, j]):
+                            gx[n, k, i, j] = gz[n, k, zi, zj]
+                        else:
+                            gx[n, k, i, j] = 0
         gx_stg[0] = gx
 
     def infer_shape(self, node, in_shapes):
@@ -313,7 +319,10 @@ class DownsampleFactorMaxGrad(Op):
     def grad(self, inp, grads):
         x, maxout, gz = inp
         ggx, = grads
-        return [theano.tensor.zeros_like(x),theano.tensor.zeros_like(maxout),DownsampleFactorMaxGradGrad(self.ds, ignore_border=self.ignore_border)(x, maxout, ggx)]
+        return [theano.tensor.zeros_like(x),
+                theano.tensor.zeros_like(maxout),
+                DownsampleFactorMaxGradGrad(
+                    self.ds, ignore_border=self.ignore_border)(x, maxout, ggx)]
 
     def c_code(self, node, name, inp, out, sub):
         x, z, gz = inp
@@ -405,38 +414,42 @@ class DownsampleFactorMaxGrad(Op):
             }
           }//for k
         }//for b
-        """ %locals()
+        """ % locals()
 
     def c_code_cache_version(self):
-        return (0,1)
+        return (0, 1)
+
 
 class DownsampleFactorMaxGradGrad(Op):
 
     @staticmethod
     def out_shape(imgshape, ds, ignore_border=False):
-	    """Return the shape of the output from this op, for input of given shape and flags.
+        """Return the shape of the output from this op, for input of given
+        shape and flags.
 
-	    :param imgshape: the shape of a tensor of images. The last two elements are interpreted
-	    as the number of rows, and the number of cols.
+        :param imgshape: the shape of a tensor of images. The last two elements
+            are interpreted as the number of rows, and the number of cols.
         :type imgshape: tuple, list, or similar of integer or
             scalar Theano variable.
 
         :param ds: downsample factor over rows and columns
         :type ds: list or tuple of two ints
 
-	    :param ignore_border: if ds doesn't divide imgshape, do we include an extra row/col of
-	    partial downsampling (False) or ignore it (True).
+        :param ignore_border: if ds doesn't divide imgshape, do we include
+            an extra row/col of partial downsampling (False) or ignore
+            it (True).
         :type ignore_border: bool
 
         :rtype: list
-	    :returns: the shape of the output from this op, for input of given shape.  This will
-	    have the same length as imgshape, but with last two elements reduced as per the
-	    downsampling & ignore_border flags.
+        :returns: the shape of the output from this op, for input of given
+            shape.  This will have the same length as imgshape, but with last
+            two elements reduced as per the downsampling & ignore_border flags.
         """
         if len(imgshape) < 2:
-	        raise TypeError('imgshape must have at least two elements (rows, cols)')
+            raise TypeError('imgshape must have at least two elements '
+                            '(rows, cols)')
         r, c = imgshape[-2:]
-	    rval = list(imgshape[:-2]) + [ r // ds[0], c // ds[1] ]
+        rval = list(imgshape[:-2]) + [r // ds[0], c // ds[1]]
 
         if not ignore_border:
             if isinstance(r, theano.Variable):
@@ -454,20 +467,23 @@ class DownsampleFactorMaxGradGrad(Op):
         self.ignore_border = ignore_border
 
     def __eq__(self, other):
-		return type(self) == type(other) and self.ds == other.ds and self.ignore_border == other.ignore_border
+        return (type(self) == type(other)
+                and self.ds == other.ds
+                and self.ignore_border == other.ignore_border)
 
     def __hash__(self):
         return hash(type(self)) ^ hash(self.ds) ^ hash(self.ignore_border)
 
     def __str__(self):
-		return '%s{%s,%s}' % (self.__class__.__name__, self.ds, self.ignore_border)
+        return '%s{%s,%s}' % (self.__class__.__name__, self.ds,
+                              self.ignore_border)
 
     def make_node(self, x, maxout, gz):
-		# make_node should only be called by the grad function of DownsampleFactorMax,
-		# so these asserts should not fail.
-		assert isinstance(x, Variable) and x.ndim==4
-		assert isinstance(maxout, Variable) and maxout.ndim==4
-		assert isinstance(gz, Variable) and gz.ndim==4
+        # make_node should only be called by the grad function of
+        # DownsampleFactorMaxGrad, so these asserts should not fail.
+        assert isinstance(x, Variable) and x.ndim == 4
+        assert isinstance(maxout, Variable) and maxout.ndim == 4
+        assert isinstance(gz, Variable) and gz.ndim == 4
 
         return Apply(self, [x, maxout, gz], [x.type()])
 
@@ -476,21 +492,25 @@ class DownsampleFactorMaxGradGrad(Op):
         x, maxout, ggx = inp
         z, = out
 
-		if len(x.shape)!=4:
-		    raise NotImplementedError('DownsampleFactorMax requires 4D input for now')
+        if len(x.shape) != 4:
+            raise NotImplementedError(
+                'DownsampleFactorMaxGradGrad requires 4D input for now')
         z_shape = self.out_shape(x.shape, self.ds, self.ignore_border)
         if (z[0] is None) or (z[0].shape != z_shape):
-		    z[0] = numpy.zeros(self.out_shape(x.shape, self.ds, self.ignore_border))
+            z[0] = numpy.zeros(
+                self.out_shape(x.shape, self.ds, self.ignore_border))
             z[0] = theano._asarray(z[0], dtype=x.dtype)
-		ggz=z[0]
+        ggz = z[0]
 
         ds0, ds1 = self.ds
         if self.ignore_border:
             x_usable2 = (x.shape[2] // ds0 * ds0)
-		else: x_usable2 = x.shape[2]
+        else:
+            x_usable2 = x.shape[2]
         if self.ignore_border:
             x_usable3 = (x.shape[3] // ds1 * ds1)
-		else: x_usable3 = x.shape[3]
+        else:
+            x_usable3 = x.shape[3]
 
         for n in xrange(x.shape[0]):
             for k in xrange(x.shape[1]):
@@ -498,9 +518,8 @@ class DownsampleFactorMaxGradGrad(Op):
                     zi = i // ds0
                     for j in xrange(x_usable3):
                         zj = j // ds1
-		                if (maxout[n,k,zi,zj] == x[n,k,i,j]):
-		                    ggz[n,k,zi,zj] = ggx[n,k,i,j]
+                        if (maxout[n, k, zi, zj] == x[n, k, i, j]):
+                            ggz[n, k, zi, zj] = ggx[n, k, i, j]
 
     def infer_shape(self, node, in_shapes):
         return [in_shapes[0]]
-