conv_transpose_op.cc 22.6 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
C
chengduoZH 已提交
2

L
Luo Tao 已提交
3 4 5
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
C
chengduoZH 已提交
6

L
Luo Tao 已提交
7
    http://www.apache.org/licenses/LICENSE-2.0
C
chengduoZH 已提交
8

L
Luo Tao 已提交
9 10 11 12 13
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. */
C
chengduoZH 已提交
14

Y
Yi Wang 已提交
15
#include "paddle/fluid/operators/conv_transpose_op.h"
S
sneaxiy 已提交
16
#include <memory>
S
Siddharth Goyal 已提交
17 18
#include <string>
#include <vector>
19
#include "paddle/fluid/framework/data_layout.h"
20
#include "paddle/fluid/platform/cudnn_workspace_helper.h"
C
chengduoZH 已提交
21

J
Jacek Czaja 已提交
22 23 24 25
#ifdef PADDLE_WITH_MKLDNN
#include "paddle/fluid/platform/mkldnn_helper.h"
#endif

C
chengduoZH 已提交
26 27 28
namespace paddle {
namespace operators {

29 30
using DataLayout = framework::DataLayout;

C
chengduoZH 已提交
31
void ConvTransposeOp::InferShape(framework::InferShapeContext* ctx) const {
32 33 34 35 36 37
  PADDLE_ENFORCE_EQ(ctx->HasInput("Input"), true,
                    "Input(Input) of ConvTransposeOp should not be null.");
  PADDLE_ENFORCE_EQ(ctx->HasInput("Filter"), true,
                    "Input(Filter) of ConvTransposeOp should not be null.");
  PADDLE_ENFORCE_EQ(ctx->HasOutput("Output"), true,
                    "Output(Output) of ConvTransposeOp should not be null.");
C
chengduoZH 已提交
38 39 40

  auto in_dims = ctx->GetInputDim("Input");
  auto filter_dims = ctx->GetInputDim("Filter");
41 42
  std::vector<int> output_size =
      ctx->Attrs().Get<std::vector<int>>("output_size");
C
chengduoZH 已提交
43 44
  std::vector<int> strides = ctx->Attrs().Get<std::vector<int>>("strides");
  std::vector<int> paddings = ctx->Attrs().Get<std::vector<int>>("paddings");
C
chengduoZH 已提交
45
  std::vector<int> dilations = ctx->Attrs().Get<std::vector<int>>("dilations");
Y
Yibing Liu 已提交
46
  int groups = ctx->Attrs().Get<int>("groups");
47 48
  std::string padding_algorithm =
      ctx->Attrs().Get<std::string>("padding_algorithm");
49 50
  const std::string data_layout_str =
      ctx->Attrs().Get<std::string>("data_format");
51 52 53
  const DataLayout data_layout =
      this->IsMKLDNNType() ? DataLayout::kNCHW
                           : framework::StringToDataLayout(data_layout_str);
C
chengduoZH 已提交
54

55
  PADDLE_ENFORCE_EQ(in_dims.size() == 4 || in_dims.size() == 5, true,
56 57 58 59 60 61 62 63 64 65 66 67
                    "ShapeError: input of Op(conv_transpose) should be 4-D or "
                    "5-D Tensor. But received: %u-D Tensor, "
                    "the shape of input is [%s]",
                    in_dims.size(), in_dims);
  PADDLE_ENFORCE_EQ(
      in_dims.size(), filter_dims.size(),
      "ShapeError: the input's dimension size and filter's dimension size of "
      "Op (conv_transpose) should be equal. But received: the shape of input "
      "is [%s], the dimension size of input is [%d], the shape of filter is "
      "[%s],  the dimension size of filter is [%d]. ",
      in_dims, in_dims.size(), filter_dims, filter_dims.size());
  int in_sub_stride_size = in_dims.size() - strides.size();
68 69
  PADDLE_ENFORCE_EQ(
      in_dims.size() - strides.size(), 2U,
70 71 72 73 74
      "ShapeError: the input's dimension size minus Attr(stride)'s size must "
      "be euqal to 2 for Op(conv_transpose). But received: [%d], the "
      "input's dimension size is [%d], the shape of input "
      "is [%s], the Attr(stride)'s size is [%d].",
      in_sub_stride_size, in_dims.size(), in_dims, strides.size());
75
  if (output_size.size())
76 77 78 79
    PADDLE_ENFORCE_EQ(
        output_size.size(), strides.size(),
        "The Attr(output_size) and Attr(stride) of Op(conv_transpose) "
        "should be the same.");
C
chengduoZH 已提交
80

81
  const int64_t C =
82
      (data_layout != DataLayout::kNHWC ? in_dims[1]
83 84 85
                                        : in_dims[in_dims.size() - 1]);
  PADDLE_ENFORCE_EQ(
      C, filter_dims[0],
86 87 88 89 90 91
      "ShapeError: The number of input channels should be equal to filter "
      "channels for Op(conv_transpose). But received: the input's channels is "
      "[%d], the shape of input is [%s], the filter's channels is [%d], the "
      "shape of filter is [%s]. The data_format is %s."
      "The error may come from wrong data_format setting.",
      C, in_dims, filter_dims[0], filter_dims, data_layout_str);
92 93

  framework::DDim in_data_dims;
94
  if (data_layout != DataLayout::kNHWC) {
95 96 97 98 99 100 101 102 103 104 105
    in_data_dims = framework::slice_ddim(in_dims, 2, in_dims.size());
  } else {
    in_data_dims = framework::slice_ddim(in_dims, 1, in_dims.size() - 1);
  }
  framework::DDim filter_data_dims =
      framework::slice_ddim(filter_dims, 2, filter_dims.size());
  std::vector<int> ksize = framework::vectorize<int>(filter_data_dims);
  UpdatePaddingAndDilation(&paddings, &dilations, padding_algorithm,
                           in_data_dims, strides, ksize);

  std::vector<int64_t> output_shape({in_dims[0]});
106
  if (data_layout != DataLayout::kNHWC) {
107 108
    output_shape.push_back(filter_dims[1] * groups);
  }
109
  const int offset = (data_layout != DataLayout::kNHWC ? 2 : 1);
C
chengduoZH 已提交
110
  for (size_t i = 0; i < strides.size(); ++i) {
C
chengduoZH 已提交
111
    auto filter_extent = dilations[i] * (filter_dims[i + 2] - 1) + 1;
112 113
    auto infer_shape = (in_dims[i + offset] - 1) * strides[i] -
                       paddings[2 * i] - paddings[2 * i + 1] + filter_extent;
114
    if (output_size.size()) {
115 116 117 118 119
      PADDLE_ENFORCE_EQ((output_size[i] >= infer_shape &&
                         output_size[i] < infer_shape + strides[i]),
                        true,
                        "output_size of Op(ConvTransposeOp) should be "
                        "in appropriate range.");
120 121 122 123
      output_shape.push_back(output_size[i]);
    } else {
      output_shape.push_back(infer_shape);
    }
C
chengduoZH 已提交
124
  }
125 126 127
  if (data_layout == DataLayout::kNHWC) {
    output_shape.push_back(filter_dims[1] * groups);
  }
C
chengduoZH 已提交
128
  ctx->SetOutputDim("Output", framework::make_ddim(output_shape));
C
chengduoZH 已提交
129 130
}

131 132
framework::OpKernelType ConvTransposeOp::GetExpectedKernelType(
    const framework::ExecutionContext& ctx) const {
J
Jacek Czaja 已提交
133
  framework::LibraryType library_{framework::LibraryType::kPlain};
134
  framework::DataLayout layout_ = framework::DataLayout::kAnyLayout;
135
  bool use_cudnn = ctx.Attr<bool>("use_cudnn");
C
chengduoZH 已提交
136
  use_cudnn &= platform::is_gpu_place(ctx.GetPlace());
C
chengduoZH 已提交
137 138 139 140
#ifdef PADDLE_WITH_CUDA
  if (platform::is_gpu_place(ctx.GetPlace())) {
    auto& dev_ctx = ctx.template device_context<platform::CUDADeviceContext>();
    use_cudnn &= dev_ctx.cudnn_handle() != nullptr;
J
Jacek Czaja 已提交
141 142 143
    if (use_cudnn) {
      library_ = framework::LibraryType::kCUDNN;
    }
C
chengduoZH 已提交
144 145
  }
#endif
J
Jacek Czaja 已提交
146 147 148 149 150
#ifdef PADDLE_WITH_MKLDNN
  if (library_ == framework::LibraryType::kPlain &&
      platform::CanMKLDNNBeUsed(ctx)) {
    library_ = framework::LibraryType::kMKLDNN;
    layout_ = framework::DataLayout::kMKLDNN;
151
  }
J
Jacek Czaja 已提交
152
#endif
153

154 155 156
  return framework::OpKernelType(
      OperatorWithKernel::IndicateVarDataType(ctx, "Input"), ctx.GetPlace(),
      layout_, library_);
157 158
}

159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
framework::OpKernelType ConvTransposeOp::GetKernelTypeForVar(
    const std::string& var_name, const Tensor& tensor,
    const framework::OpKernelType& expected_kernel_type) const {
#ifdef PADDLE_WITH_MKLDNN
  // Only input require reshaping, weights and
  // bias are having shape in NCHW order
  if ((var_name == "Input") &&
      (expected_kernel_type.data_layout_ == framework::DataLayout::kMKLDNN) &&
      (tensor.layout() != framework::DataLayout::kMKLDNN)) {
    auto attrs = Attrs();
    auto ar = paddle::framework::AttrReader(attrs);
    const std::string data_format = ar.Get<std::string>("data_format");
    auto dl = framework::StringToDataLayout(data_format);
    // Some models may have intentionally set "AnyLayout" for pool
    // op. Treat this as NCHW (default data_format value)
    if (dl != framework::DataLayout::kAnyLayout) {
      return framework::OpKernelType(
          expected_kernel_type.data_type_, tensor.place(),
          framework::StringToDataLayout(data_format));
    }
  }
#endif
  return framework::OpKernelType(expected_kernel_type.data_type_,
                                 tensor.place(), tensor.layout());
}

Y
Yu Yang 已提交
185
void Conv2DTransposeOpMaker::Make() {
J
Jacek Czaja 已提交
186 187 188 189
  AddAttr<bool>("is_test",
                "(bool, default false) Set to true for inference only, false "
                "for training. Some layers may run faster when this is true.")
      .SetDefault(false);
190 191 192 193 194
  AddInput("Input",
           "(Tensor) The input tensor of convolution transpose operator. "
           "The format of input tensor is NCHW or NHWC. Where N is batch size, "
           "C is the number of input channels, H is the height of the feature, "
           "and W is the width of the feature.");
C
chengduoZH 已提交
195 196 197 198 199 200 201 202
  AddInput(
      "Filter",
      "(Tensor) The filter tensor of convolution transpose operator. "
      "The format of the filter tensor is MCHW, where M is the number of "
      "input feature channels, C is the number of "
      "output feature channels,"
      "H is the height of the filter, and W is the width of the filter. "
      "We enforce groups number == 1 in the convolution transpose scenario.");
203 204 205 206 207 208
  AddInput("Bias",
           "(Tensor) Bias to be added to each output of filter application."
           "The format of output tensor is X (one-dimensional) of size equal"
           "to the number of output channels. Only used with MKL-DNN.")
      .AsDispensable();

C
chengduoZH 已提交
209
  AddOutput("Output",
C
chengduoZH 已提交
210
            "(Tensor) The output tensor of convolution transpose operator. "
211
            "The format of output tensor is the same as input tensor.");
212 213 214 215
  AddAttr<std::vector<int>>("output_size",
                            "(vector<int> default: []), the "
                            "size of the output tensor")
      .SetDefault({});
Y
Yibing Liu 已提交
216 217 218 219
  AddAttr<int>("groups",
               "(int default:1), the groups number of the convolution "
               "transpose operator. ")
      .SetDefault(1);
C
chengduoZH 已提交
220 221 222 223 224
  AddAttr<std::vector<int>>("dilations",
                            "(vector<int> default:{1, 1}), the "
                            "dilations(h_dilation, w_dilation) of convolution "
                            "transpose operator.")
      .SetDefault({1, 1});
C
chengduoZH 已提交
225 226
  AddAttr<std::vector<int>>(
      "strides",
C
chengduoZH 已提交
227
      "(vector<int> default:{1, 1}), the strides(h_stride, w_stride) of "
228
      "convolution transpose operator.")
C
chengduoZH 已提交
229
      .SetDefault({1, 1});
C
chengduoZH 已提交
230 231
  AddAttr<std::vector<int>>(
      "paddings",
C
chengduoZH 已提交
232
      "(vector<int> default:{0, 0}), the paddings(h_pad, w_pad) of convolution "
C
chengduoZH 已提交
233
      "transpose operator.")
C
chengduoZH 已提交
234
      .SetDefault({0, 0});
235 236 237 238
  AddAttr<bool>(
      "use_cudnn",
      "(bool, default false) Only used in cudnn kernel, need install cudnn")
      .SetDefault(false);
J
Jacek Czaja 已提交
239 240 241 242 243
  AddAttr<bool>("use_mkldnn",
                "(bool, default false) Only used in mkldnn kernel")
      .SetDefault(false);
  AddAttr<bool>("fuse_relu", "(bool, default false) Only used in mkldnn kernel")
      .SetDefault(false);
244 245 246 247 248 249 250 251
  AddAttr<std::string>("fuse_activation",
                       "(string, default \"\") Only used in mkldnn kernel")
      .SetDefault("");
  AddAttr<float>("fuse_alpha",
                 "(float, default 0.0) Only used in mkldnn kernel")
      .SetDefault(0.0f);
  AddAttr<float>("fuse_beta", "(float, default 0.0) Only used in mkldnn kernel")
      .SetDefault(0.0f);
252 253 254 255
  AddAttr<std::string>(
      "data_format",
      "(string, default NCHW) Only used in "
      "An optional string from: \"NHWC\", \"NCHW\". "
256 257 258 259 260 261 262 263 264
      "Specify that the data format of the input and output data is "
      "channel_first or channel_last.")
      .SetDefault("NCHW");
  AddAttr<std::string>(
      "padding_algorithm",
      "(string, default \"EXPLICIT\") An optional string from: \"EXPLICIT\","
      "\"SAME\",\"VALID\". Set to \"EXPLICIT\" for explicit padding. "
      "Set to \"SAME\" or \"VALID\" for algorithm of padding. ")
      .SetDefault("EXPLICIT");
265 266 267 268 269
  AddAttr<int>("workspace_size_MB",
               "Used in cudnn kernel only. workspace size for cudnn, in MB, "
               "workspace is a section of GPU memory which will be "
               "allocated/freed each time the operator runs, larger "
               "workspace size can increase performance but also requires "
T
tianshuo78520a 已提交
270
               "better hardward. This size should be carefully set.")
271
      .SetDefault(platform::GetDefaultConvWorkspaceSizeLimitMB());
C
chengduoZH 已提交
272
  AddComment(R"DOC(
C
chengduoZH 已提交
273 274
Convolution2D Transpose Operator.

C
chengduoZH 已提交
275
The convolution transpose operation calculates the output based on the input, filter
C
chengduoZH 已提交
276
and dilations, strides, paddings, groups parameters. The size of each dimension of the
C
chengduoZH 已提交
277
parameters is checked in the infer-shape.
278
Input(Input) and output(Output) are in NCHW or NHWC format. Where N is batchsize, C is the
C
chengduoZH 已提交
279 280 281 282 283 284
number of channels, H is the height of the feature, and W is the width of the feature.
Filter(Input) is in MCHW format. Where M is the number of input feature channels,
C is the number of output feature channels, H is the height of the filter,
and W is the width of the filter.
Parameters(strides, paddings) are two elements. These two elements represent height
and width, respectively.
C
chengduoZH 已提交
285
The input(X) size and output(Out) size may be different.
C
chengduoZH 已提交
286

Y
update  
yi.wu 已提交
287
For an example:
C
chengduoZH 已提交
288
  Input:
C
chengduoZH 已提交
289 290
       Input shape: $(N, C_{in}, H_{in}, W_{in})$
       Filter shape: $(C_{in}, C_{out}, H_f, W_f)$
C
chengduoZH 已提交
291
  Output:
C
chengduoZH 已提交
292 293 294
       Output shape: $(N, C_{out}, H_{out}, W_{out})$
  Where
  $$
295 296
       H_{out} = (H_{in} - 1) * strides[0] - pad_height_top - pad_height_bottom  + dilations[0] * (H_f - 1) + 1 \\
       W_{out} = (W_{in} - 1) * strides[1] - pad_width_left  - pad_width_right + dilations[1] * (W_f - 1) + 1
C
chengduoZH 已提交
297
  $$
C
chengduoZH 已提交
298 299 300
)DOC");
}

Y
Yu Yang 已提交
301
void Conv3DTransposeOpMaker::Make() {
302 303 304 305 306 307
  AddInput(
      "Input",
      "(Tensor) The input tensor of convolution transpose operator."
      "The format of input tensor is NCDHW or NDHWC. 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.");
C
chengduoZH 已提交
308 309
  AddInput("Filter",
           "(Tensor) The filter tensor of convolution transpose operator."
C
chengduoZH 已提交
310 311 312
           "The format of the filter tensor is MCDHW, where M is the number of "
           "input feature channels, C is the number of "
           "output feature channels, D "
C
chengduoZH 已提交
313 314
           "is the depth of the filter, H is the height of the filter, and "
           "W is the width of the filter."
C
chengduoZH 已提交
315
           "We enforce groups number == 1 and padding == 0 in "
C
chengduoZH 已提交
316
           "the convolution3d transpose scenario.");
C
chengduoZH 已提交
317 318
  AddOutput("Output",
            "(Tensor) The output tensor of convolution transpose operator."
319
            "The format of output tensor is the same as input tensor."
C
chengduoZH 已提交
320
            "Where N is batch size, C is "
C
chengduoZH 已提交
321 322
            "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.");
323 324 325 326
  AddAttr<std::vector<int>>("output_size",
                            "(vector<int> default: []), the "
                            "size of the output tensor")
      .SetDefault({});
C
chengduoZH 已提交
327 328 329 330 331 332
  AddAttr<std::vector<int>>(
      "dilations",
      "(vector<int> default:{1, 1, 1}), the "
      "dilations(d_dilation,h_dilation, w_dilation) of convolution "
      "transpose operator.")
      .SetDefault({1, 1, 1});
C
chengduoZH 已提交
333
  AddAttr<std::vector<int>>("strides",
C
chengduoZH 已提交
334
                            "(vector<int> default:{1, 1, 1}), the "
335
                            "strides{d_stride, h_stride, w_stride} of "
C
chengduoZH 已提交
336
                            "convolution transpose operator.")
C
chengduoZH 已提交
337
      .SetDefault({1, 1, 1});
C
chengduoZH 已提交
338
  AddAttr<std::vector<int>>("paddings",
C
chengduoZH 已提交
339
                            "(vector<int> default:{0, 0, 0}), paddings(d_pad, "
C
chengduoZH 已提交
340
                            "h_pad, w_pad) of convolution transpose operator.")
C
chengduoZH 已提交
341
      .SetDefault({0, 0, 0});
342 343 344 345
  AddAttr<int>("groups",
               "(int default:1), the groups number of the convolution3d "
               "transpose operator. ")
      .SetDefault(1);
346 347 348 349
  AddAttr<bool>(
      "use_cudnn",
      "(bool, default false) Only used in cudnn kernel, need install cudnn")
      .SetDefault(false);
350 351 352
  AddAttr<bool>("use_mkldnn",
                "(bool, default false) Only used in mkldnn kernel")
      .SetDefault(false);
353 354 355 356
  AddAttr<std::string>(
      "data_format",
      "(string, default NCHW) Only used in "
      "An optional string from: \"NHWC\", \"NCHW\". "
357 358 359 360 361 362 363 364 365
      "Specify that the data format of the input and output data is "
      "channel_first or channel_last.")
      .SetDefault("NCHW");
  AddAttr<std::string>(
      "padding_algorithm",
      "(string, default \"EXPLICIT\") An optional string from: \"EXPLICIT\","
      "\"SAME\",\"VALID\". Set to \"EXPLICIT\" for explicit padding. "
      "Set to \"SAME\" or \"VALID\" for algorithm of padding. ")
      .SetDefault("EXPLICIT");
366 367 368 369 370
  AddAttr<int>("workspace_size_MB",
               "Used in cudnn kernel only. workspace size for cudnn, in MB, "
               "workspace is a section of GPU memory which will be "
               "allocated/freed each time the operator runs, larger "
               "workspace size can increase performance but also requires "
T
tianshuo78520a 已提交
371
               "better hardward. This size should be carefully set.")
372
      .SetDefault(platform::GetDefaultConvWorkspaceSizeLimitMB());
C
chengduoZH 已提交
373
  AddComment(R"DOC(
C
chengduoZH 已提交
374 375
Convolution3D Transpose Operator.

C
chengduoZH 已提交
376
The convolution transpose operation calculates the output based on the input, filter
C
chengduoZH 已提交
377
and dilations, strides, paddings, groups parameters. The size of each dimension of the
C
chengduoZH 已提交
378
parameters is checked in the infer-shape.
379
Input(Input) and output(Output) are in NCDHW or NDHWC format. Where N is batch size, C is the
C
chengduoZH 已提交
380 381 382 383 384 385 386
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.
Filter(Input) is in MCDHW format. Where M is the number of input feature channels,
C is the number of output feature channels, D is the depth of the filter,H is the
height of the filter, and W is the width of the filter.
Parameters(strides, paddings) are three elements. These three elements represent
depth, height and width, respectively.
C
chengduoZH 已提交
387
The input(X) size and output(Out) size may be different.
C
chengduoZH 已提交
388

389
Example:
C
chengduoZH 已提交
390
  Input:
C
chengduoZH 已提交
391 392
       Input shape: $(N, C_{in}, D_{in}, H_{in}, W_{in})$
       Filter shape: $(C_{in}, C_{out}, D_f, H_f, W_f)$
C
chengduoZH 已提交
393
  Output:
C
chengduoZH 已提交
394 395 396
       Output shape: $(N, C_{out}, D_{out}, H_{out}, W_{out})$
  Where
  $$
397 398 399
       D_{out} = (D_{in} - 1) * strides[0] - pad_depth_front - pad_depth_back + dilations[0] * (D_f - 1) + 1 \\
       H_{out} = (H_{in} - 1) * strides[1] - pad_height_top  - pad_height_bottom + dilations[1] * (H_f - 1) + 1 \\
       W_{out} = (W_{in} - 1) * strides[2] - pad_width_left - pad_width_right + dilations[2] * (W_f - 1) + 1
C
chengduoZH 已提交
400
  $$
C
chengduoZH 已提交
401 402 403
)DOC");
}

C
chengduoZH 已提交
404
void ConvTransposeOpGrad::InferShape(framework::InferShapeContext* ctx) const {
C
chengduoZH 已提交
405 406 407 408 409 410 411 412 413 414
  auto in_dims = ctx->GetInputDim("Input");
  auto filter_dims = ctx->GetInputDim("Filter");
  if (ctx->HasOutput(framework::GradVarName("Input"))) {
    ctx->SetOutputDim(framework::GradVarName("Input"), in_dims);
  }
  if (ctx->HasOutput(framework::GradVarName("Filter"))) {
    ctx->SetOutputDim(framework::GradVarName("Filter"), filter_dims);
  }
}

415 416 417
framework::OpKernelType ConvTransposeOpGrad::GetExpectedKernelType(
    const framework::ExecutionContext& ctx) const {
  bool use_cudnn = ctx.Attr<bool>("use_cudnn");
418
  use_cudnn &= platform::is_gpu_place(ctx.GetPlace());
C
chengduoZH 已提交
419 420 421 422 423 424
#ifdef PADDLE_WITH_CUDA
  if (platform::is_gpu_place(ctx.GetPlace())) {
    auto& dev_ctx = ctx.template device_context<platform::CUDADeviceContext>();
    use_cudnn &= dev_ctx.cudnn_handle() != nullptr;
  }
#endif
425 426 427 428 429 430 431
  framework::LibraryType library_;
  if (use_cudnn) {
    library_ = framework::LibraryType::kCUDNN;
  } else {
    library_ = framework::LibraryType::kPlain;
  }

432
  framework::DataLayout layout_ = framework::DataLayout::kAnyLayout;
433 434 435
  return framework::OpKernelType(
      OperatorWithKernel::IndicateVarDataType(ctx, "Input"), ctx.GetPlace(),
      layout_, library_);
436 437
}

H
hong 已提交
438 439
template <typename T>
class ConvTransposeGradOpMaker : public framework::SingleGradOpMaker<T> {
S
sneaxiy 已提交
440
 public:
H
hong 已提交
441
  using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
S
sneaxiy 已提交
442 443

 protected:
H
hong 已提交
444 445 446 447 448 449 450 451 452 453
  std::unique_ptr<T> Apply() const override {
    std::unique_ptr<T> op(new T());
    op->SetType(this->ForwardOpType() + "_grad");
    op->SetInput("Input", this->Input("Input"));
    op->SetInput("Filter", this->Input("Filter"));
    op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input"));
    op->SetOutput(framework::GradVarName("Filter"), this->InputGrad("Filter"));
    if (this->HasInput("Bias")) {
      op->SetInput("Bias", this->Input("Bias"));
      op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias"));
S
sneaxiy 已提交
454
    }
H
hong 已提交
455 456
    op->SetInput(framework::GradVarName("Output"), this->OutputGrad("Output"));
    op->SetAttrMap(this->Attrs());
S
sneaxiy 已提交
457 458 459 460
    return op;
  }
};

C
chengduoZH 已提交
461 462 463 464
}  // namespace operators
}  // namespace paddle

namespace ops = paddle::operators;
C
chengduoZH 已提交
465

466
// conv2d_transpose
Y
Yang Yang 已提交
467 468
REGISTER_OPERATOR(conv2d_transpose, ops::ConvTransposeOp,
                  ops::Conv2DTransposeOpMaker,
H
hong 已提交
469 470
                  ops::ConvTransposeGradOpMaker<paddle::framework::OpDesc>,
                  ops::ConvTransposeGradOpMaker<paddle::imperative::OpBase>);
471
REGISTER_OPERATOR(conv2d_transpose_grad, ops::ConvTransposeOpGrad);
C
chengduoZH 已提交
472 473

REGISTER_OP_CPU_KERNEL(
C
chengduoZH 已提交
474
    conv2d_transpose,
Q
QI JUN 已提交
475 476
    ops::GemmConvTransposeKernel<paddle::platform::CPUDeviceContext, float>,
    ops::GemmConvTransposeKernel<paddle::platform::CPUDeviceContext, double>);
C
chengduoZH 已提交
477
REGISTER_OP_CPU_KERNEL(
C
chengduoZH 已提交
478
    conv2d_transpose_grad,
Q
QI JUN 已提交
479 480 481
    ops::GemmConvTransposeGradKernel<paddle::platform::CPUDeviceContext, float>,
    ops::GemmConvTransposeGradKernel<paddle::platform::CPUDeviceContext,
                                     double>);
C
chengduoZH 已提交
482

483
// conv3d_transpose
Y
Yang Yang 已提交
484 485
REGISTER_OPERATOR(conv3d_transpose, ops::ConvTransposeOp,
                  ops::Conv3DTransposeOpMaker,
H
hong 已提交
486 487
                  ops::ConvTransposeGradOpMaker<paddle::framework::OpDesc>,
                  ops::ConvTransposeGradOpMaker<paddle::imperative::OpBase>);
488
REGISTER_OPERATOR(conv3d_transpose_grad, ops::ConvTransposeOpGrad);
C
chengduoZH 已提交
489 490

REGISTER_OP_CPU_KERNEL(
C
chengduoZH 已提交
491
    conv3d_transpose,
Q
QI JUN 已提交
492 493
    ops::GemmConvTransposeKernel<paddle::platform::CPUDeviceContext, float>,
    ops::GemmConvTransposeKernel<paddle::platform::CPUDeviceContext, double>);
C
chengduoZH 已提交
494
REGISTER_OP_CPU_KERNEL(
C
chengduoZH 已提交
495
    conv3d_transpose_grad,
Q
QI JUN 已提交
496 497 498
    ops::GemmConvTransposeGradKernel<paddle::platform::CPUDeviceContext, float>,
    ops::GemmConvTransposeGradKernel<paddle::platform::CPUDeviceContext,
                                     double>);
499 500 501 502

// depthwise conv2d_transpose
REGISTER_OPERATOR(depthwise_conv2d_transpose, ops::ConvTransposeOp,
                  ops::Conv2DTransposeOpMaker,
H
hong 已提交
503 504
                  ops::ConvTransposeGradOpMaker<paddle::framework::OpDesc>,
                  ops::ConvTransposeGradOpMaker<paddle::imperative::OpBase>);
505 506 507 508 509 510 511 512 513 514 515
REGISTER_OPERATOR(depthwise_conv2d_transpose_grad, ops::ConvTransposeOpGrad);

REGISTER_OP_CPU_KERNEL(
    depthwise_conv2d_transpose,
    ops::GemmConvTransposeKernel<paddle::platform::CPUDeviceContext, float>,
    ops::GemmConvTransposeKernel<paddle::platform::CPUDeviceContext, double>);
REGISTER_OP_CPU_KERNEL(
    depthwise_conv2d_transpose_grad,
    ops::GemmConvTransposeGradKernel<paddle::platform::CPUDeviceContext, float>,
    ops::GemmConvTransposeGradKernel<paddle::platform::CPUDeviceContext,
                                     double>);