pool_op.cc 16.0 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
2 3 4 5 6 7 8 9 10 11 12 13 14

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. */

Y
Yi Wang 已提交
15
#include "paddle/fluid/operators/pool_op.h"
16 17 18 19 20 21
#ifdef PADDLE_WITH_CUDA
#include "paddle/fluid/platform/cudnn_helper.h"
#endif
#ifdef PADDLE_WITH_MKLDNN
#include "paddle/fluid/platform/mkldnn_helper.h"
#endif
22 23 24 25

namespace paddle {
namespace operators {

26 27 28 29 30 31 32 33 34
int PoolOutputSize(int input_size, int filter_size, int padding, int stride,
                   bool ceil_mode) {
  int output_size;
  if (!ceil_mode) {
    output_size = (input_size - filter_size + 2 * padding) / stride + 1;
  } else {
    output_size =
        (input_size - filter_size + 2 * padding + stride - 1) / stride + 1;
  }
C
chengduoZH 已提交
35 36 37 38 39
  PADDLE_ENFORCE(output_size > 0,
                 "Due to the settings of padding(%d), filter_size(%d) and "
                 "stride(%d), the output size is less than 0, please check "
                 "again. Input_size:%d",
                 padding, filter_size, stride, input_size);
40 41 42
  return output_size;
}

43
void PoolOp::InferShape(framework::InferShapeContext* ctx) const {
44 45 46 47 48 49
  PADDLE_ENFORCE(ctx->HasInput("X"), "X(Input) of Pooling should not be null.");
  PADDLE_ENFORCE(ctx->HasOutput("Out"),
                 "Out(Output) of Pooling should not be null.");

  auto in_x_dims = ctx->GetInputDim("X");

C
chengduoZH 已提交
50
  std::string pooling_type = ctx->Attrs().Get<std::string>("pooling_type");
51 52 53
  std::vector<int> ksize = ctx->Attrs().Get<std::vector<int>>("ksize");
  std::vector<int> strides = ctx->Attrs().Get<std::vector<int>>("strides");
  std::vector<int> paddings = ctx->Attrs().Get<std::vector<int>>("paddings");
54
  bool ceil_mode = ctx->Attrs().Get<bool>("ceil_mode");
55 56

  PADDLE_ENFORCE(in_x_dims.size() == 4 || in_x_dims.size() == 5,
C
chengduoZH 已提交
57
                 "Pooling intput should be 4-D or 5-D tensor.");
58

C
chengduoZH 已提交
59
  if (ctx->Attrs().Get<bool>("global_pooling")) {
60
    ksize.resize(static_cast<size_t>(in_x_dims.size()) - 2);
C
fix bug  
chengduoZH 已提交
61 62
    for (size_t i = 0; i < ksize.size(); ++i) {
      paddings[i] = 0;
63
      ksize[i] = static_cast<int>(in_x_dims[i + 2]);
C
fix bug  
chengduoZH 已提交
64
    }
65
  }
66 67 68 69 70 71 72 73 74 75

  PADDLE_ENFORCE(in_x_dims.size() - ksize.size() == 2U,
                 "Input size and pooling size should be consistent.");
  PADDLE_ENFORCE_EQ(ksize.size(), strides.size(),
                    "Strides size and pooling size should be the same.");
  PADDLE_ENFORCE_EQ(ksize.size(), paddings.size(),
                    "Paddings size and pooling size should be the same.");

  std::vector<int64_t> output_shape({in_x_dims[0], in_x_dims[1]});
  for (size_t i = 0; i < ksize.size(); ++i) {
76 77
    output_shape.push_back(PoolOutputSize(in_x_dims[i + 2], ksize[i],
                                          paddings[i], strides[i], ceil_mode));
78
  }
79
  ctx->SetOutputDim("Out", framework::make_ddim(output_shape));
80
  ctx->ShareLoD("X", "Out");
81 82
}

83
framework::OpKernelType PoolOp::GetExpectedKernelType(
84
    const framework::ExecutionContext& ctx) const {
85
  framework::LibraryType library_{framework::LibraryType::kPlain};
M
mozga-intel 已提交
86 87 88
  std::string data_format = ctx.Attr<std::string>("data_format");
  framework::DataLayout layout_ = framework::StringToDataLayout(data_format);

C
chengduoZH 已提交
89
#ifdef PADDLE_WITH_CUDA
90 91
  if (platform::CanCUDNNBeUsed(ctx)) {
    library_ = framework::LibraryType::kCUDNN;
C
chengduoZH 已提交
92 93
  }
#endif
94 95 96 97
#ifdef PADDLE_WITH_MKLDNN
  if (library_ == framework::LibraryType::kPlain &&
      platform::CanMKLDNNBeUsed(ctx)) {
    library_ = framework::LibraryType::kMKLDNN;
M
mozga-intel 已提交
98
    layout_ = framework::DataLayout::kMKLDNN;
99
  }
100
#endif
101 102 103 104 105 106

  return framework::OpKernelType(
      framework::ToDataType(ctx.Input<Tensor>("X")->type()), ctx.GetPlace(),
      layout_, library_);
}

107
void PoolOpGrad::InferShape(framework::InferShapeContext* ctx) const {
108 109 110 111 112 113
  PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) must not be null.");
  PADDLE_ENFORCE(ctx->HasOutput(framework::GradVarName("X")),
                 "Input(X@GRAD) should not be null.");
  ctx->SetOutputDim(framework::GradVarName("X"), ctx->GetInputDim("X"));
}

114
framework::OpKernelType PoolOpGrad::GetExpectedKernelType(
115
    const framework::ExecutionContext& ctx) const {
116
  framework::LibraryType library_{framework::LibraryType::kPlain};
M
mozga-intel 已提交
117 118 119
  std::string data_format = ctx.Attr<std::string>("data_format");
  framework::DataLayout layout_ = framework::StringToDataLayout(data_format);

C
chengduoZH 已提交
120
#ifdef PADDLE_WITH_CUDA
121 122
  if (platform::CanCUDNNBeUsed(ctx)) {
    library_ = framework::LibraryType::kCUDNN;
C
chengduoZH 已提交
123 124
  }
#endif
125 126 127 128
#ifdef PADDLE_WITH_MKLDNN
  if (library_ == framework::LibraryType::kPlain &&
      platform::CanMKLDNNBeUsed(ctx)) {
    library_ = framework::LibraryType::kMKLDNN;
M
mozga-intel 已提交
129
    layout_ = framework::DataLayout::kMKLDNN;
130
  }
131
#endif
132

K
Kexin Zhao 已提交
133 134 135 136 137 138 139
  auto input_data_type = framework::ToDataType(ctx.Input<Tensor>("X")->type());
  if (input_data_type == framework::proto::VarType::FP16) {
    PADDLE_ENFORCE_EQ(library_, framework::LibraryType::kCUDNN,
                      "float16 can only be used when CUDNN is used");
  }
  return framework::OpKernelType(input_data_type, ctx.GetPlace(), layout_,
                                 library_);
140 141
}

Y
Yu Yang 已提交
142
void Pool2dOpMaker::Make() {
143 144
  AddInput(
      "X",
C
chengduoZH 已提交
145
      "(Tensor) The input tensor of pooling operator. "
146 147 148
      "The format of input tensor is NCHW, 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.");
149
  AddOutput("Out",
150 151 152 153
            "(Tensor) The output tensor of pooling operator. "
            "The format of output tensor is also NCHW, "
            "where N is batch size, C is the number of channels, "
            "H is the height of the feature, "
154
            "and W is the width of the feature.");
155

C
chengduoZH 已提交
156
  AddAttr<std::string>("pooling_type",
C
chengduoZH 已提交
157 158
                       "(string), pooling type, can be \"max\" for max-pooling "
                       "and \"avg\" for average-pooling.")
159
      .InEnum({"max", "avg"});
C
fix bug  
chengduoZH 已提交
160
  AddAttr<std::vector<int>>("ksize",
161 162
                            "(vector<int>) The pooling window "
                            "size(height, width) of the pooling operator. "
C
chengduoZH 已提交
163
                            "If global_pooling = true, ksize and paddings will "
C
fix bug  
chengduoZH 已提交
164 165
                            "be ignored.");  // TODO(Chengduo): Add checker.
                                             // (Currently,
C
fix doc  
chengduoZH 已提交
166
  // TypedAttrChecker don't support vector type.)
C
chengduoZH 已提交
167
  AddAttr<bool>("global_pooling",
168
                "(bool, default false) Whether to use the global pooling. "
C
chengduoZH 已提交
169
                "If global_pooling = true, ksize and paddings will be ignored.")
170
      .SetDefault(false);
171 172 173
  AddAttr<std::vector<int>>("strides",
                            "(vector<int>, default {1, 1}), strides(height, "
                            "width) of pooling operator.")
174 175
      .SetDefault({1, 1});
  // TODO(Chengduo): Add checker. (Currently,
C
fix doc  
chengduoZH 已提交
176 177 178
  // TypedAttrChecker don't support vector type.)
  AddAttr<std::vector<int>>(
      "paddings",
179
      "(vector<int>, default {0,0}), paddings(height, width) of pooling "
180
      "operator."
C
chengduoZH 已提交
181
      "If global_pooling = true, paddings and ksize will be ignored.")
182
      .SetDefault({0, 0});
183 184 185 186 187 188
  AddAttr<bool>(
      "exclusive",
      "(bool, default True) When true, will exclude the zero-padding in the "
      "averaging calculating, otherwise, include the zero-padding. Note, it "
      "is only used when pooling_type is avg. The defalut is True.")
      .SetDefault(true);
189 190 191 192
  AddAttr<bool>(
      "use_cudnn",
      "(bool, default false) Only used in cudnn kernel, need install cudnn")
      .SetDefault(false);
193 194 195
  AddAttr<bool>(
      "ceil_mode",
      "(bool, default false) Wether to use the ceil function to calculate "
W
wanghaoshuang 已提交
196 197
      "output height and width. False is the default. If it is set to False, "
      "the floor function will be used.")
198
      .SetDefault(false);
199 200 201
  AddAttr<bool>("use_mkldnn",
                "(bool, default false) Only used in mkldnn kernel")
      .SetDefault(false);
202 203 204 205 206 207 208 209
  AddAttr<std::string>(
      "data_format",
      "(string, default NCHW) Only used in "
      "An optional string from: \"NHWC\", \"NCHW\". "
      "Defaults to \"NHWC\". Specify the data format of the output data, "
      "the input will be transformed automatically. ")
      .SetDefault("AnyLayout");
  // TODO(dzhwinter): need to registered layout transform function
210 211

  AddComment(R"DOC(
C
chengduoZH 已提交
212
The pooling2d operation calculates the output based on
C
chengduoZH 已提交
213
the input, pooling_type and ksize, strides, paddings parameters.
214 215
Input(X) and output(Out) are in NCHW 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.
C
fix doc  
chengduoZH 已提交
216 217
Parameters(ksize, strides, paddings) are two elements.
These two elements represent height and width, respectively.
C
chengduoZH 已提交
218 219
The input(X) size and output(Out) size may be different.

220
Example:
F
fengjiayi 已提交
221

C
chengduoZH 已提交
222
  Input:
F
fengjiayi 已提交
223

224
       X shape: $(N, C, H_{in}, W_{in})$
F
fengjiayi 已提交
225

C
chengduoZH 已提交
226
  Output:
F
fengjiayi 已提交
227

228
       Out shape: $(N, C, H_{out}, W_{out})$
F
fengjiayi 已提交
229

230 231
  For ceil_mode = false:
       $$
F
fengjiayi 已提交
232
       H_{out} = \\frac{(H_{in} - ksize[0] + 2 * paddings[0])}{strides[0]} + 1
F
fengjiayi 已提交
233 234
       $$
       $$
F
fengjiayi 已提交
235
       W_{out} = \\frac{(W_{in} - ksize[1] + 2 * paddings[1])}{strides[1]} + 1
236
       $$
237 238
  For ceil_mode = true:
       $$
F
fengjiayi 已提交
239
       H_{out} = \\frac{(H_{in} - ksize[0] + 2 * paddings[0] + strides[0] - 1)}{strides[0]} + 1
F
fengjiayi 已提交
240 241
       $$
       $$
F
fengjiayi 已提交
242
       W_{out} = \\frac{(W_{in} - ksize[1] + 2 * paddings[1] + strides[1] - 1)}{strides[1]} + 1
243
       $$
244

245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
  For exclusive = true:
       $$
       hstart = i * strides[0] - paddings[0]
       hend = hstart + ksize[0]
       wstart = j * strides[1] - paddings[1]
       wend = wstart + ksize[1]
       Output(i ,j) = \\frac{sum(Input[hstart:hend, wstart:wend])}{ksize[0] * ksize[1]}
       $$
  For exclusive = false:
       $$
       hstart = max(0, i * strides[0] - paddings[0])
       hend = min(H, hstart + ksize[0])
       wstart = max(0, j * strides[1] - paddings[1])
       wend = min(W, wstart + ksize[1])
       Output(i ,j) = \\frac{sum(Input[hstart:hend, wstart:wend])}{(hend - hstart) * (wend - wstart)}
       $$

262
)DOC");
263 264
}

265 266 267 268 269 270 271 272
class PoolOpInferVarType : public framework::PassInDtypeAndVarTypeToOutput {
 protected:
  std::unordered_map<std::string, std::string> GetInputOutputWithSameType()
      const override {
    return std::unordered_map<std::string, std::string>{{"X", /*->*/ "Out"}};
  }
};

Y
Yu Yang 已提交
273
void Pool3dOpMaker::Make() {
274 275 276 277 278 279
  AddInput("X",
           "(Tensor) The input tensor of pooling operator. "
           "The format of input tensor is NCDHW, where N is batch size, C is "
           "the number of channels, and D, H and W is the depth, height and "
           "width of "
           "the feature, respectively.");
280
  AddOutput("Out",
C
chengduoZH 已提交
281
            "(Tensor) The output tensor of pooling operator."
282 283 284
            "The format of output tensor is also NCDHW, "
            "where N is batch size, C is "
            "the number of channels, and D, H and W is the depth, height and "
285
            "width of the feature, respectively.");
286

C
chengduoZH 已提交
287
  AddAttr<std::string>("pooling_type",
288
                       "(string) Pooling type, can be \"max\" for max-pooling "
C
chengduoZH 已提交
289
                       "and \"avg\" for average-pooling.")
290
      .InEnum({"max", "avg"});
291 292 293 294
  AddAttr<std::vector<int>>(
      "ksize",
      "(vector<int>) The pooling window size(depth, height, "
      "width) of pooling operator. "
C
chengduoZH 已提交
295
      "If global_pooling = true, ksize and paddings will "
296 297
      "be ignored.");  // TODO(Chengduo): Add checker.
                       // (Currently,
C
fix bug  
chengduoZH 已提交
298
  // TypedAttrChecker don't support vector type.)
C
chengduoZH 已提交
299 300 301 302
  AddAttr<bool>(
      "global_pooling",
      "(bool, default false) Whether to use the global pooling. "
      "If global_pooling = true, ksize and paddings wille be ignored.")
303
      .SetDefault(false);
304 305 306 307
  AddAttr<std::vector<int>>(
      "strides",
      "(vector<int>, default {1,1,1}) Strides(depth, height, "
      "width) of the pooling operator.")
308 309
      .SetDefault({1, 1, 1});  // TODO(Chengduo): Add checker. (Currently,
                               // TypedAttrChecker don't support vector type.)
C
fix bug  
chengduoZH 已提交
310 311
  AddAttr<std::vector<int>>(
      "paddings",
312
      "(vector<int>, default {0,0,0}), paddings(depth, height, "
313
      "width) of pooling operator. "
C
chengduoZH 已提交
314
      "If global_pooling = true, ksize and paddings will be ignored.")
315 316
      .SetDefault({0, 0, 0});  // TODO(Chengduo): Add checker. (Currently,
                               // TypedAttrChecker don't support vector type.)
317 318 319 320 321 322
  AddAttr<bool>(
      "exclusive",
      "(bool, default True) When true, will exclude the zero-padding in the "
      "averaging calculating, otherwise, include the zero-padding. Note, it "
      "is only used when pooling_type is avg. The defalut is True.")
      .SetDefault(true);
323

324 325 326 327
  AddAttr<bool>(
      "use_cudnn",
      "(bool, default false) Only used in cudnn kernel, need install cudnn")
      .SetDefault(false);
328 329 330
  AddAttr<bool>(
      "ceil_mode",
      "(bool, default false) Wether to use the ceil function to calculate "
W
wanghaoshuang 已提交
331 332
      "output height and width. False is the default. If it is set to False, "
      "the floor function will be used.")
333
      .SetDefault(false);
334 335 336
  AddAttr<bool>("use_mkldnn",
                "(bool, default false) Only used in mkldnn kernel")
      .SetDefault(false);
337 338 339 340 341 342 343 344 345
  AddAttr<std::string>(
      "data_format",
      "(string, default NCHW) Only used in "
      "An optional string from: \"NHWC\", \"NCHW\". "
      "Defaults to \"NHWC\". Specify the data format of the output data, "
      "the input will be transformed automatically. ")
      .SetDefault("AnyLayout");
  // TODO(dzhwinter): need to registered layout transform function

346
  AddComment(R"DOC(
347 348
Pool3d Operator.

C
chengduoZH 已提交
349
The pooling3d operation calculates the output based on
C
chengduoZH 已提交
350
the input, pooling_type, ksize, strides, and paddings parameters.
351 352
Input(X) and output(Out) are in NCDHW format, where N is batch
size, C is the number of channels, and D, H and W are the depth, height and
353 354
width of the feature, respectively. Parameters(ksize, strides, paddings)
are three elements. These three elements represent depth, height and
355
width, respectively. The input(X) size and output(Out) size may be different.
C
chengduoZH 已提交
356 357 358

Example:
  Input:
359
       X shape: $(N, C, D_{in}, H_{in}, W_{in})$
C
chengduoZH 已提交
360
  Output:
361
       Out shape: $(N, C, D_{out}, H_{out}, W_{out})$
362
  For ceil_mode = false:
363 364 365 366 367
  $$
       D_{out} = \frac{(D_{in} - ksize[0] + 2 * paddings[0])}{strides[0]} + 1 \\
       H_{out} = \frac{(H_{in} - ksize[1] + 2 * paddings[1])}{strides[1]} + 1 \\
       W_{out} = \frac{(W_{in} - ksize[2] + 2 * paddings[2])}{strides[2]} + 1
  $$
368 369 370 371 372 373
  For ceil_mode = true:
  $$
       D_{out} = \frac{(D_{in} - ksize[0] + 2 * paddings[0] + strides[0] -1)}{strides[0]} + 1 \\
       H_{out} = \frac{(H_{in} - ksize[1] + 2 * paddings[1] + strides[1] -1)}{strides[1]} + 1 \\
       W_{out} = \frac{(W_{in} - ksize[2] + 2 * paddings[2] + strides[2] -1)}{strides[2]} + 1
  $$
374

375
)DOC");
376
}
377 378 379 380 381
}  // namespace operators
}  // namespace paddle

namespace ops = paddle::operators;

Y
Yang Yang 已提交
382
REGISTER_OPERATOR(pool2d, ops::PoolOp, ops::Pool2dOpMaker,
383
                  ops::PoolOpInferVarType,
384 385
                  paddle::framework::DefaultGradOpDescMaker<true>);
REGISTER_OPERATOR(pool2d_grad, ops::PoolOpGrad);
386

Q
QI JUN 已提交
387 388 389 390 391
REGISTER_OP_CPU_KERNEL(
    pool2d, ops::PoolKernel<paddle::platform::CPUDeviceContext, float>,
    ops::PoolKernel<paddle::platform::CPUDeviceContext, double>);
REGISTER_OP_CPU_KERNEL(
    pool2d_grad, ops::PoolGradKernel<paddle::platform::CPUDeviceContext, float>,
392
    ops::PoolGradKernel<paddle::platform::CPUDeviceContext, double>);
393

Y
Yang Yang 已提交
394
REGISTER_OPERATOR(pool3d, ops::PoolOp, ops::Pool3dOpMaker,
395
                  ops::PoolOpInferVarType,
396 397
                  paddle::framework::DefaultGradOpDescMaker<true>);
REGISTER_OPERATOR(pool3d_grad, ops::PoolOpGrad);
398

Q
QI JUN 已提交
399 400 401 402 403 404
REGISTER_OP_CPU_KERNEL(
    pool3d, ops::PoolKernel<paddle::platform::CPUDeviceContext, float>,
    ops::PoolKernel<paddle::platform::CPUDeviceContext, double>);
REGISTER_OP_CPU_KERNEL(
    pool3d_grad, ops::PoolGradKernel<paddle::platform::CPUDeviceContext, float>,
    ops::PoolGradKernel<paddle::platform::CPUDeviceContext, double>);
新手
引导
客服 返回
顶部