pool_op.cc 9.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.

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

#include "paddle/operators/pool_op.h"

namespace paddle {
namespace operators {

C
chengduoZH 已提交
20
int OutputSizePool(int input_size, int filter_size, int padding, int stride) {
21 22 23 24
  int output_size = (input_size - filter_size + 2 * padding) / stride + 1;
  return output_size;
}

25 26 27 28 29 30 31
void PoolOp::InferShape(framework::InferShapeContext *ctx) const {
  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 已提交
32
  std::string pooling_type = ctx->Attrs().Get<std::string>("pooling_type");
33 34 35 36 37
  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");

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

C
chengduoZH 已提交
40
  if (ctx->Attrs().Get<bool>("global_pooling")) {
41
    ksize.resize(static_cast<size_t>(in_x_dims.size()) - 2);
C
fix bug  
chengduoZH 已提交
42 43
    for (size_t i = 0; i < ksize.size(); ++i) {
      paddings[i] = 0;
44
      ksize[i] = static_cast<int>(in_x_dims[i + 2]);
C
fix bug  
chengduoZH 已提交
45
    }
46
  }
47 48 49 50 51 52 53 54 55 56 57 58

  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) {
    output_shape.push_back(
        OutputSizePool(in_x_dims[i + 2], ksize[i], paddings[i], strides[i]));
59
  }
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
  ctx->SetOutputDim("Out", framework::make_ddim(output_shape));
}

void PoolOpGrad::InferShape(framework::InferShapeContext *ctx) const {
  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"));
}

Pool2dOpMaker::Pool2dOpMaker(framework::OpProto *proto,
                             framework::OpAttrChecker *op_checker)
    : OpProtoAndCheckerMaker(proto, op_checker) {
  AddInput(
      "X",
C
chengduoZH 已提交
75
      "(Tensor) The input tensor of pooling operator. "
K
kexinzhao 已提交
76 77 78
      "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.");
79
  AddOutput("Out",
K
kexinzhao 已提交
80 81 82 83 84
            "(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, "
            "and W is the width of the feature.");
85

C
chengduoZH 已提交
86
  AddAttr<std::string>("pooling_type",
C
chengduoZH 已提交
87 88
                       "(string), pooling type, can be \"max\" for max-pooling "
                       "and \"avg\" for average-pooling.")
89
      .InEnum({"max", "avg"});
C
fix bug  
chengduoZH 已提交
90
  AddAttr<std::vector<int>>("ksize",
K
kexinzhao 已提交
91 92
                            "(vector<int>) The pooling window "
                            "size(height, width) of the pooling operator. "
C
chengduoZH 已提交
93
                            "If global_pooling = true, ksize and paddings will "
C
fix bug  
chengduoZH 已提交
94 95
                            "be ignored.");  // TODO(Chengduo): Add checker.
                                             // (Currently,
C
fix doc  
chengduoZH 已提交
96
  // TypedAttrChecker don't support vector type.)
C
chengduoZH 已提交
97
  AddAttr<bool>("global_pooling",
K
kexinzhao 已提交
98
                "(bool, default false) Whether to use the global pooling. "
C
chengduoZH 已提交
99
                "If global_pooling = true, ksize and paddings will be ignored.")
100
      .SetDefault(false);
K
kexinzhao 已提交
101 102 103
  AddAttr<std::vector<int>>("strides",
                            "(vector<int>, default {1, 1}), strides(height, "
                            "width) of pooling operator.")
104
      .SetDefault({1, 1});  // TODO(Chengduo): Add checker. (Currently,
C
fix doc  
chengduoZH 已提交
105 106 107
  // TypedAttrChecker don't support vector type.)
  AddAttr<std::vector<int>>(
      "paddings",
C
chengduoZH 已提交
108
      "(vector<int>, default {0,0}), paddings(height, width) of pooling "
K
kexinzhao 已提交
109
      "operator."
C
chengduoZH 已提交
110
      "If global_pooling = true, paddings and ksize will be ignored.")
111
      .SetDefault({0, 0});  // TODO(Chengduo): Add checker. (Currently,
C
fix doc  
chengduoZH 已提交
112
  // TypedAttrChecker don't support vector type.)
113 114

  AddComment(R"DOC(
K
kexinzhao 已提交
115 116
Pool2d Operator.

C
chengduoZH 已提交
117
The pooling2d operation calculates the output based on
C
chengduoZH 已提交
118
the input, pooling_type and ksize, strides, paddings parameters.
K
kexinzhao 已提交
119 120
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 已提交
121 122
Parameters(ksize, strides, paddings) are two elements.
These two elements represent height and width, respectively.
C
chengduoZH 已提交
123 124
The input(X) size and output(Out) size may be different.

C
chengduoZH 已提交
125
Example:   
C
chengduoZH 已提交
126
  Input:
K
kexinzhao 已提交
127
       X shape: $(N, C, H_{in}, W_{in})$
C
chengduoZH 已提交
128
  Output:
K
kexinzhao 已提交
129
       Out shape: $(N, C, H_{out}, W_{out})$
C
chengduoZH 已提交
130
  Where
K
kexinzhao 已提交
131
       $$ 
C
chengduoZH 已提交
132 133
       H_{out} = \frac{(H_{in} - ksize[0] + 2 * paddings[0])}{strides[0]} + 1 \\
       W_{out} = \frac{(W_{in} - ksize[1] + 2 * paddings[1])}{strides[1]} + 1
K
kexinzhao 已提交
134 135
       $$

136
)DOC");
137 138 139 140 141
}

Pool3dOpMaker::Pool3dOpMaker(framework::OpProto *proto,
                             framework::OpAttrChecker *op_checker)
    : OpProtoAndCheckerMaker(proto, op_checker) {
K
kexinzhao 已提交
142 143 144 145 146 147
  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.");
148
  AddOutput("Out",
C
chengduoZH 已提交
149
            "(Tensor) The output tensor of pooling operator."
K
kexinzhao 已提交
150 151 152 153
            "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 "
            "width of the feature, respectively.");
154

C
chengduoZH 已提交
155
  AddAttr<std::string>("pooling_type",
K
kexinzhao 已提交
156
                       "(string) Pooling type, can be \"max\" for max-pooling "
C
chengduoZH 已提交
157
                       "and \"avg\" for average-pooling.")
158
      .InEnum({"max", "avg"});
K
kexinzhao 已提交
159 160 161 162
  AddAttr<std::vector<int>>(
      "ksize",
      "(vector<int>) The pooling window size(depth, height, "
      "width) of pooling operator. "
C
chengduoZH 已提交
163
      "If global_pooling = true, ksize and paddings will "
K
kexinzhao 已提交
164 165
      "be ignored.");  // TODO(Chengduo): Add checker.
                       // (Currently,
C
fix bug  
chengduoZH 已提交
166
  // TypedAttrChecker don't support vector type.)
C
chengduoZH 已提交
167 168 169 170
  AddAttr<bool>(
      "global_pooling",
      "(bool, default false) Whether to use the global pooling. "
      "If global_pooling = true, ksize and paddings wille be ignored.")
171
      .SetDefault(false);
K
kexinzhao 已提交
172 173 174 175
  AddAttr<std::vector<int>>(
      "strides",
      "(vector<int>, default {1,1,1}) Strides(depth, height, "
      "width) of the pooling operator.")
176 177
      .SetDefault({1, 1, 1});  // TODO(Chengduo): Add checker. (Currently,
                               // TypedAttrChecker don't support vector type.)
C
fix bug  
chengduoZH 已提交
178 179
  AddAttr<std::vector<int>>(
      "paddings",
C
chengduoZH 已提交
180
      "(vector<int>, default {0,0,0}), paddings(depth, height, "
K
kexinzhao 已提交
181
      "width) of pooling operator. "
C
chengduoZH 已提交
182
      "If global_pooling = true, ksize and paddings will be ignored.")
183 184 185 186
      .SetDefault({0, 0, 0});  // TODO(Chengduo): Add checker. (Currently,
                               // TypedAttrChecker don't support vector type.)

  AddComment(R"DOC(
K
kexinzhao 已提交
187 188
Pool3d Operator.

C
chengduoZH 已提交
189
The pooling3d operation calculates the output based on
C
chengduoZH 已提交
190
the input, pooling_type, ksize, strides, and paddings parameters.
K
kexinzhao 已提交
191 192 193 194 195
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
width of the feature, respectively. Parameters(ksize, strides, paddings) 
are three elements. These three elements represent depth, height and 
width, respectively. The input(X) size and output(Out) size may be different.
C
chengduoZH 已提交
196 197 198

Example:
  Input:
K
kexinzhao 已提交
199
       X shape: $(N, C, D_{in}, H_{in}, W_{in})$
C
chengduoZH 已提交
200
  Output:
K
kexinzhao 已提交
201
       Out shape: $(N, C, D_{out}, H_{out}, W_{out})$
C
chengduoZH 已提交
202 203 204 205 206 207
  Where
  $$
       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
  $$
K
kexinzhao 已提交
208

209
)DOC");
210
}
211 212 213 214 215 216 217 218 219
}  // namespace operators
}  // namespace paddle

namespace ops = paddle::operators;

REGISTER_OP(pool2d, ops::PoolOp, ops::Pool2dOpMaker, pool2d_grad,
            ops::PoolOpGrad);

REGISTER_OP_CPU_KERNEL(pool2d,
C
chengduoZH 已提交
220 221
                       ops::PoolKernel<paddle::platform::CPUPlace, float>,
                       ops::PoolKernel<paddle::platform::CPUPlace, double>);
222
REGISTER_OP_CPU_KERNEL(pool2d_grad,
C
chengduoZH 已提交
223 224
                       ops::PoolGradKernel<paddle::platform::CPUPlace, float>,
                       ops::PoolGradKernel<paddle::platform::CPUPlace, double>)
225 226 227 228 229

REGISTER_OP(pool3d, ops::PoolOp, ops::Pool3dOpMaker, pool3d_grad,
            ops::PoolOpGrad);

REGISTER_OP_CPU_KERNEL(pool3d,
C
chengduoZH 已提交
230 231
                       ops::PoolKernel<paddle::platform::CPUPlace, float>,
                       ops::PoolKernel<paddle::platform::CPUPlace, double>);
232
REGISTER_OP_CPU_KERNEL(pool3d_grad,
C
chengduoZH 已提交
233 234
                       ops::PoolGradKernel<paddle::platform::CPUPlace, float>,
                       ops::PoolGradKernel<paddle::platform::CPUPlace, double>);