Skip to content

P
Paddle

机器未来 / Paddle
与 Fork 源项目一致

Fork自 PaddlePaddle / Paddle

通知 1
Star 1
Fork 0
P
Paddle
提交 6db476ed 编写于 作者: C chengduoZH
浏览文件
操作

Separate the declarations and implementation of the PoolOp and PoolMaker class... 

Separate the declarations and implementation of the PoolOp and PoolMaker class in order to reuse in pool_cudnn
上级 67edd04a
隐藏空白更改
内联 并排
Showing with 164 addition and 154 deletion
paddle/operators/pool_op.cc
浏览文件 @ 6db476ed
...@@ -22,108 +22,94 @@ int OutputSizePool(int input_size, int filter_size, int padding, int stride) { ...@@ -22,108 +22,94 @@ int OutputSizePool(int input_size, int filter_size, int padding, int stride) {
return output_size; return output_size;
} }
class PoolOp : public framework::OperatorWithKernel { void PoolOp::InferShape(framework::InferShapeContext *ctx) const {
public: PADDLE_ENFORCE(ctx->HasInput("X"), "X(Input) of Pooling should not be null.");
using framework::OperatorWithKernel::OperatorWithKernel; PADDLE_ENFORCE(ctx->HasOutput("Out"),
"Out(Output) of Pooling should not be null.");
protected:
void InferShape(framework::InferShapeContext *ctx) const override { auto in_x_dims = ctx->GetInputDim("X");
PADDLE_ENFORCE(ctx->HasInput("X"),
"X(Input) of Pooling should not be null."); std::string pooling_type = ctx->Attrs().Get<std::string>("poolingType");
PADDLE_ENFORCE(ctx->HasOutput("Out"), std::vector<int> ksize = ctx->Attrs().Get<std::vector<int>>("ksize");
"Out(Output) of Pooling should not be null."); std::vector<int> strides = ctx->Attrs().Get<std::vector<int>>("strides");
std::vector<int> paddings = ctx->Attrs().Get<std::vector<int>>("paddings");
auto in_x_dims = ctx->GetInputDim("X");
PADDLE_ENFORCE(in_x_dims.size() == 4 || in_x_dims.size() == 5,
std::string pooling_type = ctx->Attrs().Get<std::string>("poolingType"); "Pooling intput should be 4-D or 5-D");
std::vector<int> ksize = ctx->Attrs().Get<std::vector<int>>("ksize");
std::vector<int> strides = ctx->Attrs().Get<std::vector<int>>("strides"); if (ctx->Attrs().Get<bool>("globalPooling")) {
std::vector<int> paddings = ctx->Attrs().Get<std::vector<int>>("paddings"); ksize.resize(static_cast<size_t>(in_x_dims.size()) - 2);
for (size_t i = 0; i < ksize.size(); ++i)
PADDLE_ENFORCE(in_x_dims.size() == 4 || in_x_dims.size() == 5, ksize[i] = static_cast<int>(in_x_dims[i + 2]);
"Pooling intput should be 4-D or 5-D");
if (ctx->Attrs().Get<bool>("globalPooling")) {
ksize.resize(static_cast<size_t>(in_x_dims.size()) - 2);
for (size_t i = 0; i < ksize.size(); ++i)
ksize[i] = static_cast<int>(in_x_dims[i + 2]);
}
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]));
}
ctx->SetOutputDim("Out", framework::make_ddim(output_shape));
} }
};
PADDLE_ENFORCE(in_x_dims.size() - ksize.size() == 2U,
class PoolOpGrad : public framework::OperatorWithKernel { "Input size and pooling size should be consistent.");
public: PADDLE_ENFORCE_EQ(ksize.size(), strides.size(),
using framework::OperatorWithKernel::OperatorWithKernel; "Strides size and pooling size should be the same.");
PADDLE_ENFORCE_EQ(ksize.size(), paddings.size(),
protected: "Paddings size and pooling size should be the same.");
void InferShape(framework::InferShapeContext *ctx) const override {
PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) must not be null."); std::vector<int64_t> output_shape({in_x_dims[0], in_x_dims[1]});
PADDLE_ENFORCE(ctx->HasOutput(framework::GradVarName("X")), for (size_t i = 0; i < ksize.size(); ++i) {
"Input(X@GRAD) should not be null."); output_shape.push_back(
ctx->SetOutputDim(framework::GradVarName("X"), ctx->GetInputDim("X")); OutputSizePool(in_x_dims[i + 2], ksize[i], paddings[i], strides[i]));
} }
}; ctx->SetOutputDim("Out", framework::make_ddim(output_shape));
}
class Pool2dOpMaker : public framework::OpProtoAndCheckerMaker {
public: void PoolOpGrad::InferShape(framework::InferShapeContext *ctx) const {
Pool2dOpMaker(framework::OpProto *proto, framework::OpAttrChecker *op_checker) PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) must not be null.");
: OpProtoAndCheckerMaker(proto, op_checker) { PADDLE_ENFORCE(ctx->HasOutput(framework::GradVarName("X")),
AddInput( "Input(X@GRAD) should not be null.");
"X", ctx->SetOutputDim(framework::GradVarName("X"), ctx->GetInputDim("X"));
"The input tensor of pooling operator. " }
"The format of input tensor is NCHW. Where N is batch size, C is the "
"number of channels, H and W is the height and width of feature."); Pool2dOpMaker::Pool2dOpMaker(framework::OpProto *proto,
AddOutput("Out", framework::OpAttrChecker *op_checker)
"The output tensor of pooling operator." : OpProtoAndCheckerMaker(proto, op_checker) {
"The format of output tensor is also NCHW." AddInput(
"Where N is batch size, C is " "X",
"the number of channels, H and W is the height and " "The input tensor of pooling operator. "
"width of feature."); "The format of input tensor is NCHW. Where N is batch size, C is the "
"number of channels, H and W is the height and width of feature.");
AddAttr<std::string>("poolingType", AddOutput("Out",
"PoolingType of pooling operator." "The output tensor of pooling operator."
"Str constant equal to 'max' or 'avg'.") "The format of output tensor is also NCHW."
.InEnum({"max", "avg"}); "Where N is batch size, C is "
"the number of channels, H and W is the height and "
AddAttr<std::vector<int>>( "width of feature.");
"ksize",
"The pooling size(height, width) of pooling operator." AddAttr<std::string>("poolingType",
"If globalPooling = true, ksize is ignored and need not be " "PoolingType of pooling operator."
"specified."); // TODO(Chengduo): Add checker. (Currently, "Str constant equal to 'max' or 'avg'.")
// TypedAttrChecker don't support vector type.) .InEnum({"max", "avg"});
AddAttr<bool>(
"globalPooling", AddAttr<std::vector<int>>(
"Whether to use the globalPooling." "ksize",
"Bool constant equal to false or true." "The pooling size(height, width) of pooling operator."
"Default false." "If globalPooling = true, ksize is ignored and need not be "
"If globalPooling = true, ksize is ignored and need not be specified.") "specified."); // TODO(Chengduo): Add checker. (Currently,
.SetDefault(false); // TypedAttrChecker don't support vector type.)
AddAttr<std::vector<int>>("strides", AddAttr<bool>(
"Strides(height, width) of pooling operator." "globalPooling",
"Default {1,1}.") "Whether to use the globalPooling."
.SetDefault({1, 1}); // TODO(Chengduo): Add checker. (Currently, "Bool constant equal to false or true."
// TypedAttrChecker don't support vector type.) "Default false."
AddAttr<std::vector<int>>("paddings", "If globalPooling = true, ksize is ignored and need not be specified.")
"Paddings(height, width) of pooling operator." .SetDefault(false);
"Default {0,0}.") AddAttr<std::vector<int>>("strides",
.SetDefault({0, 0}); // TODO(Chengduo): Add checker. (Currently, "Strides(height, width) of pooling operator."
// TypedAttrChecker don't support vector type.) "Default {1,1}.")
.SetDefault({1, 1}); // TODO(Chengduo): Add checker. (Currently,
AddComment(R"DOC( // TypedAttrChecker don't support vector type.)
AddAttr<std::vector<int>>("paddings",
"Paddings(height, width) of pooling operator."
"Default {0,0}.")
.SetDefault({0, 0}); // TODO(Chengduo): Add checker. (Currently,
// TypedAttrChecker don't support vector type.)
AddComment(R"DOC(
The pooling2d operation calculates the output based on The pooling2d operation calculates the output based on
the input, poolingType and ksize, strides, paddings parameters. the input, poolingType and ksize, strides, paddings parameters.
Input(X) and output(Out) are in NCHW format. Where N is batch size, C is the Input(X) and output(Out) are in NCHW format. Where N is batch size, C is the
...@@ -131,58 +117,55 @@ number of channels, H and W is the height and width of feature. ...@@ -131,58 +117,55 @@ number of channels, H and W is the height and width of feature.
Parameters(ksize, strides, paddings) are two elements. Parameters(ksize, strides, paddings) are two elements.
These two elements represent height and width, respectively. These two elements represent height and width, respectively.
)DOC"); )DOC");
} }
};
Pool3dOpMaker::Pool3dOpMaker(framework::OpProto *proto,
class Pool3dOpMaker : public framework::OpProtoAndCheckerMaker { framework::OpAttrChecker *op_checker)
public: : OpProtoAndCheckerMaker(proto, op_checker) {
Pool3dOpMaker(framework::OpProto *proto, framework::OpAttrChecker *op_checker) AddInput(
: OpProtoAndCheckerMaker(proto, op_checker) { "X",
AddInput( "The input tensor of pooling operator. "
"X", "The format of input tensor is NCDHW. Where N is batch size, C is "
"The input tensor of pooling operator. " "the number of channels, D, H and W is the depth, height and width of "
"The format of input tensor is NCDHW. Where N is batch size, C is " "feature.");
"the number of channels, D, H and W is the depth, height and width of " AddOutput("Out",
"feature."); "The output tensor of pooling operator."
AddOutput("Out", "The format of output tensor is also NCDHW."
"The output tensor of pooling operator." "Where N is batch size, C is "
"The format of output tensor is also NCDHW." "the number of channels, D, H and W is the depth, height and "
"Where N is batch size, C is " "width of feature.");
"the number of channels, D, H and W is the depth, height and "
"width of feature."); AddAttr<std::string>("poolingType",
"PoolingType of pooling operator."
AddAttr<std::string>("poolingType", "Str constant equal to 'max' or 'avg'.")
"PoolingType of pooling operator." .InEnum({"max", "avg"});
"Str constant equal to 'max' or 'avg'.")
.InEnum({"max", "avg"}); AddAttr<std::vector<int>>(
"ksize",
AddAttr<std::vector<int>>( "The pooling size(depth, height, width) of pooling operator."
"ksize", "If globalPooling = true, ksize is ignored and need not be "
"The pooling size(depth, height, width) of pooling operator." "specified."); // TODO(Chengduo): Add checker. (Currently,
"If globalPooling = true, ksize is ignored and need not be " // TypedAttrChecker don't support vector type.)
"specified."); // TODO(Chengduo): Add checker. (Currently, AddAttr<bool>(
// TypedAttrChecker don't support vector type.) "globalPooling",
AddAttr<bool>( "Whether to use the globalPooling."
"globalPooling", "Bool constant equal to false or true."
"Whether to use the globalPooling." "Default false."
"Bool constant equal to false or true." "If globalPooling = true, ksize is ignored and need not be specified.")
"Default false." .SetDefault(false);
"If globalPooling = true, ksize is ignored and need not be specified.") AddAttr<std::vector<int>>("strides",
.SetDefault(false); "Strides(depth, height, width) of pooling operator."
AddAttr<std::vector<int>>( "Default {1,1,1}.")
"strides", .SetDefault({1, 1, 1}); // TODO(Chengduo): Add checker. (Currently,
"Strides(depth, height, width) of pooling operator." // TypedAttrChecker don't support vector type.)
"Default {1,1,1}.") AddAttr<std::vector<int>>(
.SetDefault({1, 1, 1}); // TODO(Chengduo): Add checker. (Currently, "paddings",
// TypedAttrChecker don't support vector type.) "Paddings(depth, height, width) of pooling operator."
AddAttr<std::vector<int>>( "Default {0,0,0}.")
"paddings", .SetDefault({0, 0, 0}); // TODO(Chengduo): Add checker. (Currently,
"Paddings(depth, height, width) of pooling operator." // TypedAttrChecker don't support vector type.)
"Default {0,0,0}.")
.SetDefault({0, 0, 0}); // TODO(Chengduo): Add checker. (Currently, AddComment(R"DOC(
// TypedAttrChecker don't support vector type.)
AddComment(R"DOC(
The pooling3d operation calculates the output based on The pooling3d operation calculates the output based on
the input, poolingType and ksize, strides, paddings parameters. the input, poolingType and ksize, strides, paddings parameters.
Input(X) and output(Out) are in NCDHW format. Where N is batch Input(X) and output(Out) are in NCDHW format. Where N is batch
...@@ -190,8 +173,7 @@ size, C is the number of channels, D, H and W is the depth, height and ...@@ -190,8 +173,7 @@ size, C is the number of channels, D, H and W is the depth, height and
width of feature. Parameters(ksize, strides, paddings) are three elements. width of feature. Parameters(ksize, strides, paddings) are three elements.
These three elements represent depth, height and width, respectively. These three elements represent depth, height and width, respectively.
)DOC"); )DOC");
} }
};
} // namespace operators } // namespace operators
} // namespace paddle } // namespace paddle
......
paddle/operators/pool_op.h
浏览文件 @ 6db476ed
...@@ -24,6 +24,34 @@ namespace operators { ...@@ -24,6 +24,34 @@ namespace operators {
using Tensor = framework::Tensor; using Tensor = framework::Tensor;
class PoolOp : public framework::OperatorWithKernel {
public:
using framework::OperatorWithKernel::OperatorWithKernel;
protected:
void InferShape(framework::InferShapeContext* ctx) const override;
};
class PoolOpGrad : public framework::OperatorWithKernel {
public:
using framework::OperatorWithKernel::OperatorWithKernel;
protected:
void InferShape(framework::InferShapeContext* ctx) const override;
};
class Pool2dOpMaker : public framework::OpProtoAndCheckerMaker {
public:
Pool2dOpMaker(framework::OpProto* proto,
framework::OpAttrChecker* op_checker);
};
class Pool3dOpMaker : public framework::OpProtoAndCheckerMaker {
public:
Pool3dOpMaker(framework::OpProto* proto,
framework::OpAttrChecker* op_checker);
};
template <typename Place, typename T> template <typename Place, typename T>
class PoolKernel : public framework::OpKernel<T> { class PoolKernel : public framework::OpKernel<T> {
public: public:
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或