spp_op.cc 4.1 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
S
sweetsky0901 已提交
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.
Indicesou 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/spp_op.h"
16 17
#include <string>
#include <vector>
S
sweetsky0901 已提交
18 19 20 21 22
namespace paddle {
namespace operators {

class SppOpMaker : public framework::OpProtoAndCheckerMaker {
 public:
Y
Yu Yang 已提交
23
  void Make() override {
S
sweetsky0901 已提交
24 25 26 27 28 29 30 31 32
    AddInput(
        "X",
        "(Tensor) The input tensor of spp 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.");
    AddOutput("Out",
              "(Tensor) The output tensor of spp operator."
              "N * M."
              "M = C * H * W");
S
sweetsky0901 已提交
33
    AddAttr<int>("pyramid_height", "(int), multi level pooling");
S
sweetsky0901 已提交
34 35 36 37 38
    AddAttr<std::string>(
        "pooling_type",
        "(string), pooling type, can be \"max\" for max-pooling "
        "and \"avg\" for average-pooling.")
        .InEnum({"max", "avg"});
S
sweetsky0901 已提交
39
    AddComment(R"DOC(
S
sweetsky0901 已提交
40 41 42 43 44 45 46 47 48
        "With spatial pyramid pooling, the input image can
        be of any sizes. This not only allows arbitrary aspect
        ratios, but also allows arbitrary scales. We can resize
        the input image to any scale (e.g., min(w, h)=180, 224,
        ...) and apply the same deep network. When the
        input image is at different scales, the network (with
        the same filter sizes) will extract features at different
        scales. The scales play important roles in traditional
        methods.
S
sweetsky0901 已提交
49
        Input shape: $(N, C_{in}, H_{in}, W_{in})$
S
sweetsky0901 已提交
50 51 52
        Output shape: $(H_{out}, W_{out})$
        Where
          $$
S
sweetsky0901 已提交
53
            H_{out} = N \\
S
sweetsky0901 已提交
54
            W_{out} = (((4^pyramid_height) - 1) / (4 - 1))$ * C_{in}
S
sweetsky0901 已提交
55
          $$
S
sweetsky0901 已提交
56
        paper https://arxiv.org/pdf/1406.4729v4.pdf
S
sweetsky0901 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
        )DOC");
  }
};

class SppOp : public framework::OperatorWithKernel {
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;
  void InferShape(framework::InferShapeContext* ctx) const override {
    PADDLE_ENFORCE(ctx->HasInput("X"),
                   "Input(X) of SppOp"
                   "should not be null.");
    PADDLE_ENFORCE(ctx->HasOutput("Out"),
                   "Output(Out) of SppOp should not be null.");
    auto in_x_dims = ctx->GetInputDim("X");
    int pyramid_height = ctx->Attrs().Get<int>("pyramid_height");
    PADDLE_ENFORCE(in_x_dims.size() == 4,
                   "Spping intput must be of 4-dimensional.");
S
sweetsky0901 已提交
74
    int outlen = ((std::pow(4, pyramid_height) - 1) / (4 - 1)) * in_x_dims[1];
S
sweetsky0901 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
    std::vector<int64_t> output_shape({in_x_dims[0], outlen});
    ctx->SetOutputDim("Out", framework::make_ddim(output_shape));
  }
};

class SppOpGrad : public framework::OperatorWithKernel {
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;
  void InferShape(framework::InferShapeContext* ctx) const override {
    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"));
  }
};
}  // namespace operators
}  // namespace paddle

namespace ops = paddle::operators;
Y
Yang Yang 已提交
94
REGISTER_OPERATOR(spp, ops::SppOp, ops::SppOpMaker,
95 96
                  paddle::framework::DefaultGradOpDescMaker<true>);
REGISTER_OPERATOR(spp_grad, ops::SppOpGrad);
S
sweetsky0901 已提交
97 98 99 100 101 102
REGISTER_OP_CPU_KERNEL(
    spp, ops::SppKernel<paddle::platform::CPUDeviceContext, float>,
    ops::SppKernel<paddle::platform::CPUDeviceContext, double>);
REGISTER_OP_CPU_KERNEL(
    spp_grad, ops::SppGradKernel<paddle::platform::CPUDeviceContext, float>,
    ops::SppGradKernel<paddle::platform::CPUDeviceContext, double>);