conv.py 71.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
#   Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
14
from __future__ import print_function
15

16
import numpy as np
L
LielinJiang 已提交
17
from ...device import get_cudnn_version
18
from ...static import Variable
Z
zhiboniu 已提交
19
from ...fluid import dygraph_utils
20
from ...fluid.layers.utils import convert_to_list, _is_symmetric_padding
21
from ...fluid.data_feeder import check_variable_and_dtype
22
from ...framework import ParamAttr
23
from ...fluid.layer_helper import LayerHelper
24 25 26
from ...tensor.manipulation import unsqueeze, squeeze
from ...tensor.math import add
from ...fluid.layers import nn
F
From00 已提交
27 28 29
from paddle import _C_ops
from paddle import get_flags
from paddle import in_dynamic_mode
Z
zhiboniu 已提交
30 31
from paddle.device import is_compiled_with_cuda
from paddle.device import is_compiled_with_npu
H
hong 已提交
32 33
from paddle import in_dynamic_mode
from paddle import get_flags
F
From00 已提交
34 35 36 37
from paddle.device import is_compiled_with_rocm
from paddle.fluid.framework import _global_flags
from paddle.fluid.framework import _in_legacy_dygraph
from paddle.fluid.framework import in_dygraph_mode
38

39 40
__all__ = []

41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

def _is_list_or_tuple(input):
    return isinstance(input, (list, tuple))


def _zero_padding_in_batch_and_channel(padding, channel_last):
    if channel_last:
        return list(padding[0]) == [0, 0] and list(padding[-1]) == [0, 0]
    else:
        return list(padding[0]) == [0, 0] and list(padding[1]) == [0, 0]


def _exclude_padding_in_batch_and_channel(padding, channel_last):
    padding_ = padding[1:-1] if channel_last else padding[2:]
    padding_ = [elem for pad_a_dim in padding_ for elem in pad_a_dim]
    return padding_


def _update_padding_nd(padding, channel_last, num_dims):
    if isinstance(padding, str):
        padding = padding.upper()
        if padding not in ["SAME", "VALID"]:
            raise ValueError(
                "Unknown padding: '{}'. It can only be 'SAME' or 'VALID'.".
                format(padding))
        if padding == "VALID":
            padding_algorithm = "VALID"
            padding = [0] * num_dims
        else:
            padding_algorithm = "SAME"
            padding = [0] * num_dims
    elif _is_list_or_tuple(padding):
        # for padding like
        # [(pad_before, pad_after), (pad_before, pad_after), ...]
        # padding for batch_dim and channel_dim included
        if len(padding) == 2 + num_dims and _is_list_or_tuple(padding[0]):
            if not _zero_padding_in_batch_and_channel(padding, channel_last):
                raise ValueError(
                    "Non-zero padding({}) in the batch or channel dimensions "
                    "is not supported.".format(padding))
            padding_algorithm = "EXPLICIT"
82 83
            padding = _exclude_padding_in_batch_and_channel(
                padding, channel_last)
84
            if _is_symmetric_padding(padding, num_dims):
85 86 87 88
                padding = padding[0::2]
        # for padding like [pad_before, pad_after, pad_before, pad_after, ...]
        elif len(padding) == 2 * num_dims and isinstance(padding[0], int):
            padding_algorithm = "EXPLICIT"
89 90
            padding = convert_to_list(padding, 2 * num_dims, 'padding')
            if _is_symmetric_padding(padding, num_dims):
91 92 93 94
                padding = padding[0::2]
        # for padding like [pad_d1, pad_d2, ...]
        elif len(padding) == num_dims and isinstance(padding[0], int):
            padding_algorithm = "EXPLICIT"
95
            padding = convert_to_list(padding, num_dims, 'padding')
96 97 98 99 100
        else:
            raise ValueError("In valid padding: {}".format(padding))
    # for integer padding
    else:
        padding_algorithm = "EXPLICIT"
101
        padding = convert_to_list(padding, num_dims, 'padding')
102 103
    if not all([p >= 0 for p in padding]):
        raise ValueError(
104 105
            "Invalid padding, all value should be larger than or equal to 0, but received: {}"
            .format(padding))
106 107 108
    return padding, padding_algorithm


L
LielinJiang 已提交
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
def _conv_nd(x,
             weight,
             bias=None,
             stride=1,
             padding=0,
             padding_algorithm=None,
             dilation=1,
             groups=1,
             data_format="NCHW",
             channel_dim=1,
             op_type="conv2d",
             use_cudnn=True,
             use_mkldnn=False,
             name=None):

124
    # Due to the poor performance of NHWC, we transpose the input to NCHW.
H
hong 已提交
125
    if in_dygraph_mode() and op_type == "conv2d":
126 127 128 129
        pre_bias = _C_ops.final_state_conv2d(x, weight, stride, padding,
                                             padding_algorithm, groups,
                                             dilation, data_format, False, -1,
                                             False)
H
hong 已提交
130
        if bias is not None:
131 132
            channel_dim = channel_dim + len(
                x.shape) if channel_dim < 0 else channel_dim
C
Chen Weihang 已提交
133 134 135 136 137 138 139
            if len(bias.shape) < len(x.shape):
                tmp_bias = _C_ops.final_state_reshape(
                    bias, bias.shape +
                    [1 for i in range(len(x.shape) - channel_dim - 1)])
                return _C_ops.final_state_add(pre_bias, tmp_bias)
            else:
                return _C_ops.final_state_add(pre_bias, bias)
H
hong 已提交
140 141
        else:
            return pre_bias
142 143 144 145

    if in_dygraph_mode() and op_type == "depthwise_conv2d":
        pre_bias = _C_ops.final_state_depthwise_conv2d(
            x, weight, stride, padding, padding_algorithm, groups, dilation,
146
            data_format, False, -1, False, False, use_cudnn)
147 148 149 150
        if bias is not None:
            channel_dim = channel_dim + len(
                x.shape) if channel_dim < 0 else channel_dim
            tmp_bias = _C_ops.final_state_reshape(
151 152
                bias,
                bias.shape + [1 for i in range(len(x.shape) - channel_dim - 1)])
153 154 155 156 157
            return _C_ops.final_state_add(pre_bias, tmp_bias)
        else:
            return pre_bias

    if in_dygraph_mode() and op_type == "conv3d":
158 159 160 161
        pre_bias = _C_ops.final_state_conv3d(x, weight, stride, padding,
                                             padding_algorithm, groups,
                                             dilation, data_format, False, -1,
                                             False)
162 163 164 165
        if bias is not None:
            channel_dim = channel_dim + len(
                x.shape) if channel_dim < 0 else channel_dim
            tmp_bias = _C_ops.final_state_reshape(
166 167
                bias,
                bias.shape + [1 for i in range(len(x.shape) - channel_dim - 1)])
168 169 170 171
            return _C_ops.final_state_add(pre_bias, tmp_bias)
        else:
            return pre_bias

Z
zhiboniu 已提交
172
    if in_dynamic_mode():
L
LielinJiang 已提交
173 174 175 176 177
        attrs = ('strides', stride, 'paddings', padding, 'dilations', dilation,
                 'groups', groups, 'use_cudnn', use_cudnn, 'use_mkldnn',
                 use_mkldnn, 'fuse_relu_before_depthwise_conv', False,
                 "padding_algorithm", padding_algorithm, "data_format",
                 data_format)
W
wanghuancoder 已提交
178
        pre_bias = getattr(_C_ops, op_type)(x, weight, *attrs)
L
LielinJiang 已提交
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
        if bias is not None:
            out = nn.elementwise_add(pre_bias, bias, axis=channel_dim)
        else:
            out = pre_bias
    else:
        inputs = {'Input': [x], 'Filter': [weight]}
        attrs = {
            'strides': stride,
            'paddings': padding,
            'dilations': dilation,
            'groups': groups,
            'use_cudnn': use_cudnn,
            'use_mkldnn': use_mkldnn,
            'fuse_relu_before_depthwise_conv': False,
            "padding_algorithm": padding_algorithm,
            "data_format": data_format
        }
        check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
                                 op_type)
        helper = LayerHelper(op_type, **locals())
        dtype = helper.input_dtype(input_param_name='x')
        pre_bias = helper.create_variable_for_type_inference(dtype)
        outputs = {"Output": [pre_bias]}
202 203 204 205
        helper.append_op(type=op_type,
                         inputs=inputs,
                         outputs=outputs,
                         attrs=attrs)
L
LielinJiang 已提交
206 207
        if bias is not None:
            out = helper.create_variable_for_type_inference(dtype)
208 209 210 211 212 213 214 215 216 217
            helper.append_op(type='elementwise_add',
                             inputs={
                                 'X': [pre_bias],
                                 'Y': [bias]
                             },
                             outputs={'Out': [out]},
                             attrs={
                                 'axis': channel_dim,
                                 'use_mkldnn': use_mkldnn
                             })
L
LielinJiang 已提交
218 219 220 221 222
        else:
            out = pre_bias
    return out


W
whs 已提交
223 224 225 226 227 228 229 230 231
def conv1d(x,
           weight,
           bias=None,
           stride=1,
           padding=0,
           dilation=1,
           groups=1,
           data_format='NCL',
           name=None):
232
    r"""
W
whs 已提交
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
    The convolution1D layer calculates the output based on the input, filter
    and strides, paddings, dilations, groups parameters. Input and
    Output are in NCL format, where N is batch size, C is the number of
    channels, L is the length of the feature.
    Filter is in MCK format, where M is the number of output image channels,
    C is the number of input image channels, K is the size of the kernel.
    If the groups is greater than 1, C will equal the number of input image
    channels divided by the groups. 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::

W
whs 已提交
248
        Out = \sigma (W \ast X + b)
W
whs 已提交
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274

    Where:

    * :math:`X`: Input value, a tensor with NCL format.
    * :math:`W`: Kernel value, a tensor with MCK 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, 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_{out}, C_{in}, L_f)`

        - Output:

          Output shape: :math:`(N, C_{out}, L_{out})`

        Where

        .. math::

W
whs 已提交
275
            L_{out} = \frac{(L_{in} + 2 * padding - (dilation * (L_f - 1) + 1))}{stride} + 1
W
whs 已提交
276 277 278 279 280 281 282

    Args:
        x (Tensor): The input is 3-D Tensor with shape [N, C, L], the data type 
            of input is float16 or float32 or float64.
        weight (Tensor): The convolution kernel with shape [M, C/g, K], where M is
            the number of output channels, g is the number of groups, K is the kernel's size. 
        bias (Tensor, optional): The bias with shape [M,]. Default: None.
283
        stride (int|list|tuple, optional): The stride size. If stride is a list/tuple, it must
W
whs 已提交
284
            contain one integers, (stride_size). Default: 1.
285
        padding(int|str|tuple|list, optional): The padding size. Padding could be in one of the following forms.
W
whs 已提交
286 287 288 289 290 291
            1. a string in ['valid', 'same'].
            2. an int, which means the feature map is zero paded by size of `padding` on both sides.
            3. a list[int] or tuple[int] whose length is 1, which means the feature map is zero paded by size of `padding[0]` on both sides.
            4. a list[int] or tuple[int] whose length is 2. It has the form  [pad_before, pad_after].
            5. a list or tuple of pairs of ints. It has the form [[pad_before, pad_after], [pad_before, pad_after], ...]. Note that, the batch dimension and channel dimension are also included. Each pair of integers correspond to the amount of padding for a dimension of the input. Padding in batch dimension and channel dimension should be [0, 0] or (0, 0).
            The default value is 0.
292
        dilation (int|list|tuple, optional): The dilation size. If dilation is a list/tuple, it must
W
whs 已提交
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
            contain one integer, (dilation_size). Default: 1.
        groups (int, optional): The groups number of the conv1d function. According to grouped
            convolution in Alex Krizhevsky's Deep CNN paper: 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: 1.
        data_format (str, optional): Specify the data format of the input, and the data format of the output 
            will be consistent with that of the input. An optional string from: `"NCL"`, `"NLC"`.
            The default is `"NCL"`. When it is `"NCL"`, the data is stored in the order of:
            `[batch_size, input_channels, feature_length]`.
        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 tensor representing the conv1d, whose data type is the 
        same with input.

    Raises:
312
        ValueError: If the channel dimension of the input is less than or equal to zero.
W
whs 已提交
313 314
        ValueError: If `data_format` is not "NCL" or "NLC".
        ValueError: If `padding` is a string, but not "SAME" or "VALID".
315
        ValueError: If `padding` is a list/tuple, but the element corresponding to the input's batch size is not 0 
W
whs 已提交
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
            or the element corresponding to the input's channel is not 0.
        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 * groups.
        ShapeError: If the number of output channels is not be divided by groups.

    Examples:
        .. code-block:: python

          import paddle
          import paddle.nn.functional as F
          import numpy as np
          x = np.array([[[4, 8, 1, 9],
            [7, 2, 0, 9],
            [6, 9, 2, 6]]]).astype(np.float32)
          w=np.array(
          [[[9, 3, 4],
            [0, 0, 7],
            [2, 5, 6]],
           [[0, 3, 4],
            [2, 9, 7],
            [5, 6, 8]]]).astype(np.float32)
L
LielinJiang 已提交
339
          
W
whs 已提交
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
          x_var = paddle.to_tensor(x)
          w_var = paddle.to_tensor(w)
          y_var = F.conv1d(x_var, w_var)
          y_np = y_var.numpy()
          print(y_np)
          
          # [[[133. 238.]
          #   [160. 211.]]]
    """
    cudnn_version = get_cudnn_version()
    if cudnn_version is not None:
        use_cudnn = True
    else:
        use_cudnn = False

    if data_format not in ["NCL", "NLC"]:
        raise ValueError("Attr(data_format) should be 'NCL' or 'NLC'. "
                         "Received Attr(data_format): {}.".format(data_format))

L
LielinJiang 已提交
359
    channel_last = (data_format == "NLC")
W
whs 已提交
360 361
    channel_dim = -1 if channel_last else 1
    conv2d_data_format = "NHWC" if channel_last else "NCHW"
362 363 364 365
    if len(x.shape) != 3:
        raise ValueError(
            "Input x should be 3D tensor, but received x with the shape of {}".
            format(x.shape))
W
whs 已提交
366 367 368
    num_channels = x.shape[channel_dim]
    num_filters = weight.shape[0]
    if num_channels < 0:
369
        raise ValueError("The channel dimension of the input({}) "
W
whs 已提交
370 371
                         "should be defined. Received: {}.".format(
                             x.shape, num_channels))
372 373
    if groups <= 0:
        raise ValueError(
374 375
            "The groups of conv1d should be greater than 0. Received groups: {}"
            .format(groups))
W
whs 已提交
376 377 378 379 380 381 382 383 384 385 386 387 388
    if num_channels % groups != 0:
        raise ValueError(
            "the channel of input must be divisible by groups,"
            "received: the channel of input is {}, the shape of input is {}"
            ", the groups is {}".format(num_channels, x.shape, groups))
    if num_filters % groups != 0:
        raise ValueError(
            "the number of filters must be divisible by groups,"
            "received: the number of filters is {}, the shape of weight is {}"
            ", the groups is {}".format(num_filters, weight.shape, groups))

    # update attrs
    padding, padding_algorithm = _update_padding_nd(padding, channel_last, 1)
389

W
whs 已提交
390
    if len(padding) == 2:
391
        padding = [0] * 2 + padding
W
whs 已提交
392
    elif len(padding) == 1:
393
        padding = [0] + padding
W
whs 已提交
394 395
    else:
        raise ValueError(
396 397
            "The size of padding's dimension should be 1 or 2. But got padding={}"
            .format(padding))
398 399 400
    stride = [1] + convert_to_list(stride, 1, 'stride')
    dilation = [1] + convert_to_list(dilation, 1, 'dilation')
    weight = unsqueeze(weight, axis=[-2])
W
whs 已提交
401 402

    l_type = "conv2d"
403 404

    # When "groups==num_channels and num_filters% num_channels == 0" using depthwise_conv2d has better performance
405 406
    if (is_compiled_with_cuda() and num_channels == groups and num_channels != 1
            and num_filters % num_channels == 0):
W
whs 已提交
407 408 409
        l_type = 'depthwise_conv2d'
        use_cudnn = False

410
    # NPU only supports depthwise_conv2d when  "input_channel = output_channel = groups"
Z
zhiboniu 已提交
411
    if is_compiled_with_npu():
412 413 414 415 416
        if (num_channels == groups and num_channels == num_filters):
            l_type = 'depthwise_conv2d'
        else:
            l_type = 'conv2d'

417
    squeeze_aixs = -3 if channel_last else -2
418
    x = unsqueeze(x, axis=[squeeze_aixs])
419

Z
zhiboniu 已提交
420
    if in_dynamic_mode():
W
whs 已提交
421 422 423 424
        attrs = ('strides', stride, 'paddings', padding, 'dilations', dilation,
                 'groups', groups, 'use_cudnn', use_cudnn, 'use_mkldnn', False,
                 'fuse_relu_before_depthwise_conv', False, "padding_algorithm",
                 padding_algorithm, "data_format", conv2d_data_format)
W
wanghuancoder 已提交
425
        out = getattr(_C_ops, l_type)(x, weight, *attrs)
W
whs 已提交
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
        if bias is not None:
            out = nn.elementwise_add(out, bias, axis=channel_dim)
    else:
        inputs = {'Input': [x], 'Filter': [weight]}
        attrs = {
            'strides': stride,
            'paddings': padding,
            'dilations': dilation,
            'groups': groups,
            'use_cudnn': use_cudnn,
            'use_mkldnn': False,
            'fuse_relu_before_depthwise_conv': False,
            "padding_algorithm": padding_algorithm,
            "data_format": conv2d_data_format
        }
        check_variable_and_dtype(x, 'input', ['float16', 'float32', 'float64'],
                                 'conv2d')
        helper = LayerHelper(l_type, **locals())
444
        dtype = helper.input_dtype(input_param_name='x')
W
whs 已提交
445 446
        out = helper.create_variable_for_type_inference(dtype)
        outputs = {"Output": [out]}
447 448 449 450
        helper.append_op(type=l_type,
                         inputs=inputs,
                         outputs=outputs,
                         attrs=attrs)
W
whs 已提交
451 452
        if bias is not None:
            out = nn.elementwise_add(out, bias, axis=channel_dim)
453
    out = squeeze(out, axis=[squeeze_aixs])
W
whs 已提交
454 455 456
    return out


457
def conv2d(x,
458 459 460
           weight,
           bias=None,
           stride=1,
461
           padding=0,
462 463 464 465
           dilation=1,
           groups=1,
           data_format="NCHW",
           name=None):
466
    r"""
S
swtkiwi 已提交
467

468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
    The convolution2D layer calculates the output based on the input, filter
    and strides, paddings, dilations, groups parameters. Input and
    Output are in NCHW or NHWC format, where N is batch size, C is the number of
    channels, H is the height of the feature, and W is the width of the feature.
    Filter is in MCHW format, where M is the number of output image channels,
    C is the number of input image channels, H is the height of the filter,
    and W is the width of the filter. If the groups is greater than 1,
    C will equal the number of input image channels divided by the groups.
    Please refer to UFLDL's `convolution
    <http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/>`_
    for more details.
    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:

485
    ..  math::
486

487
        Out = \sigma (W \ast X + b)
488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511

    Where:

    * :math:`X`: Input value, a tensor with NCHW or NHWC format.
    * :math:`W`: Filter value, a tensor with MCHW 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, the shape of :math:`Out` and :math:`X` may be different.

    Example:

        - Input:

          Input shape: :math:`(N, C_{in}, H_{in}, W_{in})`

          Filter shape: :math:`(C_{out}, C_{in}, H_f, W_f)`

        - Output:

          Output shape: :math:`(N, C_{out}, H_{out}, W_{out})`

        Where

512
        ..  math::
513

514 515
            H_{out}&= \frac{(H_{in} + 2 * paddings[0] - (dilations[0] * (H_f - 1) + 1))}{strides[0]} + 1 \\\\
            W_{out}&= \frac{(W_{in} + 2 * paddings[1] - (dilations[1] * (W_f - 1) + 1))}{strides[1]} + 1
516 517

    Args:
518
        x (Tensor): The input is 4-D Tensor with shape [N, C, H, W], the data type 
519
            of input is float16 or float32 or float64.
520
        weight (Tensor): The convolution kernel with shape [M, C/g, kH, kW], where M is
521 522
            the number of output channels, g is the number of groups, kH is the filter's
            height, kW is the filter's width. 
523
        bias (Tensor, optional): The bias with shape [M,].
524 525
        stride (int|list|tuple): The stride size. It means the stride in convolution. 
            If stride is a list/tuple, it must contain two integers, (stride_height, stride_width). 
526
            Otherwise, stride_height = stride_width = stride. Default: stride = 1.
527 528 529 530 531 532 533
        padding (string|int|list|tuple): The padding size. It means the number of zero-paddings
            on both sides for each dimension.If `padding` is a string, either 'VALID' or
            'SAME' which is the padding algorithm. If padding size is a tuple or list,
            it could be in three forms: `[pad_height, pad_width]` or
            `[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`, and when 
            `data_format` is `"NCHW"`, `padding` can be in the form `[[0,0], [0,0], 
            [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
L
LielinJiang 已提交
534
            when `data_format` is `"NHWC"`, `padding` can be in the form
535 536
            `[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
            Default: padding = 0.
537 538
        dilation (int|list|tuple): The dilation size. It means the spacing between the kernel
            points. If dilation is a list/tuple, it must contain two integers, (dilation_height, 
539 540
            dilation_width). Otherwise, dilation_height = dilation_width = dilation. 
            Default: dilation = 1.
C
cnn 已提交
541
        groups (int): The groups number of the Conv2D Layer. According to grouped
542 543 544 545 546 547 548 549 550 551 552 553 554
            convolution in Alex Krizhevsky's Deep CNN paper: 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.
        data_format (str, optional): Specify the data format of the input, and the data format of the output 
            will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
            The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
            `[batch_size, input_channels, input_height, input_width]`.
        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:
555
        A Tensor representing the conv2d result, whose data type is the same with input. 
556 557 558

    Raises:
        ValueError: If `data_format` is not "NCHW" or "NHWC".
559
        ValueError: If the channel dimension of the input is less than or equal to zero.
560
        ValueError: If `padding` is a string, but not "SAME" or "VALID".
561
        ValueError: If `padding` is a list/tuple, but the element corresponding to the input's batch size is not 0 
562 563 564 565 566 567 568 569 570 571
            or the element corresponding to the input's channel is not 0.
        ShapeError: If the input is not 4-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 2.
        ShapeError: If the number of input channels is not equal to filter's channels * groups.
        ShapeError: If the number of output channels is not be divided by groups.

    Examples:
        .. code-block:: python

572
          import paddle
573 574
          import paddle.nn.functional as F

575 576
          x_var = paddle.randn((2, 3, 8, 8), dtype='float32')
          w_var = paddle.randn((6, 3, 3, 3), dtype='float32')
577 578 579 580

          y_var = F.conv2d(x_var, w_var)
          y_np = y_var.numpy()

581 582 583 584 585 586 587 588 589 590
          print(y_np.shape)
          # (2, 6, 6, 6)
    """
    # entry checks
    if data_format not in ["NCHW", "NHWC"]:
        raise ValueError("Attr(data_format) should be 'NCHW' or 'NHWC'. "
                         "Received Attr(data_format): {}.".format(data_format))

    channel_last = (data_format == "NHWC")
    channel_dim = -1 if channel_last else 1
591 592 593 594
    if len(x.shape) != 4:
        raise ValueError(
            "Input x should be 4D tensor, but received x with the shape of {}".
            format(x.shape))
595
    num_channels = x.shape[channel_dim]
596 597
    num_filters = weight.shape[0]
    if num_channels < 0:
598
        raise ValueError("The channel dimension of the input({}) "
599
                         "should be defined. Received: {}.".format(
600
                             x.shape, num_channels))
601 602
    if groups <= 0:
        raise ValueError(
603 604
            "The groups of conv2d should be greater than 0. Received groups: {}"
            .format(groups))
605 606 607 608
    if num_channels % groups != 0:
        raise ValueError(
            "the channel of input must be divisible by groups,"
            "received: the channel of input is {}, the shape of input is {}"
609
            ", the groups is {}".format(num_channels, x.shape, groups))
610 611 612 613 614 615
    if num_filters % groups != 0:
        raise ValueError(
            "the number of filters must be divisible by groups,"
            "received: the number of filters is {}, the shape of weight is {}"
            ", the groups is {}".format(num_filters, weight.shape, groups))

616 617
    cudnn_version = get_cudnn_version()

618 619
    use_cudnn = True if (is_compiled_with_cuda()
                         and cudnn_version is not None) else False
620

621 622
    # update attrs
    padding, padding_algorithm = _update_padding_nd(padding, channel_last, 2)
623 624
    stride = convert_to_list(stride, 2, 'stride')
    dilation = convert_to_list(dilation, 2, 'dilation')
625 626

    l_type = "conv2d"
627 628
    if (num_channels == groups and num_channels != 1
            and num_filters % num_channels == 0):
629
        l_type = 'depthwise_conv2d'
Z
zhiboniu 已提交
630
        if is_compiled_with_rocm():
631 632 633
            use_cudnn = True
        else:
            use_cudnn = False
H
hong 已提交
634 635
    else:
        if in_dygraph_mode():
636 637 638 639
            pre_bias = _C_ops.final_state_conv2d(x, weight, stride, padding,
                                                 padding_algorithm, groups,
                                                 dilation, data_format, False,
                                                 -1, False)
H
hong 已提交
640 641 642 643 644 645 646
            if bias is not None:
                out = nn.elementwise_add(pre_bias, bias, axis=channel_dim)
                return out
            else:
                return pre_bias

    use_mkldnn = _global_flags()["FLAGS_use_mkldnn"]
647

648
    # NPU only supports depthwise_conv2d when  "input_channel = output_channel = groups"
Z
zhiboniu 已提交
649
    if is_compiled_with_npu():
650 651 652 653 654
        if (num_channels == groups and num_channels == num_filters):
            l_type = 'depthwise_conv2d'
        else:
            l_type = 'conv2d'

655 656
    if (is_compiled_with_cuda() and get_flags("FLAGS_conv2d_disable_cudnn")
        ["FLAGS_conv2d_disable_cudnn"]):
657
        use_cudnn = False
658

L
LielinJiang 已提交
659 660 661
    return _conv_nd(x, weight, bias, stride, padding, padding_algorithm,
                    dilation, groups, data_format, channel_dim, l_type,
                    use_cudnn, use_mkldnn, name)
662 663


664
def conv1d_transpose(x,
665 666 667 668 669 670 671 672 673 674
                     weight,
                     bias=None,
                     stride=1,
                     padding=0,
                     output_padding=0,
                     groups=1,
                     dilation=1,
                     output_size=None,
                     data_format="NCL",
                     name=None):
675
    r"""
676 677 678 679 680 681 682 683 684 685 686 687 688 689
    The 1-D convolution transpose layer calculates the output based on the input,
    filter, and dilation, stride, padding. Input(Input) and output(Output)
    are in 'NCL' format or 'NLC' 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::

W
whs 已提交
690
        Out = \sigma (W \ast X + b)
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725

    Where:

    * :math:`X`: Input value, a 3-D Tensor with 'NCL' format or 'NLC' format.
    * :math:`W`: Filter value, a 3-D Tensor with 'MCK' 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' or 'NLC', 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 + output_padding \\\\
           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 conv1d_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}`
726
          and :math:`L^\prime_{out} + stride`.
727 728 729 730 731 732 733 734 735

    Args:
        x(Tensor): 3-D tensor with [N, C, L] or [N, L, C] format,
                         its data type is float32 or float64.
        weight(Tensor): The convolution kernel, a Tensor with shape [C, M/g, K],
            where M is the number of output channels(filters), g is the number of groups,
            K is the size of the kernel.
        bias(Tensor, optional): The bias, a Tensor with shape [M, ].
        stride(int|tuple|list, optional): The stride size. It means the stride in transposed convolution.
736
            If stride is a list/tuple, it must contain one integer, `(stride_size)`.
737 738 739 740 741 742 743
            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 two forms:
             `[pad]` or `[pad_left, pad_right]`. Default: padding = 0.
        output_padding(int|list|tuple, optional): The count of zeros to be added to tail of each dimension.
744
             If it is a list/tuple, it must contain one integer. Default: 0.
745 746 747 748 749 750 751
        groups(int, optional): The groups number of the conv1d transpose function. 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.
        dilation(int|tuple|list, optional): The dilation size. It means the spacing between the kernel points.
752
            If dilation is a list/tuple, it must contain one integer, `(dilation_size)`.
753 754
            Default: dilation = 1.
        output_size(int|tuple|list, optional): The output image size. If output size is a
755
            tuple/list, it must contain one integer, `(feature_length)`. None if use
756
            filter_size(shape of weight), padding, and stride to calculate output_size.
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773
        data_format (str, optional): Specify the data format of the input, and the data format of the output 
            will be consistent with that of the input. An optional string from: `"NCL"`, `"NLC"`.
            The default is `"NCL"`. When it is `"NCL"`, the data is stored in the order of:
            `[batch_size, input_channels, input_length]`.
        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  tensor representing the result of 1-D transpose convolution, whose
        data type is the same with input. And its shape is (num_batches, channels, length)
        when data_format is `"NCL"` and (num_batches, length, channels) when data_format is
        `"NLC"`.

    Raises:
        ValueError: If `data_format` is a string, but not "NCL" or "NLC".
        ValueError: If `padding` is a string, but not "SAME" or "VALID".
774
        ValueError: If `padding` is a list/tuple, but the element corresponding to the input's batch size is not 0 
775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
            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.
        ValueError: If `output_padding` is greater than `stride`.
        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
          import paddle.nn.functional as F
          import numpy as np
          
          # shape: (1, 2, 4)
          x=np.array([[[4, 0, 9, 7],
                       [8, 0, 9, 2,]]]).astype(np.float32)
          # shape: (2, 1, 2)
W
whs 已提交
797
          w=np.array([[[7, 0]],
798 799 800
                      [[4, 2]]]).astype(np.float32)
          x_var = paddle.to_tensor(x)
          w_var = paddle.to_tensor(w)
801
          y_var = F.conv1d_transpose(x_var, w_var)
W
whs 已提交
802
          print(y_var)
803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818
          
          # [[[60. 16. 99. 75.  4.]]]
    """
    cudnn_version = get_cudnn_version()
    if cudnn_version is not None:
        use_cudnn = True
    else:
        use_cudnn = False

    if data_format not in ['NCL', 'NLC']:
        raise ValueError(
            "Attr(data_format) of conv2d_transpose got wrong value: "
            "received {}, but only 'NCL' or 'NLC' are supported.".format(
                data_format))
    channel_last = (data_format == "NLC")
    channel_dim = -1 if channel_last else 1
819 820 821 822
    if len(x.shape) != 3:
        raise ValueError(
            "Input x should be 3D tensor, but received x with the shape of {}".
            format(x.shape))
823 824 825

    num_channels = x.shape[channel_dim]
    if num_channels < 0:
826
        raise ValueError("The channel dimension of the input({}) "
827 828
                         "should be defined. Received: {}.".format(
                             x.shape, num_channels))
829 830
    if groups <= 0:
        raise ValueError(
831 832
            "The groups of conv1d_transpose should be greater than 0. Received groups: {}"
            .format(groups))
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
    if num_channels % groups != 0:
        raise ValueError(
            "the channel of input must be divisible by groups,"
            "received: the channel of input is {}, the shape of input is {}"
            ", the groups is {}".format(num_channels, x.shape, groups))

    # update attrs
    padding, padding_algorithm = _update_padding_nd(padding, channel_last, 1)

    if len(padding) == 2:
        padding = padding + [0] * 2
    elif len(padding) == 1:
        padding = padding + [0]
    else:
        raise ValueError(
848
            "The size of padding's dimension should 1 or 2. But got padding={}".
849 850
            format(padding))

851 852
    stride = convert_to_list(stride, 1, 'stride') + [1]
    dilation = convert_to_list(dilation, 1, 'dilation') + [1]
853 854 855 856

    if output_size is None:
        output_size = []
    else:
L
LielinJiang 已提交
857 858 859 860
        if output_padding != 0:
            raise ValueError('output_padding option is mutually exclusive with '
                             'output_size')
        if isinstance(output_size, (list, tuple, int)):
861
            output_size = convert_to_list(output_size, 1, 'output_size') + [1]
L
LielinJiang 已提交
862 863 864 865 866 867 868
        else:
            raise ValueError(
                "output_size should be int, or list, tuple of ints")

    if output_padding == 0:
        output_padding = []
    else:
869 870
        output_padding = convert_to_list(output_padding, 1,
                                         'output_padding') + [0]
L
LielinJiang 已提交
871 872 873 874

    if len(output_padding) > 0 and output_padding[0] > stride[0]:
        raise ValueError(
            "The size of output_padding should not be greater than stride."
875 876
            "But got output_padding={} and stride={}".format(
                output_padding[0], stride[0]))
877 878 879

    op_type = 'conv2d_transpose'
    num_filters = weight.shape[1]
880 881
    if (num_channels == groups and num_channels != 1 and num_filters == 1
            and not use_cudnn):
882 883 884 885 886 887
        op_type = 'depthwise_conv2d_transpose'
        use_cudnn = False

    squeeze_axis = -2 if channel_last else -1
    conv2d_data_format = "NHWC" if channel_last else "NCHW"

888 889
    x = unsqueeze(x, axis=[squeeze_axis])
    weight = unsqueeze(weight, axis=[-1])
890

Z
zhiboniu 已提交
891
    if in_dynamic_mode():
L
LielinJiang 已提交
892 893 894 895
        attrs = ('output_padding', output_padding, 'output_size', output_size,
                 'strides', stride, 'paddings', padding, 'padding_algorithm',
                 padding_algorithm, 'dilations', dilation, 'groups', groups,
                 'use_cudnn', use_cudnn, 'data_format', conv2d_data_format)
W
wanghuancoder 已提交
896
        out = getattr(_C_ops, op_type)(x, weight, *attrs)
897 898 899 900 901
        if bias is not None:
            out = nn.elementwise_add(out, bias, axis=channel_dim)
    else:
        inputs = {'Input': [x], 'Filter': [weight]}
        attrs = {
L
LielinJiang 已提交
902
            'output_padding': output_padding,
903 904 905 906 907 908 909 910 911 912 913 914
            'output_size': output_size,
            'strides': stride,
            'paddings': padding,
            'padding_algorithm': padding_algorithm,
            'dilations': dilation,
            'groups': groups,
            'use_cudnn': use_cudnn,
            'data_format': conv2d_data_format
        }
        check_variable_and_dtype(x, 'input', ['float16', 'float32', 'float64'],
                                 'conv2d_transpose')
        helper = LayerHelper(op_type, **locals())
915
        dtype = helper.input_dtype(input_param_name='x')
916 917
        out = helper.create_variable_for_type_inference(dtype)
        outputs = {"Output": [out]}
918 919 920 921
        helper.append_op(type=op_type,
                         inputs=inputs,
                         outputs=outputs,
                         attrs=attrs)
922 923 924
        if bias is not None:
            out = nn.elementwise_add(out, bias, axis=channel_dim)

925
    out = squeeze(out, axis=[squeeze_axis])
926 927 928
    return out


929
def conv2d_transpose(x,
930 931 932
                     weight,
                     bias=None,
                     stride=1,
L
LielinJiang 已提交
933 934 935
                     padding=0,
                     output_padding=0,
                     dilation=1,
936
                     groups=1,
L
LielinJiang 已提交
937
                     output_size=None,
938
                     data_format='NCHW',
939
                     name=None):
940
    r"""
S
swtkiwi 已提交
941

942 943 944 945 946 947 948 949 950 951 952
    The convolution2D transpose layer calculates the output based on the input,
    filter, and dilations, strides, paddings. Input(Input) and output(Output)
    are in NCHW or NHWC format. Where N is batch size, C is the number of channels,
    H is the height of the feature, and W is the width of the feature.
    Parameters(dilations, strides, paddings) are two elements. These two elements
    represent height and width, respectively. 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.
L
LielinJiang 已提交
953
    See more detail in :ref:`api_nn_conv_ConvTranspose2d` .
954 955 956

    For each input :math:`X`, the equation is:

957
    ..  math::
958

959
        Out = \sigma (W \ast X + b)
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983

    Where:

    * :math:`X`: Input value, a 4-D Tensor with NCHW or NHWC format.
    * :math:`W`: Filter value, a 4-D Tensor with MCHW 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 4-D Tensor with data format 'NCHW' or 'NHWC', the shape of :math:`Out` and :math:`X` may be different.

    Example:

        - Input:

          Input shape: :math:`(N, C_{in}, H_{in}, W_{in})`

          Filter shape: :math:`(C_{in}, C_{out}, H_f, W_f)`

        - Output:

          Output shape: :math:`(N, C_{out}, H_{out}, W_{out})`

        Where

984
        ..  math::
985 986 987 988 989 990 991 992 993 994 995 996 997

           H^\prime_{out} &= (H_{in} - 1) * strides[0] - pad_height_top - pad_height_bottom + dilations[0] * (H_f - 1) + 1 \\\\
           W^\prime_{out} &= (W_{in} - 1) * strides[1] - pad_width_left - pad_width_right + dilations[1] * (W_f - 1) + 1 \\\\
           H_{out} &\in [ H^\prime_{out}, H^\prime_{out} + strides[0] ] \\\\
           W_{out} &\in [ W^\prime_{out}, W^\prime_{out} + strides[1] ]

    Note:
          The conv2d_transpose can be seen as the backward of the conv2d. For conv2d, 
          when stride > 1, conv2d 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:`H_{out} = H^\prime_{out}, W_{out} = W^\prime_{out}`; 
          else, the :math:`H_{out}` of the output size must between :math:`H^\prime_{out}` 
          and :math:`H^\prime_{out} + strides[0]`, and the :math:`W_{out}` of the output size must 
998
          between :math:`W^\prime_{out}` and :math:`W^\prime_{out} + strides[1]`.
999 1000

    Args:
L
LielinJiang 已提交
1001
        x(Tensor): 4-D Tensor with [N, C, H, W] or [N, H, W, C] format,
1002
            whose data type is float32 or float64.
L
LielinJiang 已提交
1003
        weight(Tensor): The convolution kernel, a Tensor with shape [C, M/g, kH, kW],
1004 1005
            where M is the number of output channels(filters), g is the number of groups,
            kH is the height of the kernel, and kW is the width of the kernel.
L
LielinJiang 已提交
1006 1007
        bias(Tensor, optional): The bias, a Tensor with shape [M, ].
        stride(int|list|tuple, optional): The stride size. It means the stride in transposed convolution. 
1008
            If stride is a list/tuple, it must contain two integers, (stride_height, stride_width). 
L
LielinJiang 已提交
1009
            Otherwise, stride_height = stride_width = stride. Default: stride = 1.
1010 1011 1012 1013 1014
        padding(str|int|list|tuple, optional): The padding size. It means the number of zero-paddings 
            on both sides for each dimension. If `padding` is a string, either 'VALID' or 
            'SAME' which is the padding algorithm. If padding size is a tuple or list,
            it could be in three forms: `[pad_height, pad_width]` or 
            `[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`,
L
LielinJiang 已提交
1015
            and when `data_format` is `"NCHW"`, `padding` can be in the form 
1016
            `[[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
L
LielinJiang 已提交
1017
            when `data_format` is `"NHWC"`, `padding` can be in the form 
1018 1019
            `[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
            Default: padding = 0.
L
LielinJiang 已提交
1020 1021
        output_padding(int|list|tuple, optional): Additional size added to one side
            of each dimension in the output shape. Default: 0.
C
cnn 已提交
1022
        groups(int, optional): The groups number of the Conv2D transpose layer. Inspired by
1023 1024 1025 1026 1027
            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.
1028
        dilation(int|list|tuple, optional): The dilation size. It means the spacing between the kernel points. 
1029
            If dilation is a list/tuple, it must contain two integers, (dilation_height, dilation_width). 
1030
            Otherwise, dilation_height = dilation_width = dilation. Default: dilation = 1.
L
LielinJiang 已提交
1031
        output_size(int|tuple|list, optional): The output image size. If output size is a
1032
            tuple/list, it must contain two integers, (image_height, image_width). None if use
1033
            filter_size(shape of weight), padding, and stride to calculate output_size.
1034 1035 1036 1037 1038 1039 1040 1041 1042
        data_format (str, optional): Specify the data format of the input, and the data format of the output 
            will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
            The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
            `[batch_size, input_channels, input_height, input_width]`.
        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:
1043
        A Tensor representing the conv2d_transpose, whose
1044
        data type is the same with input and shape is (num_batches, channels, out_h, 
L
LielinJiang 已提交
1045 1046
        out_w) or (num_batches, out_h, out_w, channels). The tensor variable storing 
        transposed convolution result.
1047 1048 1049 1050

    Raises:
        ValueError: If `data_format` is not "NCHW" or "NHWC".
        ValueError: If `padding` is a string, but not "SAME" or "VALID".
1051
        ValueError: If `padding` is a list/tuple, but the element corresponding to the input's batch size is not 0 
1052
            or the element corresponding to the input's channel is not 0.
L
LielinJiang 已提交
1053
        ValueError: If `output_size` and kernel_size are None at the same time.
1054 1055 1056 1057 1058 1059 1060 1061 1062
        ShapeError: If the input is not 4-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 2.
        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

L
LielinJiang 已提交
1063 1064
          import paddle
          import paddle.nn.functional as F
1065

1066 1067
          x_var = paddle.randn((2, 3, 8, 8), dtype='float32')
          w_var = paddle.randn((3, 6, 3, 3), dtype='float32')
1068

1069
          y_var = F.conv2d_transpose(x_var, w_var)
L
LielinJiang 已提交
1070
          y_np = y_var.numpy()
1071

1072
          print(y_np.shape)
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
          # (2, 6, 10, 10)
    """

    if data_format not in ['NCHW', 'NHWC']:
        raise ValueError(
            "Attr(data_format) of conv2d_transpose got wrong value: "
            "received {}, but only 'NCHW' or 'NHWC' are supported.".format(
                data_format))
    channel_last = (data_format == "NHWC")
    channel_dim = -1 if channel_last else 1
1083 1084 1085 1086
    if len(x.shape) != 4:
        raise ValueError(
            "Input x should be 4D tensor, but received x with the shape of {}".
            format(x.shape))
L
LielinJiang 已提交
1087
    num_channels = x.shape[channel_dim]
1088
    if num_channels < 0:
1089
        raise ValueError("The channel dimension of the input({}) "
1090
                         "should be defined. Received: {}.".format(
L
LielinJiang 已提交
1091
                             x.shape, num_channels))
1092 1093
    if groups <= 0:
        raise ValueError(
1094 1095
            "The groups of conv2d_transpose should be greater than 0. Received groups: {}"
            .format(groups))
1096 1097 1098 1099
    if num_channels % groups != 0:
        raise ValueError(
            "the channel of input must be divisible by groups,"
            "received: the channel of input is {}, the shape of input is {}"
L
LielinJiang 已提交
1100 1101 1102 1103
            ", the groups is {}".format(num_channels, x.shape, groups))

    cudnn_version = get_cudnn_version()

1104 1105
    use_cudnn = True if (is_compiled_with_cuda()
                         and cudnn_version is not None) else False
1106 1107 1108

    # update attrs
    padding, padding_algorithm = _update_padding_nd(padding, channel_last, 2)
1109 1110
    stride = convert_to_list(stride, 2, 'stride')
    dilation = convert_to_list(dilation, 2, 'dilation')
L
LielinJiang 已提交
1111

1112 1113 1114
    if output_size is None:
        output_size = []
    else:
L
LielinJiang 已提交
1115 1116 1117 1118
        if output_padding != 0:
            raise ValueError('output_padding option is mutually exclusive with '
                             'output_size')
        if isinstance(output_size, (list, tuple, int)):
1119
            output_size = convert_to_list(output_size, 2, 'output_size')
L
LielinJiang 已提交
1120 1121 1122 1123 1124 1125 1126
        else:
            raise ValueError(
                "output_size should be int, or list, tuple of ints")

    if output_padding == 0:
        output_padding = []
    else:
1127
        output_padding = convert_to_list(output_padding, 2, 'output_padding')
1128 1129 1130

    op_type = 'conv2d_transpose'
    num_filters = weight.shape[1]
L
LielinJiang 已提交
1131
    if (num_channels == groups and num_channels != 1 and num_filters == 1):
1132
        op_type = 'depthwise_conv2d_transpose'
L
LielinJiang 已提交
1133
        use_cudnn = False
1134

F
From00 已提交
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
    if in_dygraph_mode():
        final_state_op = _C_ops.final_state_conv2d_transpose if op_type == 'conv2d_transpose' else _C_ops.final_state_depthwise_conv2d_transpose
        pre_bias = final_state_op(x, weight, stride, padding, output_padding,
                                  output_size, padding_algorithm, groups,
                                  dilation, data_format)
        if bias is not None:
            return nn.elementwise_add(pre_bias, bias, axis=channel_dim)
        else:
            return pre_bias

    if _in_legacy_dygraph():
L
LielinJiang 已提交
1146 1147 1148 1149
        attrs = ('output_padding', output_padding, 'output_size', output_size,
                 'strides', stride, 'paddings', padding, 'padding_algorithm',
                 padding_algorithm, 'dilations', dilation, 'groups', groups,
                 'use_cudnn', use_cudnn, 'data_format', data_format)
W
wanghuancoder 已提交
1150
        pre_bias = getattr(_C_ops, op_type)(x, weight, *attrs)
1151
        if bias is not None:
L
LielinJiang 已提交
1152
            out = nn.elementwise_add(pre_bias, bias, axis=channel_dim)
1153
        else:
L
LielinJiang 已提交
1154
            out = pre_bias
1155
    else:
L
LielinJiang 已提交
1156
        inputs = {'Input': [x], 'Filter': [weight]}
1157
        attrs = {
L
LielinJiang 已提交
1158
            'output_padding': output_padding,
1159 1160 1161 1162 1163 1164 1165 1166 1167
            'output_size': output_size,
            'strides': stride,
            'paddings': padding,
            'padding_algorithm': padding_algorithm,
            'dilations': dilation,
            'groups': groups,
            'use_cudnn': use_cudnn,
            'data_format': data_format
        }
L
LielinJiang 已提交
1168
        check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
1169 1170
                                 'conv2d_transpose')
        helper = LayerHelper(op_type, **locals())
L
LielinJiang 已提交
1171
        pre_bias = helper.create_variable_for_type_inference(x.dtype)
1172
        outputs = {"Output": [pre_bias]}
1173 1174 1175 1176
        helper.append_op(type=op_type,
                         inputs=inputs,
                         outputs=outputs,
                         attrs=attrs)
L
LielinJiang 已提交
1177

1178
        if bias is not None:
L
LielinJiang 已提交
1179
            out = nn.elementwise_add(pre_bias, bias, axis=channel_dim)
1180
        else:
L
LielinJiang 已提交
1181 1182
            out = pre_bias

1183 1184 1185
    return out


1186
def conv3d(x,
1187 1188 1189
           weight,
           bias=None,
           stride=1,
1190
           padding=0,
1191 1192 1193 1194
           dilation=1,
           groups=1,
           data_format="NCDHW",
           name=None):
1195
    r"""
S
swtkiwi 已提交
1196

1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
    The convolution3D layer calculates the output based on the input, filter
    and strides, paddings, dilations, groups parameters. Input(Input) and
    Output(Output) are in NCDHW or NDHWC format. Where N is batch size C is the number of
    channels, D is the depth of the feature, H is the height of the feature,
    and W is the width of the feature. Convlution3D is similar with Convlution2D
    but adds one dimension(depth). 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:

1208
    ..  math::
1209

1210
        Out = \sigma (W \ast X + b)
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233

    In the above equation:

    * :math:`X`: Input value, a tensor with NCDHW or NDHWC format.
    * :math:`W`: Filter value, a tensor with MCDHW 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, the shape of :math:`Out` and :math:`X` may be different.

    Example:

        - Input:

          Input shape: :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`

          Filter shape: :math:`(C_{out}, C_{in}, D_f, H_f, W_f)`

        - Output:
          Output shape: :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`

        Where

1234
        ..  math::
1235 1236 1237 1238 1239 1240

            D_{out}&= \\frac{(D_{in} + 2 * paddings[0] - (dilations[0] * (D_f - 1) + 1))}{strides[0]} + 1 \\\\
            H_{out}&= \\frac{(H_{in} + 2 * paddings[1] - (dilations[1] * (H_f - 1) + 1))}{strides[1]} + 1 \\\\
            W_{out}&= \\frac{(W_{in} + 2 * paddings[2] - (dilations[2] * (W_f - 1) + 1))}{strides[2]} + 1

    Args:
1241
        x (Tensor): The input is 5-D Tensor with shape [N, C, D, H, W], the data 
1242
            type of input is float16 or float32 or float64.
1243
        weight (Tensor): The convolution kernel, a Tensor with shape [M, C/g, kD, kH, kW],
1244 1245
            where M is the number of filters(output channels), g is the number of groups,
            kD, kH, kW are the filter's depth, height and width respectively.
1246
        bias (Tensor, optional): The bias, a Tensor of shape [M, ].
1247
        stride (int|list|tuple, optional): The stride size. It means the stride in convolution. If stride is a 
1248
            list/tuple, it must contain three integers, (stride_depth, stride_height, stride_width). 
1249
            Otherwise, stride_depth = stride_height = stride_width = stride. Default: stride = 1.
1250
        padding (string|int|list|tuple, optional): The padding size. It means the number of zero-paddings 
1251 1252 1253 1254
            on both sides for each dimension. If `padding` is a string, either 'VALID' or
            'SAME' which is the padding algorithm. If padding size is a tuple or list,
            it could be in three forms: `[pad_depth, pad_height, pad_width]` or
            `[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`,
L
LielinJiang 已提交
1255
            and when `data_format` is `"NCDHW"`, `padding` can be in the form
1256
            `[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
L
LielinJiang 已提交
1257
            when `data_format` is `"NDHWC"`, `padding` can be in the form
1258 1259
            `[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
            Default: padding = 0.
1260
        dilation (int|list|tuple, optional): The dilation size. It means the spacing between the kernel points. 
1261
            If dilation is a list/tuple, it must contain three integers, (dilation_depth, dilation_height,
1262 1263
            dilation_width). Otherwise, dilation_depth = dilation_height = dilation_width = dilation. 
            Default: dilation = 1.
1264
        groups (int, optional): The groups number of the Conv3D Layer. According to grouped
1265 1266 1267 1268 1269
            convolution in Alex Krizhevsky's Deep CNN paper: 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
        data_format (str, optional): Specify the data format of the input, and the data format of the output 
1270 1271 1272 1273
            will be consistent with that of the input. An optional string from: `"NCDHW"`, `"NDHWC"`.
            The default is `"NCDHW"`. When it is `"NCDHW"`, the data is stored in the order of:
            `[batch_size, input_channels, input_depth, input_height, input_width]`.
        name(str|None, optional): For detailed information, please refer 
1274 1275 1276 1277
           to :ref:`api_guide_Name`. Usually name is no need to set and 
           None by default.

    Returns:
1278
        A Tensor representing the conv3d, whose data type is 
1279 1280
        the same with input. If act is None, the tensor storing the 
        convolution result, and if act is not None, the tensor storing 
1281 1282 1283 1284 1285
        convolution and non-linearity activation result.

    Examples:
        .. code-block:: python

1286 1287
            import paddle
            import paddle.nn.functional as F
1288

1289 1290
            x_var = paddle.randn((2, 3, 8, 8, 8), dtype='float32')
            w_var = paddle.randn((6, 3, 3, 3, 3), dtype='float32')
1291

1292 1293
            y_var = F.conv3d(x_var, w_var)
            y_np = y_var.numpy()
1294

1295
            print(y_np.shape)
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305
            # (2, 6, 6, 6, 6)
    """
    # entry check
    if data_format not in ["NCDHW", "NDHWC"]:
        raise ValueError(
            "Attr(data_format) should be 'NCDHW' or 'NDHWC'. Received "
            "Attr(data_format): {}.".format(data_format))

    channel_last = (data_format == "NDHWC")
    channel_dim = -1 if channel_last else 1
1306 1307 1308 1309
    if len(x.shape) != 5:
        raise ValueError(
            "Input x should be 5D tensor, but received x with the shape of {}".
            format(x.shape))
1310
    num_channels = x.shape[channel_dim]
1311 1312 1313
    num_filters = weight.shape[0]
    if num_channels < 0:
        raise ValueError(
1314
            "The channel dimension of the input({}) should be defined. "
1315
            "Received: {}.".format(x.shape, num_channels))
1316 1317
    if groups <= 0:
        raise ValueError(
1318 1319
            "The groups of conv3d should be greater than 0. Received groups: {}"
            .format(groups))
1320 1321 1322
    if num_channels % groups != 0:
        raise ValueError(
            "The number of input channels must be divisible by Attr(groups). "
1323 1324
            "Received: number of channels({}), groups({}).".format(
                num_channels, groups))
1325 1326 1327
    if num_filters % groups != 0:
        raise ValueError(
            "The number of filters must be divisible by Attr(groups). "
1328 1329
            "Received: number of filters({}), groups({}).".format(
                num_filters, groups))
1330

1331
    cudnn_version = get_cudnn_version()
1332 1333
    use_cudnn = True if (is_compiled_with_cuda()
                         and cudnn_version is not None) else False
1334

1335
    padding, padding_algorithm = _update_padding_nd(padding, channel_last, 3)
1336 1337
    stride = convert_to_list(stride, 3, 'stride')
    dilation = convert_to_list(dilation, 3, 'dilation')
1338 1339
    op_type = "conv3d"

L
LielinJiang 已提交
1340 1341 1342
    return _conv_nd(x, weight, bias, stride, padding, padding_algorithm,
                    dilation, groups, data_format, channel_dim, op_type,
                    use_cudnn, False, name)
1343 1344


1345
def conv3d_transpose(x,
1346 1347 1348
                     weight,
                     bias=None,
                     stride=1,
L
LielinJiang 已提交
1349 1350
                     padding=0,
                     output_padding=0,
1351
                     groups=1,
L
LielinJiang 已提交
1352 1353
                     dilation=1,
                     output_size=None,
1354
                     data_format='NCDHW',
1355
                     name=None):
1356
    r"""
L
LielinJiang 已提交
1357
    The convolution3d transpose layer calculates the output based on the input,
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
    filter, and dilations, strides, paddings. Input(Input) and output(Output)
    are in NCDHW or NDHWC format. Where N is batch size, C is the number of channels,
    D is the depth of the feature, H is the height of the feature, and W
    is the width of the feature. Parameters(dilations, strides, paddings) are
    two elements. These two elements represent height and width, respectively.
    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.
L
LielinJiang 已提交
1368
    See more detail in :ref:`api_nn_conv_ConvTranspose3d` .
1369 1370 1371

    For each input :math:`X`, the equation is:

1372
    ..  math::
1373

1374
        Out = \sigma (W \ast X + b)
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398

    In the above equation:

    * :math:`X`: Input value, a Tensor with NCDHW or NDHWC format.
    * :math:`W`: Filter value, a Tensor with MCDHW 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, the shape of :math:`Out` and :math:`X` may be different.

    Example:

        - Input:

          Input shape: :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`

          Filter shape: :math:`(C_{in}, C_{out}, D_f, H_f, W_f)`

        - Output:

          Output shape: :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`

        Where

1399
        ..  math::
1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416

           D^\prime_{out} &= (D_{in} - 1) * strides[0] - 2 * paddings[0] + dilations[0] * (D_f - 1) + 1 \\\\
           H^\prime_{out} &= (H_{in} - 1) * strides[1] - 2 * paddings[1] + dilations[1] * (H_f - 1) + 1 \\\\
           W^\prime_{out} &= (W_{in} - 1) * strides[2] - 2 * paddings[2] + dilations[2] * (W_f - 1) + 1 \\\\
           D_{out} &\in [ D^\prime_{out}, D^\prime_{out} + strides[0] ] \\\\
           H_{out} &\in [ H^\prime_{out}, H^\prime_{out} + strides[1] ] \\\\
           W_{out} &\in [ W^\prime_{out}, W^\prime_{out} + strides[2] ]

    Note:
          The conv3d_transpose can be seen as the backward of the conv3d. For conv3d, 
          when stride > 1, conv3d maps multiple input shape to the same output shape, 
          so for conv3d_transpose, when stride > 1, input shape maps multiple output shape.
          If output_size is None, :math:`H_{out} = H^\prime_{out}, :math:`H_{out} = \
          H^\prime_{out}, W_{out} = W^\prime_{out}`; else, the :math:`D_{out}` of the output 
          size must between :math:`D^\prime_{out}` and :math:`D^\prime_{out} + strides[0]`, 
          the :math:`H_{out}` of the output size must between :math:`H^\prime_{out}` 
          and :math:`H^\prime_{out} + strides[1]`, and the :math:`W_{out}` of the output size must 
1417
          between :math:`W^\prime_{out}` and :math:`W^\prime_{out} + strides[2]`.
1418 1419

    Args:
L
LielinJiang 已提交
1420
        x(Tensor): The input is 5-D Tensor with shape [N, C, D, H, W] or [N, D, H, W, C], the data type 
1421
            of input is float32 or float64.
L
LielinJiang 已提交
1422
        weight (Tensor): The convolution kernel, a Tensor with shape [C, M/g, kD, kH, kW],
1423 1424
            where M is the number of filters(output channels), g is the number of groups,
            kD, kH, kW are the filter's depth, height and width respectively.
L
LielinJiang 已提交
1425 1426
        bias (Tensor, optional): The bias, a Tensor of shape [M, ].
        stride(int|list|tuple, optional): The stride size. It means the stride in transposed convolution. 
1427
            If stride is a list/tuple, it must contain three integers, (stride_depth, stride_height, 
L
LielinJiang 已提交
1428 1429
            stride_width). Otherwise, stride_depth = stride_height = stride_width = stride. 
            Default: stride = 1.
1430 1431 1432 1433
        padding (string|int|list|tuple, optional): The padding size. It means the number of zero-paddings 
            on both sides for each dimension. If `padding` is a string, either 'VALID' or
            'SAME' which is the padding algorithm. If padding size is a tuple or list,
            it could be in three forms: `[pad_depth, pad_height, pad_width]` or
1434
            `[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`,
L
LielinJiang 已提交
1435
            and when `data_format` is `"NCDHW"`, `padding` can be in the form
1436
            `[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
L
LielinJiang 已提交
1437
            when `data_format` is `"NDHWC"`, `padding` can be in the form
1438 1439
            `[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
            Default: padding = 0.
L
LielinJiang 已提交
1440 1441
        output_padding(int|list|tuple, optional): Additional size added to one side
            of each dimension in the output shape. Default: 0.
C
cnn 已提交
1442
        groups(int, optional): The groups number of the Conv3D transpose layer. Inspired by
1443 1444 1445 1446 1447
            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
1448
        dilation(int|list|tuple, optional): The dilation size. It means the spacing between the kernel points. 
1449
            If dilation is a list/tuple, it must contain three integers, (dilation_depth, dilation_height, 
1450 1451
            dilation_width). Otherwise, dilation_depth = dilation_height = dilation_width = dilation. 
            Default: dilation = 1.
L
LielinJiang 已提交
1452
        output_size(int|list|tuple, optional): The output image size. If output size is a
1453
            list/tuple, it must contain three integers, (image_depth, image_height, image_width).
1454
            None if use filter_size(shape of weight), padding, and stride to calculate output_size.
1455 1456 1457 1458
        data_format (str, optional): Specify the data format of the input, and the data format of the output 
            will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
            The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
            `[batch_size, input_channels, input_height, input_width]`.
1459 1460 1461 1462 1463
        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:
1464
        A Tensor representing the conv3d_transpose, whose data
1465 1466 1467 1468 1469 1470 1471 1472
        type is the same with input and shape is (num_batches, channels, out_d, out_h, 
        out_w) or (num_batches, out_d, out_h, out_w, channels). 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 `data_format` is not "NCDHW" or "NDHWC".
        ValueError: If `padding` is a string, but not "SAME" or "VALID".
1473
        ValueError: If `padding` is a list/tuple, but the element corresponding to the input's batch size is not 0 
1474
            or the element corresponding to the input's channel is not 0.
L
LielinJiang 已提交
1475
        ValueError: If `output_size` and kernel_size are None at the same time.
1476 1477 1478 1479 1480 1481 1482 1483
        ShapeError: If the input is not 5-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 2.
        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
L
LielinJiang 已提交
1484 1485
          
          import paddle
1486 1487
          import paddle.nn.functional as F

1488 1489
          x_var = paddle.randn((2, 3, 8, 8, 8), dtype='float32')
          w_var = paddle.randn((3, 6, 3, 3, 3), dtype='float32')
1490

1491
          y_var = F.conv3d_transpose(x_var, w_var)
L
LielinJiang 已提交
1492
          y_np = y_var.numpy()
1493

1494
          print(y_np.shape)
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
          # (2, 6, 10, 10, 10)
    """
    # entry checks
    if data_format not in ["NCDHW", "NDHWC"]:
        raise ValueError(
            "Attr(data_format) should be 'NCDHW' or 'NDHWC'. Received "
            "Attr(data_format): {}.".format(data_format))

    channel_last = (data_format == "NDHWC")
    channel_dim = -1 if channel_last else 1
1505 1506 1507 1508
    if len(x.shape) != 5:
        raise ValueError(
            "Input x should be 5D tensor, but received x with the shape of {}".
            format(x.shape))
L
LielinJiang 已提交
1509
    num_channels = x.shape[channel_dim]
1510 1511 1512
    num_filters = weight.shape[1]
    if num_channels < 0:
        raise ValueError(
1513
            "The channel dimension of the input({}) should be defined. "
L
LielinJiang 已提交
1514
            "Received: {}.".format(x.shape, num_channels))
1515 1516
    if groups <= 0:
        raise ValueError(
1517 1518
            "The groups of conv3d_transpose should be greater than 0. Received groups: {}"
            .format(groups))
1519 1520 1521
    if num_channels % groups != 0:
        raise ValueError(
            "The number of input channels must be divisible by Attr(groups). "
1522 1523
            "Received: number of channels({}), groups({}).".format(
                num_channels, groups))
1524 1525

    padding, padding_algorithm = _update_padding_nd(padding, channel_last, 3)
1526 1527
    stride = convert_to_list(stride, 3, 'stride')
    dilation = convert_to_list(dilation, 3, 'dilation')
1528 1529 1530
    if output_size is None:
        output_size = []
    else:
L
LielinJiang 已提交
1531 1532 1533 1534
        if output_padding != 0:
            raise ValueError('output_padding option is mutually exclusive with '
                             'output_size')
        if isinstance(output_size, (list, tuple, int)):
1535
            output_size = convert_to_list(output_size, 3, 'output_size')
L
LielinJiang 已提交
1536 1537 1538 1539 1540 1541 1542
        else:
            raise ValueError(
                "output_size should be int, or list, tuple of ints")

    if output_padding == 0:
        output_padding = []
    else:
1543
        output_padding = convert_to_list(output_padding, 3, 'output_padding')
L
LielinJiang 已提交
1544 1545 1546 1547

    cudnn_version = get_cudnn_version()

    #TODO(LielinJiang): whether to use cudnn according to the version of cudnn
1548 1549
    use_cudnn = True if (is_compiled_with_cuda()
                         and cudnn_version is not None) else False
1550 1551 1552 1553

    op_type = 'conv3d_transpose'
    data_format_ = "NHWC" if channel_last else "NCHW"

F
From00 已提交
1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
    if in_dygraph_mode():
        pre_bias = _C_ops.final_state_conv3d_transpose(
            x, weight, stride, padding, output_padding, output_size,
            padding_algorithm, groups, dilation, data_format_)
        if bias is not None:
            return nn.elementwise_add(pre_bias, bias, axis=channel_dim)
        else:
            return pre_bias

    if _in_legacy_dygraph():
L
LielinJiang 已提交
1564 1565 1566 1567
        attrs = ('output_padding', output_padding, 'output_size', output_size,
                 'paddings', padding, "padding_algorithm", padding_algorithm,
                 'strides', stride, 'dilations', dilation, 'groups', groups,
                 'use_cudnn', use_cudnn, "data_format", data_format_)
W
wanghuancoder 已提交
1568
        pre_bias = getattr(_C_ops, op_type)(x, weight, *attrs)
1569
        if bias is not None:
L
LielinJiang 已提交
1570
            out = nn.elementwise_add(pre_bias, bias, axis=channel_dim)
1571
        else:
L
LielinJiang 已提交
1572
            out = pre_bias
1573
    else:
L
LielinJiang 已提交
1574
        inputs = {'Input': [x], 'Filter': [weight]}
1575
        attrs = {
L
LielinJiang 已提交
1576
            'output_padding': output_padding,
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
            'output_size': output_size,
            'paddings': padding,
            "padding_algorithm": padding_algorithm,
            'strides': stride,
            'dilations': dilation,
            'groups': groups,
            'use_cudnn': use_cudnn,
            "data_format": data_format_
        }
        helper = LayerHelper(op_type, **locals())
L
LielinJiang 已提交
1587 1588
        check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
                                 'conv3d')
1589

L
LielinJiang 已提交
1590
        pre_bias = helper.create_variable_for_type_inference(x.dtype)
1591 1592
        outputs = {"Output": [pre_bias]}

1593 1594 1595 1596
        helper.append_op(type=op_type,
                         inputs=inputs,
                         outputs=outputs,
                         attrs=attrs)
1597
        if bias is not None:
L
LielinJiang 已提交
1598
            out = nn.elementwise_add(pre_bias, bias, axis=channel_dim)
1599
        else:
L
LielinJiang 已提交
1600
            out = pre_bias
1601 1602

    return out