chore: import upstream snapshot with attribution

paddle/phi/kernels/cpu/psroi_pool_grad_kernel.cc

@@ -0,0 +1,144 @@
+// Copyright (c) 2022 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 "paddle/phi/kernels/psroi_pool_grad_kernel.h"
+
+#include <algorithm>
+
+#include "paddle/phi/core/kernel_registry.h"
+#include "paddle/phi/kernels/funcs/math_function.h"
+
+namespace phi {
+
+template <typename T, typename Context>
+void PsroiPoolGradKernel(const Context& dev_ctx,
+                         const DenseTensor& x,
+                         const DenseTensor& rois,
+                         const optional<DenseTensor>& rois_num,
+                         const DenseTensor& dout,
+                         int pooled_height,
+                         int pooled_width,
+                         int output_channels,
+                         float spatial_scale,
+                         DenseTensor* dx) {
+  if (dx) {
+    const auto& in_dims = x.dims();
+    int64_t input_channels = in_dims[1];
+    int64_t height = in_dims[2];
+    int64_t width = in_dims[3];
+    int64_t rois_num_t = rois.dims()[0];
+
+    // set roi batch id
+    DenseTensor rois_batch_id_list;
+    rois_batch_id_list.Resize({rois_num_t});
+    int* rois_batch_id_data = dev_ctx.template Alloc<int>(&rois_batch_id_list);
+    int64_t rois_batch_size = 0;
+    if (rois_num.get_ptr()) {
+      rois_batch_size = rois_num->numel();
+      auto* rois_num_t_data = rois_num->data<int>();
+      int64_t start = 0;
+      for (int64_t n = 0; n < rois_batch_size; ++n) {
+        for (int64_t i = start; i < start + rois_num_t_data[n]; ++i) {
+          rois_batch_id_data[i] = n;
+        }
+        start += rois_num_t_data[n];
+      }
+    } else {
+      auto rois_lod = rois.lod().back();
+      rois_batch_size = static_cast<int64_t>(rois_lod.size()) - 1;
+      // calculate batch id index for each roi according to LoD
+      for (int64_t n = 0; n < rois_batch_size; ++n) {
+        for (size_t i = rois_lod[n]; i < rois_lod[n + 1]; ++i) {
+          rois_batch_id_data[i] = n;
+        }
+      }
+    }
+    const T* input_rois = rois.data<T>();
+    const T* dout_data = dout.data<T>();
+    T* dx_data = dev_ctx.template Alloc<T>(dx);
+
+    // set gradient of X to be 0. before backpropagate.
+    funcs::SetConstant<Context, T> set_zero;
+    set_zero(dev_ctx, dx, static_cast<T>(0));
+
+    // backpropagate gradient per output pixel
+    int64_t dout_size = dout.numel();
+    for (int64_t i = 0; i < dout_size; ++i) {
+      // The output is in order (n, c, ph, pw)
+      int64_t pw = i % pooled_width;
+      int64_t ph = (i / pooled_width) % pooled_height;
+      int64_t c = (i / pooled_width / pooled_height) % output_channels;
+      int64_t n = i / pooled_width / pooled_height / output_channels;
+
+      // set roi_batch_id
+      int64_t roi_batch_id = rois_batch_id_data[n];
+      int64_t input_channel =
+          (static_cast<int64_t>(c) * pooled_height + ph) * pooled_width + pw;
+      int64_t input_offset =
+          (static_cast<int64_t>(roi_batch_id) * input_channels +
+           input_channel) *
+          height * width;
+      T* offset_dx_data = dx_data + input_offset;
+
+      // [start, end) interval for spatial sampling
+      const T* offset_input_rois = input_rois + static_cast<int64_t>(n) * 4;
+      T roi_start_w =
+          static_cast<T>(round(offset_input_rois[0])) * spatial_scale;
+      T roi_start_h =
+          static_cast<T>(round(offset_input_rois[1])) * spatial_scale;
+      T roi_end_w =
+          static_cast<T>(round(offset_input_rois[2]) + 1.) * spatial_scale;
+      T roi_end_h =
+          static_cast<T>(round(offset_input_rois[3]) + 1.) * spatial_scale;
+
+      // Force too small ROIs to be 1x1
+      T roi_height = std::max(roi_end_h - roi_start_h, (T)0.1);  // avoid 0
+      T roi_width = std::max(roi_end_w - roi_start_w, (T)0.1);
+
+      // Compute w and h at input feature map
+      T bin_size_h = roi_height / static_cast<T>(pooled_height);
+      T bin_size_w = roi_width / static_cast<T>(pooled_width);
+
+      int64_t hstart = floor(bin_size_h * static_cast<T>(ph) + roi_start_h);
+      int64_t wstart = floor(bin_size_w * static_cast<T>(pw) + roi_start_w);
+      int64_t hend = ceil(bin_size_h * static_cast<T>(ph + 1) + roi_start_h);
+      int64_t wend = ceil(bin_size_w * static_cast<T>(pw + 1) + roi_start_w);
+
+      // Add roi offsets and clip to input boundaries
+      hstart = std::min(std::max(hstart, static_cast<int64_t>(0)), height);
+      hend = std::min(std::max(hend, static_cast<int64_t>(0)), height);
+      wstart = std::min(std::max(wstart, static_cast<int64_t>(0)), width);
+      wend = std::min(std::max(wend, static_cast<int64_t>(0)), width);
+      bool is_empty = (hend <= hstart) || (wend <= wstart);
+
+      // Accumulate diff_val into input data
+      T bin_area =
+          static_cast<T>(static_cast<int64_t>(hend - hstart) * (wend - wstart));
+      T diff_val = is_empty ? 0. : dout_data[i] / bin_area;
+      for (int64_t ih = hstart; ih < hend; ++ih) {
+        for (int64_t iw = wstart; iw < wend; ++iw) {
+          int64_t input_index = static_cast<int64_t>(ih) * width + iw;
+          offset_dx_data[input_index] += diff_val;
+        }
+      }
+    }
+  }
+}
+
+}  // namespace phi
+
+PD_REGISTER_KERNEL(
+    psroi_pool_grad, CPU, ALL_LAYOUT, phi::PsroiPoolGradKernel, float, double) {
+  kernel->InputAt(2).SetDataType(phi::CppTypeToDataType<int>::Type());
+}