autogen code support for max_pool[2,3]_with_index op (#53359)

paddle/fluid/operators/pool_with_index_op.cc

-/* 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 <memory>
-
-#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<std::vector<int>>("ksize",
-                              "(vector<int>) 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<bool>(
-        "global_pooling",
-        "(bool, default:false) Whether to use the global pooling. "
-        "If global_pooling = true, ksize and paddings will be ignored.")
-        .SetDefault(false);
-    AddAttr<bool>(
-        "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<std::vector<int>>("strides",
-                              "(vector<int>, default {1, 1}), strides(height, "
-                              "width) of pooling operator.")
-        .SetDefault({1, 1});  // TODO(Chengduo): Add checker. (Currently,
-    // TypedAttrChecker don't support vector type.)
-    AddAttr<std::vector<int>>(
-        "paddings",
-        "(vector<int>, 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<std::vector<int>>("ksize",
-                              "(vector<int>) 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<bool>(
-        "global_pooling",
-        "(bool, default false) Whether to use the global pooling. "
-        "If global_pooling = true, ksize and paddings will be ignored.")
-        .SetDefault(false);
-    AddAttr<bool>(
-        "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<std::vector<int>>("strides",
-                              "(vector<int>, 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<std::vector<int>>(
-        "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 <typename T>
-class MaxPoolWithIndexGradOpMaker : public framework::SingleGradOpMaker<T> {
- public:
-  using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
-
- protected:
-  void Apply(GradOpPtr<T> 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<paddle::framework::OpDesc>,
-                  ops::MaxPoolWithIndexGradOpMaker<paddle::imperative::OpBase>,
-                  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<paddle::framework::OpDesc>,
-                  ops::MaxPoolWithIndexGradOpMaker<paddle::imperative::OpBase>,
-                  MaxPool3dWithIndexInferShapeFunctor);
-REGISTER_OPERATOR(max_pool3d_with_index_grad,
-                  ops::MaxPoolWithIndexOpGrad,
-                  ops::MaxPoolWithIndexOpGradNoNeedBufferVarsInferer,
-                  MaxPool3dWithIndexGradInferShapeFunctor);

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)

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)

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)

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 :

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)

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);