spp_op.h 6.7 KB
Newer Older
S
sweetsky0901 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/* 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
#include "paddle/framework/op_registry.h"
#include "paddle/operators/math/math_function.h"
#include "paddle/operators/math/pooling.h"
#include "paddle/operators/strided_memcpy.h"

namespace paddle {
namespace operators {
S
sweetsky0901 已提交
23
template <typename DeviceContext, typename T>
S
sweetsky0901 已提交
24 25 26 27 28 29 30 31 32 33 34 35 36
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");
    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 已提交
37 38 39 40 41 42
      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 已提交
43 44
      std::vector<int> paddings({padding_h, padding_w});
      // pooling output shape
S
sweetsky0901 已提交
45
      framework::Tensor out_level;
S
sweetsky0901 已提交
46 47
      std::vector<int64_t> output_shape_vec(
          {in_x->dims()[0], in_x->dims()[1], bins, bins});
S
sweetsky0901 已提交
48 49 50
      framework::DDim output_shape(framework::make_ddim(output_shape_vec));
      out_level.mutable_data<T>(output_shape, context.GetPlace());
      // pooling
S
sweetsky0901 已提交
51
      math::Pool2dFunctor<DeviceContext, math::MaxPool<T>, T> pool_forward;
S
sweetsky0901 已提交
52
      math::MaxPool<T> max_process;
S
sweetsky0901 已提交
53 54
      pool_forward(context.template device_context<DeviceContext>(), *in_x,
                   kernel_size, strides, paddings, max_process, &out_level);
S
sweetsky0901 已提交
55 56 57 58 59 60
      // 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 已提交
61
      out_level.Resize(output_flatten_shape);
S
sweetsky0901 已提交
62
      // concat
S
sweetsky0901 已提交
63 64 65
      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 已提交
66
                       out_stride, out->data<T>() + output_offset);
S
sweetsky0901 已提交
67
      output_offset += out_level.dims()[1] * out_level_stride[1];
S
sweetsky0901 已提交
68 69 70
    }
  }
};
S
sweetsky0901 已提交
71
template <typename DeviceContext, typename T>
S
sweetsky0901 已提交
72 73 74 75 76 77 78 79 80
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 已提交
81
    int pyramid_height = context.template Attr<int>("pyramid_height");
S
sweetsky0901 已提交
82 83
    auto& device_ctx = context.template device_context<DeviceContext>();
    math::SetConstant<DeviceContext, T> zero;
S
sweetsky0901 已提交
84 85 86 87 88 89 90 91
    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 已提交
92 93 94 95 96 97
      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 已提交
98
      std::vector<int> paddings({padding_h, padding_w});
S
sweetsky0901 已提交
99
      // split out and outgrad  ...  to flatten
S
sweetsky0901 已提交
100 101
      framework::Tensor out_level;
      framework::Tensor outgrad_level;
S
sweetsky0901 已提交
102 103 104 105 106
      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 已提交
107 108 109
      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 已提交
110
      // memcpy
S
sweetsky0901 已提交
111 112 113
      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 已提交
114

S
sweetsky0901 已提交
115
      StridedMemcpy<T>(context.template device_context<DeviceContext>(),
S
sweetsky0901 已提交
116
                       out_grad->data<T>() + out_offset, out_stride,
S
sweetsky0901 已提交
117 118 119
                       outgrad_level.dims(), flatten_stride,
                       outgrad_level.data<T>());
      out_offset += out_level.dims()[1] * out_stride[1];
S
sweetsky0901 已提交
120
      // flatten backward to nchw
S
sweetsky0901 已提交
121

S
sweetsky0901 已提交
122
      std::vector<int64_t> out_shape_vec({in_x->dims()[0], in_x->dims()[1]});
S
sweetsky0901 已提交
123 124 125 126
      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 已提交
127
      framework::DDim out_shape(framework::make_ddim(out_shape_vec));
S
sweetsky0901 已提交
128
      out_level.ShareDataWith(out_level);
S
sweetsky0901 已提交
129
      out_level.Resize(out_shape);
S
sweetsky0901 已提交
130
      outgrad_level.ShareDataWith(outgrad_level);
S
sweetsky0901 已提交
131
      outgrad_level.Resize(out_shape);
S
sweetsky0901 已提交
132
      // pooling backward
S
sweetsky0901 已提交
133 134 135 136
      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);
S
sweetsky0901 已提交
137 138 139 140 141
    }
  }
};
}  // namespace operators
}  // namespace paddle