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.
+            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,102 +414,112 @@ 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.
-
-	    :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).
-	    :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.
-	    """
-	    if len(imgshape) < 2:
-	        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] ]
-
-	    if not ignore_border:
-	        if isinstance(r, theano.Variable):
-	            rval[-2] = tensor.switch(r % ds[0], rval[-2] + 1, rval[-2])
-	        elif r % ds[0]:
-	            rval[-2] += 1
-	        if isinstance(c, theano.Variable):
-	            rval[-1] = tensor.switch(c % ds[1], rval[-1] + 1, rval[-1])
-	        elif c % ds[1]:
-	            rval[-1] += 1
-	    return rval
-
-	def __init__(self, ds, ignore_border):
-		self.ds = tuple(ds)
-		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
-
-	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)
-
-	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
-
-		return Apply(self, [x, maxout, gz], [x.type()])
-
-	def perform(self, node, inp, out):
-
-		x, maxout, ggx = inp
-		z, = out
-		
-		if len(x.shape)!=4:
-		    raise NotImplementedError('DownsampleFactorMax 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] = theano._asarray(z[0], dtype=x.dtype)
-		ggz=z[0]
-
-		ds0, ds1 = self.ds
-		if self.ignore_border:
-		    x_usable2 = (x.shape[2] // ds0 * ds0)
-		else: x_usable2 = x.shape[2]
-		if self.ignore_border:
-		    x_usable3 = (x.shape[3] // ds1 * ds1)
-		else: x_usable3 = x.shape[3]
-		
-		for n in xrange(x.shape[0]):
-		    for k in xrange(x.shape[1]):
-		        for i in xrange(x_usable2):
-		            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]
-
-	def infer_shape(self, node, in_shapes):
-		return [in_shapes[0]]
+    @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.
+
+        :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).
+        :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.
+        """
+        if len(imgshape) < 2:
+            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]]
+
+        if not ignore_border:
+            if isinstance(r, theano.Variable):
+                rval[-2] = tensor.switch(r % ds[0], rval[-2] + 1, rval[-2])
+            elif r % ds[0]:
+                rval[-2] += 1
+            if isinstance(c, theano.Variable):
+                rval[-1] = tensor.switch(c % ds[1], rval[-1] + 1, rval[-1])
+            elif c % ds[1]:
+                rval[-1] += 1
+        return rval
+
+    def __init__(self, ds, ignore_border):
+        self.ds = tuple(ds)
+        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)
+
+    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)
+
+    def make_node(self, x, maxout, gz):
+        # 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()])
+
+    def perform(self, node, inp, out):
+
+        x, maxout, ggx = inp
+        z, = out
+
+        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] = theano._asarray(z[0], dtype=x.dtype)
+        ggz = z[0]
 
+        ds0, ds1 = self.ds
+        if self.ignore_border:
+            x_usable2 = (x.shape[2] // ds0 * ds0)
+        else:
+            x_usable2 = x.shape[2]
+        if self.ignore_border:
+            x_usable3 = (x.shape[3] // ds1 * ds1)
+        else:
+            x_usable3 = x.shape[3]
+
+        for n in xrange(x.shape[0]):
+            for k in xrange(x.shape[1]):
+                for i in xrange(x_usable2):
+                    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]
+
+    def infer_shape(self, node, in_shapes):
+        return [in_shapes[0]]