Merge pull request #6460 from erakra/upsamp2

theano/tensor/nnet/abstract_conv.py

@@ -1761,8 +1761,7 @@ def bilinear_kernel_1D(ratio, normalize=True):
 
 
 def frac_bilinear_upsampling(input,
-                             ratio=None,
-                             frac_ratio=None):
+                             frac_ratio):
     """Compute bilinear upsampling
     This function will build the symbolic graph for upsampling
     a tensor by the given ratio using bilinear interpolation.
@@ -1772,10 +1771,7 @@ def frac_bilinear_upsampling(input,
     input: symbolic 4D tensor
         mini-batch of feature map stacks, of shape (batch size,
         input channels, input rows, input columns) that will be upsampled.
-    ratio: `int or Constant or Scalar Tensor of int* dtype`
-        the ratio by which the input is upsampled in the 2D space (row and
-        col size).
-    frac_ratio: None, tuple of int or tuple of tuples of int
+    frac_ratio: tuple of int or tuple of tuples of int
         The tuple defining the fractional ratio by which the input is
         upsampled in the 2D space. One fractional ratio should be
         represented as (numerator, denominator). If row and col ratios are
@@ -1790,42 +1786,35 @@ def frac_bilinear_upsampling(input,
     Notes
     -----
     :note: The kernel used for bilinear interpolation is fixed (not learned).
-    :note: When the upsampling ratio is even, the last row and column is
-        repeated one extra time compared to the first row and column which makes
-        the upsampled tensor asymmetrical on both sides. This does not happen when
-        the upsampling ratio is odd.
-    :note: This function must get either ratio or frac_ratio as parameter and
-        never both at once.
+    :note: When the upsampling frac_ratio numerator is even, the
+        last row and column is repeated one extra time compared to the first
+        row and column which makes the upsampled tensor asymmetrical on both
+        sides. This does not happen when it is odd.
     """
 
     T = theano.tensor
     row, col = input.shape[2:]
     up_input = input.reshape((-1, 1, row, col))
 
-    # redefince the ratio depending on the case
-    if frac_ratio is None:
-        if not isinstance(ratio, tuple):
-            ratio = (ratio, ratio)
-        subsample = (1, 1)
+    # define the upsampling ratio depending on the case
+    if not isinstance(frac_ratio, tuple):
+        raise ValueError("frac_ratio must be a tuple")
     else:
-        if not isinstance(frac_ratio, tuple):
-            raise ValueError("frac_ratio must be a tuple")
-        else:
-            if isinstance(frac_ratio[0], tuple):
-                f_r = []
-                for i, fr in enumerate(frac_ratio):
-                    p, q = fr
-                    div = gcd(p, q)
-                    f_r.append(tuple(np.array(fr) // div))
-                frac_ratio = tuple(f_r)
-                ratio = (frac_ratio[0][0], frac_ratio[1][0])
-                subsample = (frac_ratio[0][1], frac_ratio[1][1])
-            else:
-                p, q = frac_ratio
+        if isinstance(frac_ratio[0], tuple):
+            f_r = []
+            for i, fr in enumerate(frac_ratio):
+                p, q = fr
                 div = gcd(p, q)
-                frac_ratio = tuple(np.array(frac_ratio) // div)
-                ratio = (frac_ratio[0], frac_ratio[0])
-                subsample = (frac_ratio[1], frac_ratio[1])
+                f_r.append(tuple(np.array(fr) // div))
+            frac_ratio = tuple(f_r)
+            ratio = (frac_ratio[0][0], frac_ratio[1][0])
+            subsample = (frac_ratio[0][1], frac_ratio[1][1])
+        else:
+            p, q = frac_ratio
+            div = gcd(p, q)
+            frac_ratio = tuple(np.array(frac_ratio) // div)
+            ratio = (frac_ratio[0], frac_ratio[0])
+            subsample = (frac_ratio[1], frac_ratio[1])
 
     # duplicate borders of the input
     concat_mat = T.concatenate((up_input[:, :, :1, :], up_input,
@@ -1853,7 +1842,7 @@ def frac_bilinear_upsampling(input,
                                       dtype=theano.config.floatX)),
                              axis=3)
 
-    # upsample the input by passing it as kernl of conv and using filter_dilation
+    # upsample the input by passing it as kernel of conv and using filter_dilation
     upsamp = T.nnet.conv2d(pad_kern, concat_mat, border_mode='valid',
                            filter_dilation=ratio, subsample=subsample)
 
@@ -1914,12 +1903,11 @@ def bilinear_upsampling(input,
 
     if frac_ratio:
         if use_1D_kernel:
-            raise ValueError('For fractional ratios 1D kernel'
+            raise ValueError('For fractional ratios 1D kernel '
                              'method not implemented. You may want to pass '
                              'use_1D_kernel as False')
-        return frac_bilinear_upsampling(input,
-                                        ratio=ratio,
-                                        frac_ratio=frac_ratio)
+        # case of fractional 2D upsampling
+        return frac_bilinear_upsampling(input, frac_ratio=frac_ratio)
 
     # the remaining case if integer ratio with use_1D_kernel
     T = theano.tensor