Change args in conv_transpose1d

test=develop

Author: wanghaoshuang

python/paddle/fluid/layers/nn.py

@@ -58,7 +58,6 @@
  'inplace_abn',
  'instance_norm',
  'data_norm',
- 'conv1d_transpose',
  'conv2d_transpose',
  'conv3d_transpose',
  'reduce_sum',
@@ -3728,271 +3727,6 @@ def spectral_norm(weight, dim=0, power_iters=1, eps=1e-12, name=None):
  return out
 
 
-def conv1d_transpose(input,
- num_filters,
- output_size=None,
- filter_size=None,
- padding=0,
- stride=1,
- dilation=1,
- groups=None,
- param_attr=None,
- bias_attr=None,
- use_cudnn=True,
- act=None,
- name=None):
- """
- :api_attr: Static Graph
-
- The convolution1D transpose layer calculates the output based on the input,
- filter, and dilation, stride, padding. Input(Input) and output(Output)
- are in NCL format where N is batch size, C is the number of channels,
- L is the length of the feature. The details of convolution transpose
- layer, please refer to the following explanation and references
- `therein <https://arxiv.org/pdf/1603.07285.pdf>`_.
- If bias attribution and activation type are provided, bias is added to
- the output of the convolution, and the corresponding activation function
- is applied to the final result.
-
- For each input :math:`X`, the equation is:
-
- .. math::
-
- Out = \sigma (W \\ast X + b)
-
- Where:
-
- * :math:`X`: Input value, a 3-D Tensor with NCL format.
- * :math:`W`: Filter value, a 3-D Tensor with MCL format.
- * :math:`\\ast`: Convolution operation.
- * :math:`b`: Bias value, a 2-D Tensor with shape [M, 1].
- * :math:`\\sigma`: Activation function.
- * :math:`Out`: Output value, a 3-D Tensor with data format 'NCL', the shape of :math:`Out` and :math:`X` may be different.
-
- Example:
-
- - Input:
-
- Input shape: :math:`(N, C_{in}, L_{in})`
-
- Filter shape: :math:`(C_{in}, C_{out}, L_f)`
-
- - Output:
-
- Output shape: :math:`(N, C_{out}, L_{out})`
-
- Where
-
- .. math::
-
- L^\prime_{out} &= (L_{in} - 1) * stride - pad_top - pad_bottom + dilation * (L_f - 1) + 1 \\\\
- L_{out} &\in [ L^\prime_{out}, L^\prime_{out} + stride ]
-
- Note:
- The conv1d_transpose can be seen as the backward of the conv1d. For conv1d,
- when stride > 1, conv1d maps multiple input shape to the same output shape,
- so for conv2d_transpose, when stride > 1, input shape maps multiple output shape.
- If output_size is None, :math:`L_{out} = L^\prime_{out}`;
- else, the :math:`L_{out}` of the output size must between :math:`L^\prime_{out}`
- and :math:`L^\prime_{out} + stride`. conv2d_transpose can compute the kernel size automatically.
-
- Args:
- input(Variable): 3-D Tensor with [N, C, L] format,
- its data type is float32 or float64.
- num_filters(int): The number of the filter. It is as same as the output
- image channel.
- output_size(int|tuple, optional): The output image size. If output size is a
- tuple, it must contain one integer, (feature_length). None if use
- filter_size, padding, and stride to calculate output_size.
- If output_size and filter_size are specified at the same time, They
- should follow the formula above. Default: None. output_size and filter_size
- should not be None at the same time.
- filter_size(int|tuple, optional): The filter size. If filter_size is a tuple,
- it must contain one integers, (filter_size). None if
- use output size to calculate filter_size. Default: None. filter_size and
- output_size should not be None at the same time.
- stride(int|tuple, optional): The stride size. It means the stride in transposed convolution.
- If stride is a tuple, it must contain one integer, (stride_size).
- Default: stride = 1.
- padding(int|list|str|tuple, optional): The padding size. The padding argument effectively adds
- `dilation * (kernel - 1)` amount of zero-padding on both sides of input. If `padding` is a
- string, either 'VALID' or 'SAME' supported, which is the padding algorithm.
- If `padding` is a tuple or list, it could be in three forms:
- `[pad]` or `[pad_top, pad_bottom]`, and `[[0,0], [0,0], [pad_height_top, pad_height_bottom],
- [pad_width_left, pad_width_right]]`. Default: padding = 0.
- dilation(int|tuple, optional): The dilation size. It means the spacing between the kernel points.
- If dilation is a tuple, it must contain one integers, (dilation_size).
- Default: dilation = 1.
- filter_size(int|tuple, optional): The filter size. If filter_size is a tuple,
- it must contain one integers, (filter_size). None if
- use output size to calculate filter_size. Default: None.
- groups(int, optional): The groups number of the Conv2d transpose layer. Inspired by
- grouped convolution in Alex Krizhevsky's Deep CNN paper, in which
- when group=2, the first half of the filters is only connected to the
- first half of the input channels, while the second half of the
- filters is only connected to the second half of the input channels.
- Default: groups = 1.
- param_attr (ParamAttr, optional): The parameter attribute for learnable parameters/weights
- of conv2d_transpose. If it is set to None or one attribute of ParamAttr, conv2d_transpose
- will create ParamAttr as param_attr. If the Initializer of the param_attr
- is not set, the parameter is initialized with Xavier. Default: None.
- bias_attr (ParamAttr|bool, optional): The parameter attribute for the bias of conv2d_transpose.
- If it is set to False, no bias will be added to the output units.
- If it is set to None or one attribute of ParamAttr, conv2d_transpose
- will create ParamAttr as bias_attr. If the Initializer of the bias_attr
- is not set, the bias is initialized zero. Default: None.
- use_cudnn(bool, optional): Use cudnn kernel or not, it is valid only when the cudnn
- library is installed. Default: True.
- act (str, optional): Activation type, if it is set to None, activation is not appended.
- Default: None.
- name(str, optional): For detailed information, please refer
- to :ref:`api_guide_Name`. Usually name is no need to set and
- None by default.
-
- Returns:
- A Variable holding Tensor representing the conv1d_transpose, whose
- data type is the same with input and shape is (num_batches, channels, length).
- If act is None, the tensor variable storing the transposed convolution result,
- and if act is not None, the tensor variable storing transposed convolution and
- non-linearity activation result.
-
- Raises:
- ValueError: If the type of `use_cudnn` is not bool.
- ValueError: If `padding` is a string, but not "SAME" or "VALID".
- ValueError: If `padding` is a tuple, but the element corresponding to the input's batch size is not 0
- or the element corresponding to the input's channel is not 0.
- ValueError: If `output_size` and filter_size are None at the same time.
- ShapeError: If the input is not 3-D Tensor.
- ShapeError: If the input's dimension size and filter's dimension size not equal.
- ShapeError: If the dimension size of input minus the size of `stride` is not 1.
- ShapeError: If the number of input channels is not equal to filter's channels.
- ShapeError: If the size of `output_size` is not equal to that of `stride`.
-
- Examples:
- .. code-block:: python
-
- import paddle.fluid as fluid
- data = fluid.data(name='data', shape=[None, 3, 32], dtype='float32')
- conv2d_transpose = fluid.layers.conv1d_transpose(input=data, num_filters=2, filter_size=3)
- """
- assert param_attr is not False, "param_attr should not be False in conv1d_transpose."
-
- input_channel = input.shape[1]
- op_type = 'conv2d_transpose'
- if (input_channel == groups and num_filters == input_channel and
- not use_cudnn):
- op_type = 'depthwise_conv2d_transpose'
-
- helper = LayerHelper(op_type, **locals())
- if not isinstance(input, Variable):
- raise TypeError("Input of conv1d_transpose must be Variable")
-
- stride = utils.convert_to_list(stride, 1, 'stride') + [1]
- dilation = utils.convert_to_list(dilation, 1, 'dilation') + [1]
-
- if not isinstance(use_cudnn, bool):
- raise ValueError("use_cudnn should be True or False")
-
- def _update_padding(padding):
- def is_list_or_tuple(ele):
- if isinstance(ele, list) or isinstance(ele, tuple):
- return True
- return False
-
- if is_list_or_tuple(padding) and len(padding) == 3:
- if is_list_or_tuple(padding[0]):
- if not (padding[0] == [0, 0] and padding[1] == [0, 0]):
- raise ValueError(
- "Non-zero padding(%s) in the batch or channel dimensions "
- "is not supported." % str(padding))
- padding = padding + [[0, 0]]
- padding = padding[2:4]
- padding = [ele for a_list in padding for ele in a_list]
- else:
- padding = padding + [0]
-
- padding = utils.convert_to_list(padding, 4, 'padding')
- else:
- padding = utils.convert_to_list(padding, 1, 'padding') + [0]
- padding = [padding[0], padding[0], padding[1], padding[1]]
- return padding
-
- padding_algorithm = "EXPLICIT"
- if isinstance(padding, str):
- padding = padding.upper()
- if padding not in ["SAME", "VALID"]:
- raise ValueError(
- "Unknown padding: '%s'. It can only be 'SAME' or 'VALID'." %
- str(padding))
- if padding == "VALID":
- padding_algorithm = "VALID"
- padding = [0]
- elif padding == "SAME":
- padding_algorithm = "SAME"
- padding = [0]
-
- padding = _update_padding(padding)
-
- input = unsqueeze(input=input, axes=[-1])
-
- if filter_size is None:
- if output_size is None:
- raise ValueError("output_size must be set when filter_size is None")
- if isinstance(output_size, int):
- output_size = [output_size, 1]
-
- h_in = input.shape[2]
- w_in = input.shape[3]
-
- filter_size_h = (output_size[0] - (h_in - 1) * stride[0] + padding[0] +
- padding[1] - 1) // dilation[0] + 1
- filter_size_w = (output_size[1] - (w_in - 1) * stride[1] + padding[2] +
- padding[3] - 1) // dilation[1] + 1
- filter_size = [filter_size_h, filter_size_w]
- else:
- filter_size = utils.convert_to_list(
- filter_size, 1, 'conv2d_transpose.filter_size') + [1]
-
- if len(padding) == 4 and utils._is_symmetric_padding(padding, 2):
- padding = [padding[0], padding[2]]
-
- if output_size is None:
- output_size = []
- elif isinstance(output_size, (list, tuple, int)):
- output_size = utils.convert_to_list(output_size, 1, 'output_size') + [1]
- else:
- raise ValueError("output_size should be int, list[int] or tuple[int]")
- groups = 1 if groups is None else groups
- filter_shape = [input_channel, num_filters // groups] + filter_size
-
- img_filter = helper.create_parameter(
- dtype=input.dtype, shape=filter_shape, attr=helper.param_attr)
-
- img_filter = reshape(img_filter, shape=filter_shape)
-
- pre_bias = helper.create_variable_for_type_inference(dtype=input.dtype)
- helper.append_op(
- type=op_type,
- inputs={'Input': [input],
- 'Filter': [img_filter]},
- outputs={'Output': pre_bias},
- attrs={
- 'output_size': output_size,
- 'strides': stride,
- 'paddings': padding,
- 'padding_algorithm': padding_algorithm,
- 'dilations': dilation,
- 'groups': groups,
- 'use_cudnn': use_cudnn,
- 'data_format': "NCHW"
- })
-
- pre_act = helper.append_bias_op(pre_bias, dim_start=1, dim_end=2)
- out = helper.append_activation(pre_act)
- out = squeeze(input=out, axes=[-1])
- return out
-
-
 def conv2d_transpose(input,
  num_filters,
  output_size=None,

python/paddle/nn/__init__.py

@@ -78,7 +78,7 @@
 from .layer.common import Linear #DEFINE_ALIAS
 from .layer.common import Flatten #DEFINE_ALIAS
 from .layer.common import UpSample #DEFINE_ALIAS
-from .layer.conv import Conv1DTranspose #DEFINE_ALIAS
+from .layer.conv import ConvTranspose1D #DEFINE_ALIAS
 from .layer.conv import Conv2D #DEFINE_ALIAS
 from .layer.conv import Conv2DTranspose #DEFINE_ALIAS
 from .layer.conv import Conv3D #DEFINE_ALIAS

python/paddle/nn/functional/__init__.py

@@ -63,7 +63,7 @@
 # from .common import bilinear_tensor_product #DEFINE_ALIAS
 from .common import assign #DEFINE_ALIAS
 from .common import interpolate #DEFINE_ALIAS
-from .conv import conv1d_transpose #DEFINE_ALIAS
+from .conv import conv_transpose1d #DEFINE_ALIAS
 from .conv import conv2d #DEFINE_ALIAS
 from .conv import conv2d_transpose #DEFINE_ALIAS
 from .conv import conv3d #DEFINE_ALIAS