diff --git a/paddle/fluid/operators/pool_with_index_op.cc b/paddle/fluid/operators/pool_with_index_op.cc deleted file mode 100644 index 79262db30fafbaf5fd3accc098b0938bb7ec14e4..0000000000000000000000000000000000000000 --- a/paddle/fluid/operators/pool_with_index_op.cc +++ /dev/null @@ -1,302 +0,0 @@ -/* Copyright (c) 2016 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. */ - -#include - -#include "paddle/fluid/framework/infershape_utils.h" -#include "paddle/fluid/framework/op_registry.h" -#include "paddle/phi/core/infermeta_utils.h" -#include "paddle/phi/infermeta/backward.h" -#include "paddle/phi/infermeta/unary.h" - -namespace paddle { -namespace operators { - -inline int MaxPoolOutputSize(int input_size, - int filter_size, - int padding, - int stride) { - PADDLE_ENFORCE_NE( - stride, - 0, - phi::errors::InvalidArgument( - "The stride of MaxPool shall not be 0, but received %d.", stride)); - int output_size = (input_size - filter_size + 2 * padding) / stride + 1; - return output_size; -} - -class MaxPoolWithIndexOp : public framework::OperatorWithKernel { - public: - using framework::OperatorWithKernel::OperatorWithKernel; - - protected: - phi::KernelKey GetExpectedKernelType( - const framework::ExecutionContext &ctx) const override { - return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "X"), - ctx.device_context().GetPlace()); - } -}; - -class MaxPoolWithIndexOpGrad : public framework::OperatorWithKernel { - public: - using framework::OperatorWithKernel::OperatorWithKernel; - - protected: - phi::KernelKey GetExpectedKernelType( - const framework::ExecutionContext &ctx) const override { - return phi::KernelKey(OperatorWithKernel::IndicateVarDataType( - ctx, framework::GradVarName("Out")), - ctx.device_context().GetPlace()); - } -}; - -class MaxPool2dWithIndexOpMaker : public framework::OpProtoAndCheckerMaker { - public: - void Make() override { - AddInput( - "X", - "(Tensor) 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 is the height of the image, " - "and W is the width of the image."); - AddOutput("Out", - "(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 image " - "and W is the width of the image."); - AddOutput("Mask", - "(Tensor) The Mask 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 image, " - "and W is the width of the image. " - "It represents the index in the current feature map."); - - AddAttr>("ksize", - "(vector) The pooling window size(height, " - "width) of pooling operator. " - "If global_pooling = true, ksize and paddings " - "will be ignored."); // TODO(Chengduo): Add - // checker. (Currently, - // TypedAttrChecker don't support vector type.) - AddAttr( - "global_pooling", - "(bool, default:false) Whether to use the global pooling. " - "If global_pooling = true, ksize and paddings will be ignored.") - .SetDefault(false); - AddAttr( - "adaptive", - "(bool, default False) When true, will perform adaptive pooling " - "instead, " - "output shape in H and W dimensions will be same as ksize, input data " - "will be divided into grids specify by ksize averagely and perform " - "pooling in each grid area to get output pooling value.") - .SetDefault(false); - AddAttr>("strides", - "(vector, default {1, 1}), strides(height, " - "width) of pooling operator.") - .SetDefault({1, 1}); // TODO(Chengduo): Add checker. (Currently, - // TypedAttrChecker don't support vector type.) - AddAttr>( - "paddings", - "(vector, default:{0, 0}), paddings(height, width) of pooling " - "operator. " - "If global_pooling = true, paddings and will be ignored.") - .SetDefault({0, 0}); // TODO(Chengduo): Add checker. (Currently, - // TypedAttrChecker don't support vector type.) - - AddComment(R"DOC( -MaxPool2d Operator. - -The maxPooling2d with index operation calculates the output and the mask -based on the input, ksize, strides, and paddings parameters. Input(X) and -output(Out, Mask) 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. -Parameters(ksize, strides, paddings) are two elements. -These two elements represent height and width, respectively. -The input(X) size and output(Out, Mask) size may be different. - -Example: - Input: - X shape: $(N, C, H_{in}, W_{in})$ - Output: - Out shape: $(N, C, H_{out}, W_{out})$ - Mask shape: $(N, C, H_{out}, W_{out})$ - Where - $$ - 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 - $$ - - For adaptive = true: - $$ - H_{out} = ksize[0] W_{out} = ksize[1] - $$ - - -)DOC"); - } -}; - -class MaxPool3dWithIndexOpMaker : public framework::OpProtoAndCheckerMaker { - public: - void Make() override { - 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 are the depth, height and " - "width of " - "the image, respectively"); - AddOutput("Out", - "(Tensor) The output tensor of pooling operator. " - "The format of output tensor is also NCDHW, " - "where N is the batch size, C is the number of channels, " - "and D, H and W are the depth, height and " - "width of the image, respectively."); - AddOutput("Mask", - "(Tensor) The Mask tensor of pooling operator. " - "The format of output tensor is also NCDHW, " - "where N is the batch size, C is the number of channels, and " - "D, H and W are the depth, height and width " - "of the image, respectively. " - "It represents the index in the current feature map."); - - AddAttr>("ksize", - "(vector) The pooling window size(depth, " - "height, width) of pooling operator. " - "If global_pooling = true, ksize and paddings " - "will be ignored."); // TODO(Chengduo): Add - // checker. (Currently, - // TypedAttrChecker don't support vector type.) - AddAttr( - "global_pooling", - "(bool, default false) Whether to use the global pooling. " - "If global_pooling = true, ksize and paddings will be ignored.") - .SetDefault(false); - AddAttr( - "adaptive", - "(bool, default False) When true, will perform adaptive pooling " - "instead, " - "output shape in H and W dimensions will be same as ksize, input data " - "will be divided into grids specify by ksize averagely and perform " - "pooling in each grid area to get output pooling value.") - .SetDefault(false); - AddAttr>("strides", - "(vector, default {1,1,1}), strides(depth, " - "height, width) of pooling operator.") - .SetDefault({1, 1, 1}); // TODO(Chengduo): Add checker. (Currently, - // TypedAttrChecker don't support vector type.) - AddAttr>( - "paddings", - "(vector, default {0,0,0}), paddings(depth, " - "height, width) of pooling operator. " - "If global_pooling = true, paddings and ksize will be ignored.") - .SetDefault({0, 0, 0}); // TODO(Chengduo): Add checker. (Currently, - // TypedAttrChecker don't support vector type.) - - AddComment(R"DOC( -MaxPool3d Operator. - -The maxpooling3d with index operation calculates the output and the mask -based on the input and ksize, strides, paddings parameters. -Input(X) and output(Out, Mask) 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, Mask) size may be different. - -Example: - Input: - X shape: $(N, C, D_{in}, H_{in}, W_{in})$ - Output: - Out shape: $(N, C, D_{out}, H_{out}, W_{out})$ - Mask shape: $(N, C, D_{out}, H_{out}, W_{out})$ - 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 - $$ - - For adaptive = true: - $$ - D_{out} = ksize[0] H_{out} = ksize[1] W_{out} = ksize[2] - $$ - -)DOC"); - } -}; - -template -class MaxPoolWithIndexGradOpMaker : public framework::SingleGradOpMaker { - public: - using framework::SingleGradOpMaker::SingleGradOpMaker; - - protected: - void Apply(GradOpPtr op) const override { - op->SetType(this->ForwardOpType() + "_grad"); - op->SetAttrMap(this->Attrs()); - op->SetInput("X", this->Input("X")); - op->SetInput("Mask", this->Output("Mask")); - op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); - } -}; - -DECLARE_NO_NEED_BUFFER_VARS_INFERER( - MaxPoolWithIndexOpGradNoNeedBufferVarsInferer, "X"); - -} // namespace operators -} // namespace paddle - -namespace ops = paddle::operators; - -DECLARE_INFER_SHAPE_FUNCTOR(max_pool2d_with_index, - MaxPool2dWithIndexInferShapeFunctor, - PD_INFER_META(phi::MaxPoolWithIndexInferMeta)); -DECLARE_INFER_SHAPE_FUNCTOR(max_pool2d_with_index_grad, - MaxPool2dWithIndexGradInferShapeFunctor, - PD_INFER_META(phi::MaxPoolWithIndexGradInferMeta)); - -REGISTER_OPERATOR(max_pool2d_with_index, - ops::MaxPoolWithIndexOp, - ops::MaxPool2dWithIndexOpMaker, - ops::MaxPoolWithIndexGradOpMaker, - ops::MaxPoolWithIndexGradOpMaker, - MaxPool2dWithIndexInferShapeFunctor); -REGISTER_OPERATOR(max_pool2d_with_index_grad, - ops::MaxPoolWithIndexOpGrad, - ops::MaxPoolWithIndexOpGradNoNeedBufferVarsInferer, - MaxPool2dWithIndexGradInferShapeFunctor); - -DECLARE_INFER_SHAPE_FUNCTOR(max_pool3d_with_index, - MaxPool3dWithIndexInferShapeFunctor, - PD_INFER_META(phi::MaxPoolWithIndexInferMeta)); -DECLARE_INFER_SHAPE_FUNCTOR(max_pool3d_with_index_grad, - MaxPool3dWithIndexGradInferShapeFunctor, - PD_INFER_META(phi::MaxPoolWithIndexGradInferMeta)); - -REGISTER_OPERATOR(max_pool3d_with_index, - ops::MaxPoolWithIndexOp, - ops::MaxPool3dWithIndexOpMaker, - ops::MaxPoolWithIndexGradOpMaker, - ops::MaxPoolWithIndexGradOpMaker, - MaxPool3dWithIndexInferShapeFunctor); -REGISTER_OPERATOR(max_pool3d_with_index_grad, - ops::MaxPoolWithIndexOpGrad, - ops::MaxPoolWithIndexOpGradNoNeedBufferVarsInferer, - MaxPool3dWithIndexGradInferShapeFunctor); diff --git a/paddle/phi/api/yaml/backward.yaml b/paddle/phi/api/yaml/backward.yaml index 6faf2d0ba7a49b607830f56202edbf716b339ee7..9a31d8fb3e3b1adde5382638a8dfbace11c8aa34 100644 --- a/paddle/phi/api/yaml/backward.yaml +++ b/paddle/phi/api/yaml/backward.yaml @@ -1092,6 +1092,24 @@ kernel : func : matrix_power_grad +- backward_op : max_pool2d_with_index_grad + forward : max_pool2d_with_index(Tensor x, int[] kernel_size, int[] strides = {1, 1}, int[] paddings = {0, 0}, bool global_pooling = false, bool adaptive = false) -> Tensor(out), Tensor(mask) + args : (Tensor x, Tensor mask, Tensor out_grad, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive) + output : Tensor(x_grad) + infer_meta : + func : MaxPoolWithIndexGradInferMeta + kernel : + func : max_pool2d_with_index_grad + +- backward_op : max_pool3d_with_index_grad + forward : max_pool3d_with_index(Tensor x, int[] kernel_size, int[] strides = {1, 1, 1}, int[] paddings = {0, 0, 0}, bool global_pooling = false, bool adaptive = false) -> Tensor(out), Tensor(mask) + args : (Tensor x, Tensor mask, Tensor out_grad, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive) + output : Tensor(x_grad) + infer_meta : + func : MaxPoolWithIndexGradInferMeta + kernel : + func : max_pool3d_with_index_grad + - backward_op : maxout_grad forward : maxout(Tensor x, int groups, int axis) -> Tensor(out) args : (Tensor x, Tensor out, Tensor out_grad, int groups, int axis) diff --git a/paddle/phi/api/yaml/legacy_backward.yaml b/paddle/phi/api/yaml/legacy_backward.yaml index c80e79e3ff207140435a28c4903386571d4ac747..590acb5b35b93086f6e26604ea81d3f1ddee07ab 100755 --- a/paddle/phi/api/yaml/legacy_backward.yaml +++ b/paddle/phi/api/yaml/legacy_backward.yaml @@ -557,24 +557,6 @@ func : max_grad composite : max_grad(x, out, out_grad, axis, keepdim, reduce_all, x_grad) -- backward_op : max_pool2d_with_index_grad - forward : max_pool2d_with_index(Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive) -> Tensor(out), Tensor(mask) - args : (Tensor x, Tensor mask, Tensor out_grad, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive) - output : Tensor(x_grad) - infer_meta : - func : MaxPoolWithIndexGradInferMeta - kernel : - func : max_pool2d_with_index_grad - -- backward_op : max_pool3d_with_index_grad - forward : max_pool3d_with_index(Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive) -> Tensor(out), Tensor(mask) - args : (Tensor x, Tensor mask, Tensor out_grad, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive) - output : Tensor(x_grad) - infer_meta : - func : MaxPoolWithIndexGradInferMeta - kernel : - func : max_pool3d_with_index_grad - - backward_op : maximum_grad forward : maximum(Tensor x, Tensor y) -> Tensor(out) args : (Tensor x, Tensor y, Tensor out_grad) diff --git a/paddle/phi/api/yaml/legacy_ops.yaml b/paddle/phi/api/yaml/legacy_ops.yaml index 5bb3e8d0d73e7458634785a152d048ef406d36cf..257d67c3477eeec4d28cd9854812c33f3e11d4c7 100755 --- a/paddle/phi/api/yaml/legacy_ops.yaml +++ b/paddle/phi/api/yaml/legacy_ops.yaml @@ -732,24 +732,6 @@ func : max backward : max_grad -- op : max_pool2d_with_index - args : (Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive) - output : Tensor(out), Tensor(mask) - infer_meta : - func : MaxPoolWithIndexInferMeta - kernel : - func : max_pool2d_with_index - backward : max_pool2d_with_index_grad - -- op : max_pool3d_with_index - args : (Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive) - output : Tensor(out), Tensor(mask) - infer_meta : - func : MaxPoolWithIndexInferMeta - kernel : - func : max_pool3d_with_index - backward : max_pool3d_with_index_grad - - op : maximum args : (Tensor x, Tensor y) output : Tensor(out) diff --git a/paddle/phi/api/yaml/op_compat.yaml b/paddle/phi/api/yaml/op_compat.yaml index 68778a1c856022aa9003ad06cb5632709376dcf9..17e56bd2a0e909ef5677511e33f934f5b0210f44 100755 --- a/paddle/phi/api/yaml/op_compat.yaml +++ b/paddle/phi/api/yaml/op_compat.yaml @@ -1469,6 +1469,22 @@ extra : attrs : [bool use_mkldnn = false] +- op : max_pool2d_with_index + inputs : + {x : X} + outputs : + {out : Out, mask : Mask} + attrs : + kernel_size : ksize + +- op : max_pool3d_with_index + inputs : + {x : X} + outputs : + {out : Out, mask : Mask} + attrs : + kernel_size : ksize + - op : maximum (elementwise_max) backward : maximum_grad (elementwise_max_grad) extra : diff --git a/paddle/phi/api/yaml/ops.yaml b/paddle/phi/api/yaml/ops.yaml index 8fc8c4c9b081c91c2ed03e57e4496712c068c987..8d99f741567365bfbceece851c20795d7fdcf6f1 100644 --- a/paddle/phi/api/yaml/ops.yaml +++ b/paddle/phi/api/yaml/ops.yaml @@ -1271,6 +1271,24 @@ func : matrix_power backward : matrix_power_grad +- op : max_pool2d_with_index + args : (Tensor x, int[] kernel_size, int[] strides= {1, 1}, int[] paddings = {0, 0}, bool global_pooling = false, bool adaptive = false) + output : Tensor(out), Tensor(mask) + infer_meta : + func : MaxPoolWithIndexInferMeta + kernel : + func : max_pool2d_with_index + backward : max_pool2d_with_index_grad + +- op : max_pool3d_with_index + args : (Tensor x, int[] kernel_size, int[] strides = {1, 1, 1}, int[] paddings = {0, 0, 0}, bool global_pooling = false, bool adaptive = false) + output : Tensor(out), Tensor(mask) + infer_meta : + func : MaxPoolWithIndexInferMeta + kernel : + func : max_pool3d_with_index + backward : max_pool3d_with_index_grad + - op : maxout args : (Tensor x, int groups, int axis = 1) output : Tensor(out) diff --git a/paddle/phi/ops/compat/pool_sig.cc b/paddle/phi/ops/compat/pool_sig.cc index b807b21a1c0b1c2dfd6d60208a5b263a653fc47b..8bbb1d63c29ad542f7ac533f298e8b2881544c34 100644 --- a/paddle/phi/ops/compat/pool_sig.cc +++ b/paddle/phi/ops/compat/pool_sig.cc @@ -65,24 +65,6 @@ KernelSignature Pool2dDoubleGradOpArgumentMapping( {"Out"}); } -KernelSignature MaxPool2dWithIndexOpArgumentMapping( - const ArgumentMappingContext& ctx) { - return KernelSignature( - "max_pool2d_with_index", - {"X"}, - {"ksize", "strides", "paddings", "global_pooling", "adaptive"}, - {"Out", "Mask"}); -} - -KernelSignature MaxPool2dWithIndexGradOpArgumentMapping( - const ArgumentMappingContext& ctx) { - return KernelSignature( - "max_pool2d_with_index_grad", - {"X", "Mask", "Out@GRAD"}, - {"ksize", "strides", "paddings", "global_pooling", "adaptive"}, - {"X@GRAD"}); -} - KernelSignature Pool3dOpArgumentMapping(const ArgumentMappingContext& ctx) { return KernelSignature("pool3d", {"X"}, @@ -115,24 +97,6 @@ KernelSignature Pool3dGradOpArgumentMapping(const ArgumentMappingContext& ctx) { {"X@GRAD"}); } -KernelSignature MaxPool3dWithIndexOpArgumentMapping( - const ArgumentMappingContext& ctx) { - return KernelSignature( - "max_pool3d_with_index", - {"X"}, - {"ksize", "strides", "paddings", "global_pooling", "adaptive"}, - {"Out", "Mask"}); -} - -KernelSignature MaxPool3dWithIndexGradOpArgumentMapping( - const ArgumentMappingContext& ctx) { - return KernelSignature( - "max_pool3d_with_index_grad", - {"X", "Mask", "Out@GRAD"}, - {"ksize", "strides", "paddings", "global_pooling", "adaptive"}, - {"X@GRAD"}); -} - } // namespace phi PD_REGISTER_ARG_MAPPING_FN(pool2d, phi::Pool2dOpArgumentMapping); @@ -140,15 +104,5 @@ PD_REGISTER_ARG_MAPPING_FN(pool2d_grad, phi::Pool2dGradOpArgumentMapping); PD_REGISTER_ARG_MAPPING_FN(pool2d_double_grad, phi::Pool2dDoubleGradOpArgumentMapping); -PD_REGISTER_ARG_MAPPING_FN(max_pool2d_with_index, - phi::MaxPool2dWithIndexOpArgumentMapping); -PD_REGISTER_ARG_MAPPING_FN(max_pool2d_with_index_grad, - phi::MaxPool2dWithIndexGradOpArgumentMapping); - PD_REGISTER_ARG_MAPPING_FN(pool3d, phi::Pool3dOpArgumentMapping); PD_REGISTER_ARG_MAPPING_FN(pool3d_grad, phi::Pool3dGradOpArgumentMapping); - -PD_REGISTER_ARG_MAPPING_FN(max_pool3d_with_index, - phi::MaxPool3dWithIndexOpArgumentMapping); -PD_REGISTER_ARG_MAPPING_FN(max_pool3d_with_index_grad, - phi::MaxPool3dWithIndexGradOpArgumentMapping);