conv.py 73.2 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 21
from ...fluid.layers.utils import convert_to_list, _is_symmetric_padding, _contain_var, _convert_to_tensor_list
from ...fluid.data_feeder import check_variable_and_dtype, check_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
27
from paddle import _C_ops, _legacy_C_ops
F
From00 已提交
28 29
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
from paddle.fluid.framework import _non_static_mode
39

40 41
__all__ = []

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 82

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"
83 84
            padding = _exclude_padding_in_batch_and_channel(
                padding, channel_last)
85
            if _is_symmetric_padding(padding, num_dims):
86 87 88 89
                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"
90 91
            padding = convert_to_list(padding, 2 * num_dims, 'padding')
            if _is_symmetric_padding(padding, num_dims):
92 93 94 95
                padding = padding[0::2]
        # for padding like [pad_d1, pad_d2, ...]
        elif len(padding) == num_dims and isinstance(padding[0], int):
            padding_algorithm = "EXPLICIT"
96
            padding = convert_to_list(padding, num_dims, 'padding')
97 98 99 100 101
        else:
            raise ValueError("In valid padding: {}".format(padding))
    # for integer padding
    else:
        padding_algorithm = "EXPLICIT"
102
        padding = convert_to_list(padding, num_dims, 'padding')
103 104
    if not all([p >= 0 for p in padding]):
        raise ValueError(
105 106
            "Invalid padding, all value should be larger than or equal to 0, but received: {}"
            .format(padding))
107 108 109
    return padding, padding_algorithm


L
LielinJiang 已提交
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
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):

125
    # Due to the poor performance of NHWC, we transpose the input to NCHW.
H
hong 已提交
126
    if in_dygraph_mode() and op_type == "conv2d":
127 128 129
        pre_bias = _C_ops.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
133 134 135 136
            if isinstance(x, tuple):
                x = x[0]
            if isinstance(bias, tuple):
                bias = bias[0]
C
Chen Weihang 已提交
137
            if len(bias.shape) < len(x.shape):
138
                tmp_bias = _C_ops.reshape(
139
                    bias, [1 for i in range(channel_dim)] + bias.shape +
C
Chen Weihang 已提交
140
                    [1 for i in range(len(x.shape) - channel_dim - 1)])
141
                return _C_ops.add(pre_bias, tmp_bias)
C
Chen Weihang 已提交
142
            else:
143
                return _C_ops.add(pre_bias, bias)
H
hong 已提交
144 145
        else:
            return pre_bias
146 147

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

    if in_dygraph_mode() and op_type == "conv3d":
163 164 165
        pre_bias = _C_ops.conv3d(x, weight, stride, padding, padding_algorithm,
                                 groups, dilation, data_format, False, -1,
                                 False)
166 167 168
        if bias is not None:
            channel_dim = channel_dim + len(
                x.shape) if channel_dim < 0 else channel_dim
169
            tmp_bias = _C_ops.reshape(
170 171
                bias,
                bias.shape + [1 for i in range(len(x.shape) - channel_dim - 1)])
172
            return _C_ops.add(pre_bias, tmp_bias)
173 174 175
        else:
            return pre_bias

Z
zhiboniu 已提交
176
    if in_dynamic_mode():
L
LielinJiang 已提交
177 178 179 180 181
        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)
182
        pre_bias = getattr(_legacy_C_ops, op_type)(x, weight, *attrs)
L
LielinJiang 已提交
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205
        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]}
206 207 208 209
        helper.append_op(type=op_type,
                         inputs=inputs,
                         outputs=outputs,
                         attrs=attrs)
L
LielinJiang 已提交
210 211
        if bias is not None:
            out = helper.create_variable_for_type_inference(dtype)
212 213 214 215 216 217 218 219 220 221
            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 已提交
222 223 224 225 226
        else:
            out = pre_bias
    return out


W
whs 已提交
227 228 229 230 231 232 233 234 235
def conv1d(x,
           weight,
           bias=None,
           stride=1,
           padding=0,
           dilation=1,
           groups=1,
           data_format='NCL',
           name=None):
236
    r"""
W
whs 已提交
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
    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 已提交
252
        Out = \sigma (W \ast X + b)
W
whs 已提交
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278

    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 已提交
279
            L_{out} = \frac{(L_{in} + 2 * padding - (dilation * (L_f - 1) + 1))}{stride} + 1
W
whs 已提交
280 281

    Args:
282
        x (Tensor): The input is 3-D Tensor with shape [N, C, L], the data type
W
whs 已提交
283 284
            of input is float16 or float32 or float64.
        weight (Tensor): The convolution kernel with shape [M, C/g, K], where M is
285
            the number of output channels, g is the number of groups, K is the kernel's size.
W
whs 已提交
286
        bias (Tensor, optional): The bias with shape [M,]. Default: None.
287
        stride (int|list|tuple, optional): The stride size. If stride is a list/tuple, it must
W
whs 已提交
288
            contain one integers, (stride_size). Default: 1.
289
        padding(int|str|tuple|list, optional): The padding size. Padding could be in one of the following forms.
W
whs 已提交
290 291 292 293 294 295
            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.
296
        dilation (int|list|tuple, optional): The dilation size. If dilation is a list/tuple, it must
W
whs 已提交
297 298 299 300 301 302
            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.
303
        data_format (str, optional): Specify the data format of the input, and the data format of the output
W
whs 已提交
304 305 306
            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]`.
307 308
        name(str, optional): For detailed information, please refer
           to :ref:`api_guide_Name`. Usually name is no need to set and
W
whs 已提交
309 310 311
           None by default.

    Returns:
312
        A tensor representing the conv1d, whose data type is the
W
whs 已提交
313 314 315
        same with input.

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

W
whs 已提交
344 345 346 347 348
          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)
349

W
whs 已提交
350 351 352 353 354 355 356 357 358 359 360 361 362
          # [[[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 已提交
363
    channel_last = (data_format == "NLC")
W
whs 已提交
364 365
    channel_dim = -1 if channel_last else 1
    conv2d_data_format = "NHWC" if channel_last else "NCHW"
366 367 368 369
    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 已提交
370 371 372
    num_channels = x.shape[channel_dim]
    num_filters = weight.shape[0]
    if num_channels < 0:
373
        raise ValueError("The channel dimension of the input({}) "
W
whs 已提交
374 375
                         "should be defined. Received: {}.".format(
                             x.shape, num_channels))
376 377
    if groups <= 0:
        raise ValueError(
378 379
            "The groups of conv1d should be greater than 0. Received groups: {}"
            .format(groups))
W
whs 已提交
380 381 382 383 384 385 386 387 388 389 390 391 392
    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)
393

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

    l_type = "conv2d"
407 408

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

414
    # NPU only supports depthwise_conv2d when  "input_channel = output_channel = groups"
Z
zhiboniu 已提交
415
    if is_compiled_with_npu():
416 417 418 419 420
        if (num_channels == groups and num_channels == num_filters):
            l_type = 'depthwise_conv2d'
        else:
            l_type = 'conv2d'

421
    squeeze_aixs = -3 if channel_last else -2
422
    x = unsqueeze(x, axis=[squeeze_aixs])
423

424 425 426 427 428 429 430 431
    if in_dygraph_mode():
        out = getattr(_C_ops,
                      l_type)(x, weight, stride, padding, padding_algorithm,
                              groups, dilation, conv2d_data_format, False, -1,
                              False, False, use_cudnn)
        if bias is not None:
            out = nn.elementwise_add(out, bias, axis=channel_dim)
    elif _in_legacy_dygraph():
W
whs 已提交
432 433 434 435
        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)
436
        out = getattr(_legacy_C_ops, l_type)(x, weight, *attrs)
W
whs 已提交
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
        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())
455
        dtype = helper.input_dtype(input_param_name='x')
W
whs 已提交
456 457
        out = helper.create_variable_for_type_inference(dtype)
        outputs = {"Output": [out]}
458 459 460 461
        helper.append_op(type=l_type,
                         inputs=inputs,
                         outputs=outputs,
                         attrs=attrs)
W
whs 已提交
462 463
        if bias is not None:
            out = nn.elementwise_add(out, bias, axis=channel_dim)
464
    out = squeeze(out, axis=[squeeze_aixs])
W
whs 已提交
465 466 467
    return out


468
def conv2d(x,
469 470 471
           weight,
           bias=None,
           stride=1,
472
           padding=0,
473 474 475 476
           dilation=1,
           groups=1,
           data_format="NCHW",
           name=None):
477
    r"""
S
swtkiwi 已提交
478

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
    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:

496
    ..  math::
497

498
        Out = \sigma (W \ast X + b)
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522

    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

523
        ..  math::
524

525 526
            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
527 528

    Args:
529
        x (Tensor): The input is 4-D Tensor with shape [N, C, H, W], the data type
530
            of input is float16 or float32 or float64.
531
        weight (Tensor): The convolution kernel with shape [M, C/g, kH, kW], where M is
532
            the number of output channels, g is the number of groups, kH is the filter's
533
            height, kW is the filter's width.
534
        bias (Tensor, optional): The bias with shape [M,].
535 536
        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).
537
            Otherwise, stride_height = stride_width = stride. Default: stride = 1.
538 539 540 541
        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
542 543
            `[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],
544
            [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
L
LielinJiang 已提交
545
            when `data_format` is `"NHWC"`, `padding` can be in the form
546 547
            `[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
            Default: padding = 0.
548
        dilation (int|list|tuple): The dilation size. It means the spacing between the kernel
549 550
            points. If dilation is a list/tuple, it must contain two integers, (dilation_height,
            dilation_width). Otherwise, dilation_height = dilation_width = dilation.
551
            Default: dilation = 1.
C
cnn 已提交
552
        groups (int): The groups number of the Conv2D Layer. According to grouped
553 554 555 556
            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.
557
        data_format (str, optional): Specify the data format of the input, and the data format of the output
558 559 560
            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]`.
561 562
        name(str, optional): For detailed information, please refer
           to :ref:`api_guide_Name`. Usually name is no need to set and
563 564 565
           None by default.

    Returns:
566
        A Tensor representing the conv2d result, whose data type is the same with input.
567 568 569

    Raises:
        ValueError: If `data_format` is not "NCHW" or "NHWC".
570
        ValueError: If the channel dimension of the input is less than or equal to zero.
571
        ValueError: If `padding` is a string, but not "SAME" or "VALID".
572
        ValueError: If `padding` is a list/tuple, but the element corresponding to the input's batch size is not 0
573 574 575 576 577 578 579 580 581 582
            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

583
          import paddle
584 585
          import paddle.nn.functional as F

586 587
          x_var = paddle.randn((2, 3, 8, 8), dtype='float32')
          w_var = paddle.randn((6, 3, 3, 3), dtype='float32')
588 589 590 591

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

592 593 594 595 596 597 598 599 600 601
          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
602 603 604 605
    if len(x.shape) != 4:
        raise ValueError(
            "Input x should be 4D tensor, but received x with the shape of {}".
            format(x.shape))
606
    num_channels = x.shape[channel_dim]
607 608
    num_filters = weight.shape[0]
    if num_channels < 0:
609
        raise ValueError("The channel dimension of the input({}) "
610
                         "should be defined. Received: {}.".format(
611
                             x.shape, num_channels))
612 613
    if groups <= 0:
        raise ValueError(
614 615
            "The groups of conv2d should be greater than 0. Received groups: {}"
            .format(groups))
616 617 618 619
    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 {}"
620
            ", the groups is {}".format(num_channels, x.shape, groups))
621 622 623 624 625 626
    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))

627 628
    cudnn_version = get_cudnn_version()

629 630
    use_cudnn = True if (is_compiled_with_cuda()
                         and cudnn_version is not None) else False
631

632 633
    # update attrs
    padding, padding_algorithm = _update_padding_nd(padding, channel_last, 2)
634 635
    stride = convert_to_list(stride, 2, 'stride')
    dilation = convert_to_list(dilation, 2, 'dilation')
636 637

    l_type = "conv2d"
638 639
    if (num_channels == groups and num_channels != 1
            and num_filters % num_channels == 0):
640
        l_type = 'depthwise_conv2d'
Z
zhiboniu 已提交
641
        if is_compiled_with_rocm():
642 643 644
            use_cudnn = True
        else:
            use_cudnn = False
H
hong 已提交
645 646
    else:
        if in_dygraph_mode():
647 648 649
            pre_bias = _C_ops.conv2d(x, weight, stride, padding,
                                     padding_algorithm, groups, dilation,
                                     data_format, False, -1, False)
H
hong 已提交
650 651 652 653 654 655 656
            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"]
657

658
    # NPU only supports depthwise_conv2d when  "input_channel = output_channel = groups"
Z
zhiboniu 已提交
659
    if is_compiled_with_npu():
660 661 662 663 664
        if (num_channels == groups and num_channels == num_filters):
            l_type = 'depthwise_conv2d'
        else:
            l_type = 'conv2d'

665 666
    if (is_compiled_with_cuda() and get_flags("FLAGS_conv2d_disable_cudnn")
        ["FLAGS_conv2d_disable_cudnn"]):
667
        use_cudnn = False
668

L
LielinJiang 已提交
669 670 671
    return _conv_nd(x, weight, bias, stride, padding, padding_algorithm,
                    dilation, groups, data_format, channel_dim, l_type,
                    use_cudnn, use_mkldnn, name)
672 673


674
def conv1d_transpose(x,
675 676 677 678 679 680 681 682 683 684
                     weight,
                     bias=None,
                     stride=1,
                     padding=0,
                     output_padding=0,
                     groups=1,
                     dilation=1,
                     output_size=None,
                     data_format="NCL",
                     name=None):
685
    r"""
686 687 688 689 690 691 692 693 694 695 696 697 698 699
    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 已提交
700
        Out = \sigma (W \ast X + b)
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 726 727 728 729 730 731 732 733 734 735

    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}`
736
          and :math:`L^\prime_{out} + stride`.
737 738 739 740 741 742 743 744 745

    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.
746
            If stride is a list/tuple, it must contain one integer, `(stride_size)`.
747 748 749 750 751 752 753
            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.
754
             If it is a list/tuple, it must contain one integer. Default: 0.
755 756 757 758 759 760 761
        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.
762
            If dilation is a list/tuple, it must contain one integer, `(dilation_size)`.
763 764
            Default: dilation = 1.
        output_size(int|tuple|list, optional): The output image size. If output size is a
765
            tuple/list, it must contain one integer, `(feature_length)`. None if use
766
            filter_size(shape of weight), padding, and stride to calculate output_size.
767
        data_format (str, optional): Specify the data format of the input, and the data format of the output
768 769 770
            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]`.
771 772
        name(str, optional): For detailed information, please refer
           to :ref:`api_guide_Name`. Usually name is no need to set and
773 774 775 776 777 778 779 780 781 782 783
           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".
784
        ValueError: If `padding` is a list/tuple, but the element corresponding to the input's batch size is not 0
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
            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
802

803 804 805 806
          # shape: (1, 2, 4)
          x=np.array([[[4, 0, 9, 7],
                       [8, 0, 9, 2,]]]).astype(np.float32)
          # shape: (2, 1, 2)
W
whs 已提交
807
          w=np.array([[[7, 0]],
808 809 810
                      [[4, 2]]]).astype(np.float32)
          x_var = paddle.to_tensor(x)
          w_var = paddle.to_tensor(w)
811
          y_var = F.conv1d_transpose(x_var, w_var)
W
whs 已提交
812
          print(y_var)
813

814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
          # [[[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
829 830 831 832
    if len(x.shape) != 3:
        raise ValueError(
            "Input x should be 3D tensor, but received x with the shape of {}".
            format(x.shape))
833 834 835

    num_channels = x.shape[channel_dim]
    if num_channels < 0:
836
        raise ValueError("The channel dimension of the input({}) "
837 838
                         "should be defined. Received: {}.".format(
                             x.shape, num_channels))
839 840
    if groups <= 0:
        raise ValueError(
841 842
            "The groups of conv1d_transpose should be greater than 0. Received groups: {}"
            .format(groups))
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
    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(
858
            "The size of padding's dimension should 1 or 2. But got padding={}".
859 860
            format(padding))

861 862
    stride = convert_to_list(stride, 1, 'stride') + [1]
    dilation = convert_to_list(dilation, 1, 'dilation') + [1]
863 864 865 866

    if output_size is None:
        output_size = []
    else:
L
LielinJiang 已提交
867 868 869 870
        if output_padding != 0:
            raise ValueError('output_padding option is mutually exclusive with '
                             'output_size')
        if isinstance(output_size, (list, tuple, int)):
871
            output_size = convert_to_list(output_size, 1, 'output_size') + [1]
L
LielinJiang 已提交
872 873 874 875 876 877 878
        else:
            raise ValueError(
                "output_size should be int, or list, tuple of ints")

    if output_padding == 0:
        output_padding = []
    else:
879 880
        output_padding = convert_to_list(output_padding, 1,
                                         'output_padding') + [0]
L
LielinJiang 已提交
881 882 883 884

    if len(output_padding) > 0 and output_padding[0] > stride[0]:
        raise ValueError(
            "The size of output_padding should not be greater than stride."
885 886
            "But got output_padding={} and stride={}".format(
                output_padding[0], stride[0]))
887 888 889

    op_type = 'conv2d_transpose'
    num_filters = weight.shape[1]
890 891
    if (num_channels == groups and num_channels != 1 and num_filters == 1
            and not use_cudnn):
892 893 894 895 896 897
        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"

898 899
    x = unsqueeze(x, axis=[squeeze_axis])
    weight = unsqueeze(weight, axis=[-1])
900

901 902 903 904 905 906 907 908
    if in_dygraph_mode():
        out = getattr(_C_ops,
                      op_type)(x, weight, stride, padding, output_padding,
                               output_size, padding_algorithm, groups, dilation,
                               conv2d_data_format)
        if bias is not None:
            out = nn.elementwise_add(out, bias, axis=channel_dim)
    elif _in_legacy_dygraph():
L
LielinJiang 已提交
909 910 911 912
        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)
913
        out = getattr(_legacy_C_ops, op_type)(x, weight, *attrs)
914 915 916 917 918
        if bias is not None:
            out = nn.elementwise_add(out, bias, axis=channel_dim)
    else:
        inputs = {'Input': [x], 'Filter': [weight]}
        attrs = {
L
LielinJiang 已提交
919
            'output_padding': output_padding,
920 921 922 923 924 925 926 927 928 929 930 931
            '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())
932
        dtype = helper.input_dtype(input_param_name='x')
933 934
        out = helper.create_variable_for_type_inference(dtype)
        outputs = {"Output": [out]}
935 936 937 938
        helper.append_op(type=op_type,
                         inputs=inputs,
                         outputs=outputs,
                         attrs=attrs)
939 940 941
        if bias is not None:
            out = nn.elementwise_add(out, bias, axis=channel_dim)

942
    out = squeeze(out, axis=[squeeze_axis])
943 944 945
    return out


946
def conv2d_transpose(x,
947 948 949
                     weight,
                     bias=None,
                     stride=1,
L
LielinJiang 已提交
950 951 952
                     padding=0,
                     output_padding=0,
                     dilation=1,
953
                     groups=1,
L
LielinJiang 已提交
954
                     output_size=None,
955
                     data_format='NCHW',
956
                     name=None):
957
    r"""
S
swtkiwi 已提交
958

959 960 961 962 963 964 965 966 967 968 969
    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 已提交
970
    See more detail in :ref:`api_nn_conv_ConvTranspose2d` .
971 972 973

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

974
    ..  math::
975

976
        Out = \sigma (W \ast X + b)
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000

    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

1001
        ..  math::
1002 1003 1004 1005 1006 1007 1008

           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:
1009 1010
          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,
1011
          so for conv2d_transpose, when stride > 1, input shape maps multiple output shape.
1012 1013 1014
          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
1015
          between :math:`W^\prime_{out}` and :math:`W^\prime_{out} + strides[1]`.
1016 1017

    Args:
L
LielinJiang 已提交
1018
        x(Tensor): 4-D Tensor with [N, C, H, W] or [N, H, W, C] format,
1019
            whose data type is float32 or float64.
L
LielinJiang 已提交
1020
        weight(Tensor): The convolution kernel, a Tensor with shape [C, M/g, kH, kW],
1021 1022
            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 已提交
1023
        bias(Tensor, optional): The bias, a Tensor with shape [M, ].
1024 1025
        stride(int|list|tuple, optional): The stride size. It means the stride in transposed convolution.
            If stride is a list/tuple, it must contain two integers, (stride_height, stride_width).
L
LielinJiang 已提交
1026
            Otherwise, stride_height = stride_width = stride. Default: stride = 1.
1027 1028
        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
1029
            'SAME' which is the padding algorithm. If padding size is a tuple or list,
1030
            it could be in three forms: `[pad_height, pad_width]` or
1031
            `[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`,
1032
            and when `data_format` is `"NCHW"`, `padding` can be in the form
1033
            `[[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
1034
            when `data_format` is `"NHWC"`, `padding` can be in the form
1035 1036
            `[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
            Default: padding = 0.
L
LielinJiang 已提交
1037 1038
        output_padding(int|list|tuple, optional): Additional size added to one side
            of each dimension in the output shape. Default: 0.
C
cnn 已提交
1039
        groups(int, optional): The groups number of the Conv2D transpose layer. Inspired by
1040 1041 1042 1043 1044
            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.
1045 1046
        dilation(int|list|tuple, optional): The dilation size. It means the spacing between the kernel points.
            If dilation is a list/tuple, it must contain two integers, (dilation_height, dilation_width).
1047
            Otherwise, dilation_height = dilation_width = dilation. Default: dilation = 1.
L
LielinJiang 已提交
1048
        output_size(int|tuple|list, optional): The output image size. If output size is a
1049
            tuple/list, it must contain two integers, (image_height, image_width). None if use
1050
            filter_size(shape of weight), padding, and stride to calculate output_size.
1051
        data_format (str, optional): Specify the data format of the input, and the data format of the output
1052 1053 1054
            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]`.
1055 1056
        name(str, optional): For detailed information, please refer
           to :ref:`api_guide_Name`. Usually name is no need to set and
1057 1058 1059
           None by default.

    Returns:
1060
        A Tensor representing the conv2d_transpose, whose
1061 1062
        data type is the same with input and shape is (num_batches, channels, out_h,
        out_w) or (num_batches, out_h, out_w, channels). The tensor variable storing
L
LielinJiang 已提交
1063
        transposed convolution result.
1064 1065 1066 1067

    Raises:
        ValueError: If `data_format` is not "NCHW" or "NHWC".
        ValueError: If `padding` is a string, but not "SAME" or "VALID".
1068
        ValueError: If `padding` is a list/tuple, but the element corresponding to the input's batch size is not 0
1069
            or the element corresponding to the input's channel is not 0.
L
LielinJiang 已提交
1070
        ValueError: If `output_size` and kernel_size are None at the same time.
1071 1072 1073 1074 1075 1076 1077 1078 1079
        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 已提交
1080 1081
          import paddle
          import paddle.nn.functional as F
1082

1083 1084
          x_var = paddle.randn((2, 3, 8, 8), dtype='float32')
          w_var = paddle.randn((3, 6, 3, 3), dtype='float32')
1085

1086
          y_var = F.conv2d_transpose(x_var, w_var)
L
LielinJiang 已提交
1087
          y_np = y_var.numpy()
1088

1089
          print(y_np.shape)
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
          # (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
1100 1101 1102 1103
    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 已提交
1104
    num_channels = x.shape[channel_dim]
1105
    if num_channels < 0:
1106
        raise ValueError("The channel dimension of the input({}) "
1107
                         "should be defined. Received: {}.".format(
L
LielinJiang 已提交
1108
                             x.shape, num_channels))
1109 1110
    if groups <= 0:
        raise ValueError(
1111 1112
            "The groups of conv2d_transpose should be greater than 0. Received groups: {}"
            .format(groups))
1113 1114 1115 1116
    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 已提交
1117 1118 1119 1120
            ", the groups is {}".format(num_channels, x.shape, groups))

    cudnn_version = get_cudnn_version()

1121 1122
    use_cudnn = True if (is_compiled_with_cuda()
                         and cudnn_version is not None) else False
1123 1124 1125

    # update attrs
    padding, padding_algorithm = _update_padding_nd(padding, channel_last, 2)
1126 1127
    stride = convert_to_list(stride, 2, 'stride')
    dilation = convert_to_list(dilation, 2, 'dilation')
L
LielinJiang 已提交
1128

1129 1130 1131
    if output_size is None:
        output_size = []
    else:
L
LielinJiang 已提交
1132 1133 1134
        if output_padding != 0:
            raise ValueError('output_padding option is mutually exclusive with '
                             'output_size')
1135 1136 1137 1138 1139 1140
        if isinstance(output_size, (list, tuple)):
            if _contain_var(output_size):
                output_size = _convert_to_tensor_list(output_size)
            else:
                output_size = convert_to_list(output_size, 2, 'output_size')
        elif isinstance(output_size, int):
1141
            output_size = convert_to_list(output_size, 2, 'output_size')
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
        elif isinstance(output_size, Variable):
            check_dtype(output_size.dtype, 'output_size', ['int32', 'int64'],
                        'conv2d_transpose')
            if len(output_size.shape) == 1 and (output_size.shape[0] == 1
                                                or output_size.shape[0] == 2):
                if output_size.shape[0] == 1:
                    output_size = [output_size, output_size]
            else:
                raise ValueError(
                    "output_size must contain one or two integers.")
L
LielinJiang 已提交
1152 1153
        else:
            raise ValueError(
1154 1155
                "output_size should be int or Tensor or list, tuple of ints or Tensor"
            )
L
LielinJiang 已提交
1156 1157 1158 1159

    if output_padding == 0:
        output_padding = []
    else:
1160
        output_padding = convert_to_list(output_padding, 2, 'output_padding')
1161 1162 1163

    op_type = 'conv2d_transpose'
    num_filters = weight.shape[1]
L
LielinJiang 已提交
1164
    if (num_channels == groups and num_channels != 1 and num_filters == 1):
1165
        op_type = 'depthwise_conv2d_transpose'
L
LielinJiang 已提交
1166
        use_cudnn = False
1167

F
From00 已提交
1168
    if in_dygraph_mode():
1169 1170 1171
        op = _C_ops.conv2d_transpose if op_type == 'conv2d_transpose' else _C_ops.depthwise_conv2d_transpose
        pre_bias = op(x, weight, stride, padding, output_padding, output_size,
                      padding_algorithm, groups, dilation, data_format)
F
From00 已提交
1172 1173 1174 1175 1176 1177
        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 已提交
1178 1179 1180 1181
        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)
1182
        pre_bias = getattr(_legacy_C_ops, op_type)(x, weight, *attrs)
1183
        if bias is not None:
L
LielinJiang 已提交
1184
            out = nn.elementwise_add(pre_bias, bias, axis=channel_dim)
1185
        else:
L
LielinJiang 已提交
1186
            out = pre_bias
1187
    else:
L
LielinJiang 已提交
1188
        inputs = {'Input': [x], 'Filter': [weight]}
1189
        attrs = {
L
LielinJiang 已提交
1190
            'output_padding': output_padding,
1191 1192 1193 1194 1195 1196 1197 1198 1199
            '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 已提交
1200
        check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
1201 1202
                                 'conv2d_transpose')
        helper = LayerHelper(op_type, **locals())
L
LielinJiang 已提交
1203
        pre_bias = helper.create_variable_for_type_inference(x.dtype)
1204
        outputs = {"Output": [pre_bias]}
1205 1206 1207 1208
        helper.append_op(type=op_type,
                         inputs=inputs,
                         outputs=outputs,
                         attrs=attrs)
L
LielinJiang 已提交
1209

1210
        if bias is not None:
L
LielinJiang 已提交
1211
            out = nn.elementwise_add(pre_bias, bias, axis=channel_dim)
1212
        else:
L
LielinJiang 已提交
1213 1214
            out = pre_bias

1215 1216 1217
    return out


1218
def conv3d(x,
1219 1220 1221
           weight,
           bias=None,
           stride=1,
1222
           padding=0,
1223 1224 1225 1226
           dilation=1,
           groups=1,
           data_format="NCDHW",
           name=None):
1227
    r"""
S
swtkiwi 已提交
1228

1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
    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:

1240
    ..  math::
1241

1242
        Out = \sigma (W \ast X + b)
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265

    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

1266
        ..  math::
1267 1268 1269 1270 1271 1272

            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:
1273
        x (Tensor): The input is 5-D Tensor with shape [N, C, D, H, W], the data
1274
            type of input is float16 or float32 or float64.
1275
        weight (Tensor): The convolution kernel, a Tensor with shape [M, C/g, kD, kH, kW],
1276 1277
            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.
1278
        bias (Tensor, optional): The bias, a Tensor of shape [M, ].
1279 1280
        stride (int|list|tuple, optional): The stride size. It means the stride in convolution. If stride is a
            list/tuple, it must contain three integers, (stride_depth, stride_height, stride_width).
1281
            Otherwise, stride_depth = stride_height = stride_width = stride. Default: stride = 1.
1282
        padding (string|int|list|tuple, optional): The padding size. It means the number of zero-paddings
1283 1284 1285 1286
            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 已提交
1287
            and when `data_format` is `"NCDHW"`, `padding` can be in the form
1288
            `[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
L
LielinJiang 已提交
1289
            when `data_format` is `"NDHWC"`, `padding` can be in the form
1290 1291
            `[[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.
1292
        dilation (int|list|tuple, optional): The dilation size. It means the spacing between the kernel points.
1293
            If dilation is a list/tuple, it must contain three integers, (dilation_depth, dilation_height,
1294
            dilation_width). Otherwise, dilation_depth = dilation_height = dilation_width = dilation.
1295
            Default: dilation = 1.
1296
        groups (int, optional): The groups number of the Conv3D Layer. According to grouped
1297 1298 1299 1300
            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
1301
        data_format (str, optional): Specify the data format of the input, and the data format of the output
1302 1303 1304
            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]`.
1305 1306
        name(str|None, optional): For detailed information, please refer
           to :ref:`api_guide_Name`. Usually name is no need to set and
1307 1308 1309
           None by default.

    Returns:
1310 1311 1312
        A Tensor representing the conv3d, whose data type is
        the same with input. If act is None, the tensor storing the
        convolution result, and if act is not None, the tensor storing
1313 1314 1315 1316 1317
        convolution and non-linearity activation result.

    Examples:
        .. code-block:: python

1318 1319
            import paddle
            import paddle.nn.functional as F
1320

1321 1322
            x_var = paddle.randn((2, 3, 8, 8, 8), dtype='float32')
            w_var = paddle.randn((6, 3, 3, 3, 3), dtype='float32')
1323

1324 1325
            y_var = F.conv3d(x_var, w_var)
            y_np = y_var.numpy()
1326

1327
            print(y_np.shape)
1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
            # (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
1338 1339 1340 1341
    if len(x.shape) != 5:
        raise ValueError(
            "Input x should be 5D tensor, but received x with the shape of {}".
            format(x.shape))
1342
    num_channels = x.shape[channel_dim]
1343 1344 1345
    num_filters = weight.shape[0]
    if num_channels < 0:
        raise ValueError(
1346
            "The channel dimension of the input({}) should be defined. "
1347
            "Received: {}.".format(x.shape, num_channels))
1348 1349
    if groups <= 0:
        raise ValueError(
1350 1351
            "The groups of conv3d should be greater than 0. Received groups: {}"
            .format(groups))
1352 1353 1354
    if num_channels % groups != 0:
        raise ValueError(
            "The number of input channels must be divisible by Attr(groups). "
1355 1356
            "Received: number of channels({}), groups({}).".format(
                num_channels, groups))
1357 1358 1359
    if num_filters % groups != 0:
        raise ValueError(
            "The number of filters must be divisible by Attr(groups). "
1360 1361
            "Received: number of filters({}), groups({}).".format(
                num_filters, groups))
1362

1363
    cudnn_version = get_cudnn_version()
1364 1365
    use_cudnn = True if (is_compiled_with_cuda()
                         and cudnn_version is not None) else False
1366

1367
    padding, padding_algorithm = _update_padding_nd(padding, channel_last, 3)
1368 1369
    stride = convert_to_list(stride, 3, 'stride')
    dilation = convert_to_list(dilation, 3, 'dilation')
1370 1371
    op_type = "conv3d"

L
LielinJiang 已提交
1372 1373 1374
    return _conv_nd(x, weight, bias, stride, padding, padding_algorithm,
                    dilation, groups, data_format, channel_dim, op_type,
                    use_cudnn, False, name)
1375 1376


1377
def conv3d_transpose(x,
1378 1379 1380
                     weight,
                     bias=None,
                     stride=1,
L
LielinJiang 已提交
1381 1382
                     padding=0,
                     output_padding=0,
1383
                     groups=1,
L
LielinJiang 已提交
1384 1385
                     dilation=1,
                     output_size=None,
1386
                     data_format='NCDHW',
1387
                     name=None):
1388
    r"""
L
LielinJiang 已提交
1389
    The convolution3d transpose layer calculates the output based on the input,
1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
    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 已提交
1400
    See more detail in :ref:`api_nn_conv_ConvTranspose3d` .
1401 1402 1403

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

1404
    ..  math::
1405

1406
        Out = \sigma (W \ast X + b)
1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430

    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

1431
        ..  math::
1432 1433 1434 1435 1436 1437 1438 1439 1440

           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:
1441 1442
          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,
1443 1444
          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} = \
1445 1446 1447 1448
          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
1449
          between :math:`W^\prime_{out}` and :math:`W^\prime_{out} + strides[2]`.
1450 1451

    Args:
1452
        x(Tensor): The input is 5-D Tensor with shape [N, C, D, H, W] or [N, D, H, W, C], the data type
1453
            of input is float32 or float64.
L
LielinJiang 已提交
1454
        weight (Tensor): The convolution kernel, a Tensor with shape [C, M/g, kD, kH, kW],
1455 1456
            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 已提交
1457
        bias (Tensor, optional): The bias, a Tensor of shape [M, ].
1458 1459 1460
        stride(int|list|tuple, optional): The stride size. It means the stride in transposed convolution.
            If stride is a list/tuple, it must contain three integers, (stride_depth, stride_height,
            stride_width). Otherwise, stride_depth = stride_height = stride_width = stride.
L
LielinJiang 已提交
1461
            Default: stride = 1.
1462
        padding (string|int|list|tuple, optional): The padding size. It means the number of zero-paddings
1463 1464 1465
            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
1466
            `[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`,
L
LielinJiang 已提交
1467
            and when `data_format` is `"NCDHW"`, `padding` can be in the form
1468
            `[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
L
LielinJiang 已提交
1469
            when `data_format` is `"NDHWC"`, `padding` can be in the form
1470 1471
            `[[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 已提交
1472 1473
        output_padding(int|list|tuple, optional): Additional size added to one side
            of each dimension in the output shape. Default: 0.
C
cnn 已提交
1474
        groups(int, optional): The groups number of the Conv3D transpose layer. Inspired by
1475 1476 1477 1478 1479
            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
1480 1481 1482
        dilation(int|list|tuple, optional): The dilation size. It means the spacing between the kernel points.
            If dilation is a list/tuple, it must contain three integers, (dilation_depth, dilation_height,
            dilation_width). Otherwise, dilation_depth = dilation_height = dilation_width = dilation.
1483
            Default: dilation = 1.
L
LielinJiang 已提交
1484
        output_size(int|list|tuple, optional): The output image size. If output size is a
1485
            list/tuple, it must contain three integers, (image_depth, image_height, image_width).
1486
            None if use filter_size(shape of weight), padding, and stride to calculate output_size.
1487
        data_format (str, optional): Specify the data format of the input, and the data format of the output
1488 1489 1490
            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]`.
1491 1492
        name(str, optional): For detailed information, please refer
           to :ref:`api_guide_Name`. Usually name is no need to set and
1493 1494 1495
           None by default.

    Returns:
1496
        A Tensor representing the conv3d_transpose, whose data
1497 1498 1499
        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
1500 1501 1502 1503 1504
        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".
1505
        ValueError: If `padding` is a list/tuple, but the element corresponding to the input's batch size is not 0
1506
            or the element corresponding to the input's channel is not 0.
L
LielinJiang 已提交
1507
        ValueError: If `output_size` and kernel_size are None at the same time.
1508 1509 1510 1511 1512 1513 1514 1515
        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
1516

L
LielinJiang 已提交
1517
          import paddle
1518 1519
          import paddle.nn.functional as F

1520 1521
          x_var = paddle.randn((2, 3, 8, 8, 8), dtype='float32')
          w_var = paddle.randn((3, 6, 3, 3, 3), dtype='float32')
1522

1523
          y_var = F.conv3d_transpose(x_var, w_var)
L
LielinJiang 已提交
1524
          y_np = y_var.numpy()
1525

1526
          print(y_np.shape)
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536
          # (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
1537 1538 1539 1540
    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 已提交
1541
    num_channels = x.shape[channel_dim]
1542 1543 1544
    num_filters = weight.shape[1]
    if num_channels < 0:
        raise ValueError(
1545
            "The channel dimension of the input({}) should be defined. "
L
LielinJiang 已提交
1546
            "Received: {}.".format(x.shape, num_channels))
1547 1548
    if groups <= 0:
        raise ValueError(
1549 1550
            "The groups of conv3d_transpose should be greater than 0. Received groups: {}"
            .format(groups))
1551 1552 1553
    if num_channels % groups != 0:
        raise ValueError(
            "The number of input channels must be divisible by Attr(groups). "
1554 1555
            "Received: number of channels({}), groups({}).".format(
                num_channels, groups))
1556 1557

    padding, padding_algorithm = _update_padding_nd(padding, channel_last, 3)
1558 1559
    stride = convert_to_list(stride, 3, 'stride')
    dilation = convert_to_list(dilation, 3, 'dilation')
1560 1561 1562
    if output_size is None:
        output_size = []
    else:
L
LielinJiang 已提交
1563 1564 1565 1566
        if output_padding != 0:
            raise ValueError('output_padding option is mutually exclusive with '
                             'output_size')
        if isinstance(output_size, (list, tuple, int)):
1567
            output_size = convert_to_list(output_size, 3, 'output_size')
L
LielinJiang 已提交
1568 1569 1570 1571 1572 1573 1574
        else:
            raise ValueError(
                "output_size should be int, or list, tuple of ints")

    if output_padding == 0:
        output_padding = []
    else:
1575
        output_padding = convert_to_list(output_padding, 3, 'output_padding')
L
LielinJiang 已提交
1576 1577 1578 1579

    cudnn_version = get_cudnn_version()

    #TODO(LielinJiang): whether to use cudnn according to the version of cudnn
1580 1581
    use_cudnn = True if (is_compiled_with_cuda()
                         and cudnn_version is not None) else False
1582 1583 1584 1585

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

F
From00 已提交
1586
    if in_dygraph_mode():
1587 1588 1589 1590
        pre_bias = _C_ops.conv3d_transpose(x, weight, stride, padding,
                                           output_padding, output_size,
                                           padding_algorithm, groups, dilation,
                                           data_format_)
F
From00 已提交
1591 1592 1593 1594 1595 1596
        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 已提交
1597 1598 1599 1600
        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_)
1601
        pre_bias = getattr(_legacy_C_ops, op_type)(x, weight, *attrs)
1602
        if bias is not None:
L
LielinJiang 已提交
1603
            out = nn.elementwise_add(pre_bias, bias, axis=channel_dim)
1604
        else:
L
LielinJiang 已提交
1605
            out = pre_bias
1606
    else:
L
LielinJiang 已提交
1607
        inputs = {'Input': [x], 'Filter': [weight]}
1608
        attrs = {
L
LielinJiang 已提交
1609
            'output_padding': output_padding,
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
            '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 已提交
1620 1621
        check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
                                 'conv3d')
1622

L
LielinJiang 已提交
1623
        pre_bias = helper.create_variable_for_type_inference(x.dtype)
1624 1625
        outputs = {"Output": [pre_bias]}

1626 1627 1628 1629
        helper.append_op(type=op_type,
                         inputs=inputs,
                         outputs=outputs,
                         attrs=attrs)
1630
        if bias is not None:
L
LielinJiang 已提交
1631
            out = nn.elementwise_add(pre_bias, bias, axis=channel_dim)
1632
        else:
L
LielinJiang 已提交
1633
            out = pre_bias
1634 1635

    return out