spp_op.h 7.7 KB
Newer Older
S
sweetsky0901 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/* 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.
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. */

#pragma once
Y
Yi Wang 已提交
16 17 18 19
#include "paddle/fluid/framework/op_registry.h"
#include "paddle/fluid/operators/math/math_function.h"
#include "paddle/fluid/operators/math/pooling.h"
#include "paddle/fluid/operators/strided_memcpy.h"
S
sweetsky0901 已提交
20 21 22

namespace paddle {
namespace operators {
S
sweetsky0901 已提交
23
template <typename DeviceContext, typename T>
S
sweetsky0901 已提交
24 25 26 27 28 29
class SppKernel : public framework::OpKernel<T> {
 public:
  void Compute(const framework::ExecutionContext& context) const override {
    const framework::Tensor* in_x = context.Input<framework::Tensor>("X");
    auto* out = context.Output<framework::Tensor>("Out");
    int pyramid_height = context.template Attr<int>("pyramid_height");
S
sweetsky0901 已提交
30 31
    std::string pooling_type =
        context.template Attr<std::string>("pooling_type");
S
sweetsky0901 已提交
32 33 34 35 36 37 38
    out->mutable_data<T>(context.GetPlace());
    auto out_stride = framework::stride(out->dims());
    int input_h = in_x->dims()[2];
    int input_w = in_x->dims()[3];
    size_t output_offset = 0;
    for (int p = 0; p < pyramid_height; ++p) {
      int bins = std::pow(2, p);
S
sweetsky0901 已提交
39 40 41 42 43 44
      int kernel_size_h = std::ceil(input_h / static_cast<double>(bins));
      int kernel_size_w = std::ceil(input_w / static_cast<double>(bins));
      int padding_h = (kernel_size_h * bins - input_h + 1) / 2;
      int padding_w = (kernel_size_w * bins - input_w + 1) / 2;
      std::vector<int> kernel_size({kernel_size_h, kernel_size_w});
      std::vector<int> strides({kernel_size_h, kernel_size_w});
S
sweetsky0901 已提交
45 46
      std::vector<int> paddings({padding_h, padding_w});
      // pooling output shape
S
sweetsky0901 已提交
47
      framework::Tensor out_level;
S
sweetsky0901 已提交
48 49
      std::vector<int64_t> output_shape_vec(
          {in_x->dims()[0], in_x->dims()[1], bins, bins});
S
sweetsky0901 已提交
50 51 52
      framework::DDim output_shape(framework::make_ddim(output_shape_vec));
      out_level.mutable_data<T>(output_shape, context.GetPlace());
      // pooling
S
sweetsky0901 已提交
53 54 55 56 57 58 59 60 61 62 63
      if (pooling_type == "max") {
        math::Pool2dFunctor<DeviceContext, math::MaxPool<T>, T> pool_forward;
        math::MaxPool<T> max_process;
        pool_forward(context.template device_context<DeviceContext>(), *in_x,
                     kernel_size, strides, paddings, max_process, &out_level);
      } else if (pooling_type == "avg") {
        math::Pool2dFunctor<DeviceContext, math::AvgPool<T>, T> pool_forward;
        math::AvgPool<T> avg_process;
        pool_forward(context.template device_context<DeviceContext>(), *in_x,
                     kernel_size, strides, paddings, avg_process, &out_level);
      }
S
sweetsky0901 已提交
64 65 66 67 68 69
      // flatten pooling output shape
      int output_flatten_w = in_x->dims()[1] * bins * bins;
      std::vector<int64_t> output_flatten_shape_vec(
          {in_x->dims()[0], output_flatten_w});
      framework::DDim output_flatten_shape(
          framework::make_ddim(output_flatten_shape_vec));
S
sweetsky0901 已提交
70
      out_level.Resize(output_flatten_shape);
S
sweetsky0901 已提交
71
      // concat
S
sweetsky0901 已提交
72 73 74
      auto out_level_stride = framework::stride(out_level.dims());
      StridedMemcpy<T>(context.template device_context<DeviceContext>(),
                       out_level.data<T>(), out_level_stride, out_level.dims(),
S
sweetsky0901 已提交
75
                       out_stride, out->data<T>() + output_offset);
S
sweetsky0901 已提交
76
      output_offset += out_level.dims()[1] * out_level_stride[1];
S
sweetsky0901 已提交
77 78 79
    }
  }
};
S
sweetsky0901 已提交
80
template <typename DeviceContext, typename T>
S
sweetsky0901 已提交
81 82 83 84 85 86 87 88 89
class SppGradKernel : public framework::OpKernel<T> {
 public:
  void Compute(const framework::ExecutionContext& context) const override {
    const framework::Tensor* in_x = context.Input<framework::Tensor>("X");
    const framework::Tensor* out = context.Input<framework::Tensor>("Out");
    const framework::Tensor* out_grad =
        context.Input<framework::Tensor>(framework::GradVarName("Out"));
    framework::Tensor* in_x_grad =
        context.Output<framework::Tensor>(framework::GradVarName("X"));
S
sweetsky0901 已提交
90
    int pyramid_height = context.template Attr<int>("pyramid_height");
S
sweetsky0901 已提交
91 92
    std::string pooling_type =
        context.template Attr<std::string>("pooling_type");
S
sweetsky0901 已提交
93 94
    auto& device_ctx = context.template device_context<DeviceContext>();
    math::SetConstant<DeviceContext, T> zero;
S
sweetsky0901 已提交
95 96 97 98 99 100 101 102
    in_x_grad->mutable_data<T>(context.GetPlace());
    zero(device_ctx, in_x_grad, static_cast<T>(0));
    auto out_stride = framework::stride(out->dims());
    int input_h = in_x->dims()[2];
    int input_w = in_x->dims()[3];
    size_t out_offset = 0;
    for (int p = 0; p < pyramid_height; ++p) {
      int bins = std::pow(2, p);
S
sweetsky0901 已提交
103 104 105 106 107 108
      int kernel_size_h = std::ceil(input_h / static_cast<double>(bins));
      int kernel_size_w = std::ceil(input_w / static_cast<double>(bins));
      int padding_h = (kernel_size_h * bins - input_h + 1) / 2;
      int padding_w = (kernel_size_w * bins - input_w + 1) / 2;
      std::vector<int> kernel_size({kernel_size_h, kernel_size_w});
      std::vector<int> strides({kernel_size_h, kernel_size_w});
S
sweetsky0901 已提交
109
      std::vector<int> paddings({padding_h, padding_w});
S
sweetsky0901 已提交
110
      // split out and outgrad  ...  to flatten
S
sweetsky0901 已提交
111 112
      framework::Tensor out_level;
      framework::Tensor outgrad_level;
S
sweetsky0901 已提交
113 114 115 116 117
      int out_flatten_w = in_x->dims()[1] * bins * bins;
      std::vector<int64_t> out_flatten_shape_vec(
          {in_x->dims()[0], out_flatten_w});
      framework::DDim out_flatten_shape(
          framework::make_ddim(out_flatten_shape_vec));
S
sweetsky0901 已提交
118 119 120
      out_level.mutable_data<T>(out_flatten_shape, context.GetPlace());
      outgrad_level.mutable_data<T>(out_flatten_shape, context.GetPlace());
      auto flatten_stride = framework::stride(out_level.dims());
S
sweetsky0901 已提交
121
      // memcpy
S
sweetsky0901 已提交
122 123 124
      StridedMemcpy<T>(context.template device_context<DeviceContext>(),
                       out->data<T>() + out_offset, out_stride,
                       out_level.dims(), flatten_stride, out_level.data<T>());
S
sweetsky0901 已提交
125

S
sweetsky0901 已提交
126
      StridedMemcpy<T>(context.template device_context<DeviceContext>(),
S
sweetsky0901 已提交
127
                       out_grad->data<T>() + out_offset, out_stride,
S
sweetsky0901 已提交
128 129 130
                       outgrad_level.dims(), flatten_stride,
                       outgrad_level.data<T>());
      out_offset += out_level.dims()[1] * out_stride[1];
S
sweetsky0901 已提交
131
      // flatten backward to nchw
S
sweetsky0901 已提交
132

S
sweetsky0901 已提交
133
      std::vector<int64_t> out_shape_vec({in_x->dims()[0], in_x->dims()[1]});
S
sweetsky0901 已提交
134 135 136 137
      out_shape_vec.push_back(
          (input_h - kernel_size_h + 2 * padding_h) / kernel_size_h + 1);
      out_shape_vec.push_back(
          (input_w - kernel_size_w + 2 * padding_w) / kernel_size_w + 1);
S
sweetsky0901 已提交
138
      framework::DDim out_shape(framework::make_ddim(out_shape_vec));
S
sweetsky0901 已提交
139
      out_level.ShareDataWith(out_level);
S
sweetsky0901 已提交
140
      out_level.Resize(out_shape);
S
sweetsky0901 已提交
141
      outgrad_level.ShareDataWith(outgrad_level);
S
sweetsky0901 已提交
142
      outgrad_level.Resize(out_shape);
S
sweetsky0901 已提交
143
      // pooling backward
S
sweetsky0901 已提交
144 145 146 147 148 149 150 151 152 153
      if (pooling_type == "max") {
        math::MaxPool2dGradFunctor<DeviceContext, T> pool2d_backward;
        pool2d_backward(context.template device_context<DeviceContext>(), *in_x,
                        *&out_level, *&outgrad_level, kernel_size, strides,
                        paddings, in_x_grad);
      } else if (pooling_type == "avg") {
        math::Pool2dGradFunctor<DeviceContext, math::AvgPoolGrad<T>, T>
            pool_backward;
        math::AvgPoolGrad<T> avg_process;
        pool_backward(context.template device_context<DeviceContext>(), *in_x,
S
sweetsky0901 已提交
154
                      *&out_level, *&outgrad_level, kernel_size, strides,
S
sweetsky0901 已提交
155 156
                      paddings, avg_process, in_x_grad);
      }
S
sweetsky0901 已提交
157 158 159 160 161
    }
  }
};
}  // namespace operators
}  // namespace paddle