roi_pool_kernel.cpp 7.67 KB
Newer Older
1
2
#include <float.h>

3
4
#include <ATen/ATen.h>
#include <torch/library.h>
5
6
7
8
9

namespace vision {
namespace ops {

namespace {
10
11
12
13
14
15
16

template <class T>
inline void add(T* address, const T& val) {
  *address += val;
}

template <typename T>
17
void roi_pool_forward_kernel_impl(
18
19
    const T* input,
    const T spatial_scale,
20
21
22
23
24
    int channels,
    int height,
    int width,
    int pooled_height,
    int pooled_width,
25
    const T* rois,
26
    int num_rois,
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
    T* output,
    int* argmax_data) {
  for (int n = 0; n < num_rois; ++n) {
    const T* offset_rois = rois + n * 5;
    int roi_batch_ind = offset_rois[0];
    int roi_start_w = round(offset_rois[1] * spatial_scale);
    int roi_start_h = round(offset_rois[2] * spatial_scale);
    int roi_end_w = round(offset_rois[3] * spatial_scale);
    int roi_end_h = round(offset_rois[4] * spatial_scale);

    // Force malformed ROIs to be 1x1
    int roi_width = std::max(roi_end_w - roi_start_w + 1, 1);
    int roi_height = std::max(roi_end_h - roi_start_h + 1, 1);
    T bin_size_h = static_cast<T>(roi_height) / static_cast<T>(pooled_height);
    T bin_size_w = static_cast<T>(roi_width) / static_cast<T>(pooled_width);

    for (int ph = 0; ph < pooled_height; ++ph) {
      for (int pw = 0; pw < pooled_width; ++pw) {
        int hstart = static_cast<int>(floor(static_cast<T>(ph) * bin_size_h));
        int wstart = static_cast<int>(floor(static_cast<T>(pw) * bin_size_w));
        int hend = static_cast<int>(ceil(static_cast<T>(ph + 1) * bin_size_h));
        int wend = static_cast<int>(ceil(static_cast<T>(pw + 1) * bin_size_w));

        // Add roi offsets and clip to input boundaries
        hstart = std::min(std::max(hstart + roi_start_h, 0), height);
        hend = std::min(std::max(hend + roi_start_h, 0), height);
        wstart = std::min(std::max(wstart + roi_start_w, 0), width);
        wend = std::min(std::max(wend + roi_start_w, 0), width);
        bool is_empty = (hend <= hstart) || (wend <= wstart);

        for (int c = 0; c < channels; ++c) {
          // Define an empty pooling region to be zero
          T maxval = is_empty ? 0 : -FLT_MAX;
          // If nothing is pooled, argmax = -1 causes nothing to be backprop'd
          int maxidx = -1;

          const T* input_offset =
              input + (roi_batch_ind * channels + c) * height * width;

          for (int h = hstart; h < hend; ++h) {
            for (int w = wstart; w < wend; ++w) {
              int input_index = h * width + w;
              if (input_offset[input_index] > maxval) {
                maxval = input_offset[input_index];
                maxidx = input_index;
              }
            }
          }
          int index =
              ((n * channels + c) * pooled_height + ph) * pooled_width + pw;
          output[index] = maxval;
          argmax_data[index] = maxidx;
        } // channels
      } // pooled_width
    } // pooled_height
  } // num_rois
}

template <typename T>
86
void roi_pool_backward_kernel_impl(
87
88
    const T* grad_output,
    const int* argmax_data,
89
90
91
92
93
94
    int num_rois,
    int channels,
    int height,
    int width,
    int pooled_height,
    int pooled_width,
95
96
    T* grad_input,
    const T* rois,
97
98
99
100
    int n_stride,
    int c_stride,
    int h_stride,
    int w_stride) {
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
  for (int n = 0; n < num_rois; ++n) {
    const T* offset_rois = rois + n * 5;
    int roi_batch_ind = offset_rois[0];

    for (int c = 0; c < channels; ++c) {
      T* grad_input_offset =
          grad_input + ((roi_batch_ind * channels + c) * height * width);
      const int* argmax_data_offset =
          argmax_data + (n * channels + c) * pooled_height * pooled_width;

      for (int ph = 0; ph < pooled_height; ++ph) {
        for (int pw = 0; pw < pooled_width; ++pw) {
          int output_offset = n * n_stride + c * c_stride;
          int argmax = argmax_data_offset[ph * pooled_width + pw];

          if (argmax != -1) {
            add(grad_input_offset + argmax,
                static_cast<T>(
                    grad_output
                        [output_offset + ph * h_stride + pw * w_stride]));
          }
        } // pooled_width
      } // pooled_height
    } // channels
  } // num_rois
}

128
std::tuple<at::Tensor, at::Tensor> roi_pool_forward_kernel(
129
130
    const at::Tensor& input,
    const at::Tensor& rois,
131
132
133
    double spatial_scale,
    int64_t pooled_height,
    int64_t pooled_width) {
vfdev's avatar
vfdev committed
134
135
  TORCH_CHECK(input.device().is_cpu(), "input must be a CPU tensor");
  TORCH_CHECK(rois.device().is_cpu(), "rois must be a CPU tensor");
136
137
138

  at::TensorArg input_t{input, "input", 1}, rois_t{rois, "rois", 2};

139
  at::CheckedFrom c = "roi_pool_forward_kernel";
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
  at::checkAllSameType(c, {input_t, rois_t});

  int num_rois = rois.size(0);
  int channels = input.size(1);
  int height = input.size(2);
  int width = input.size(3);

  at::Tensor output = at::zeros(
      {num_rois, channels, pooled_height, pooled_width}, input.options());
  at::Tensor argmax = at::zeros(
      {num_rois, channels, pooled_height, pooled_width},
      input.options().dtype(at::kInt));

  if (output.numel() == 0) {
    return std::make_tuple(output, argmax);
  }

157
  auto input_ = input.contiguous(), rois_ = rois.contiguous();
158
  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
159
      input.scalar_type(), "roi_pool_forward_kernel", [&] {
160
        roi_pool_forward_kernel_impl<scalar_t>(
161
            input_.data_ptr<scalar_t>(),
162
163
164
165
166
167
            spatial_scale,
            channels,
            height,
            width,
            pooled_height,
            pooled_width,
168
            rois_.data_ptr<scalar_t>(),
169
170
171
172
            num_rois,
            output.data_ptr<scalar_t>(),
            argmax.data_ptr<int>());
      });
173
174
175
  return std::make_tuple(output, argmax);
}

176
at::Tensor roi_pool_backward_kernel(
177
178
179
    const at::Tensor& grad,
    const at::Tensor& rois,
    const at::Tensor& argmax,
180
181
182
183
184
185
186
    double spatial_scale,
    int64_t pooled_height,
    int64_t pooled_width,
    int64_t batch_size,
    int64_t channels,
    int64_t height,
    int64_t width) {
187
  // Check if input tensors are CPU tensors
vfdev's avatar
vfdev committed
188
189
190
191
192
  TORCH_CHECK(grad.device().is_cpu(), "grad must be a CPU tensor");
  TORCH_CHECK(rois.device().is_cpu(), "rois must be a CPU tensor");
  TORCH_CHECK(argmax.device().is_cpu(), "argmax must be a CPU tensor");
  TORCH_CHECK(
      rois.size(1) == 5, "Tensor rois should have shape as Tensor[K, 5]");
193
194
195

  at::TensorArg grad_t{grad, "grad", 1}, rois_t{rois, "rois", 2};

196
  at::CheckedFrom c = "roi_pool_backward_kernel";
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
  at::checkAllSameType(c, {grad_t, rois_t});

  auto num_rois = rois.size(0);

  at::Tensor grad_input =
      at::zeros({batch_size, channels, height, width}, grad.options());

  // handle possibly empty gradients
  if (grad.numel() == 0) {
    return grad_input;
  }

  // get stride values to ensure indexing into gradients is correct.
  int n_stride = grad.stride(0);
  int c_stride = grad.stride(1);
  int h_stride = grad.stride(2);
  int w_stride = grad.stride(3);

215
  auto rois_ = rois.contiguous();
216
  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
217
      grad.scalar_type(), "roi_pool_backward_kernel", [&] {
218
        roi_pool_backward_kernel_impl<scalar_t>(
219
220
221
222
223
224
225
226
227
            grad.data_ptr<scalar_t>(),
            argmax.data_ptr<int>(),
            num_rois,
            channels,
            height,
            width,
            pooled_height,
            pooled_width,
            grad_input.data_ptr<scalar_t>(),
228
            rois_.data_ptr<scalar_t>(),
229
230
231
232
233
            n_stride,
            c_stride,
            h_stride,
            w_stride);
      });
234
235
  return grad_input;
}
236

237
238
239
} // namespace

TORCH_LIBRARY_IMPL(torchvision, CPU, m) {
240
241
242
243
244
245
  m.impl(
      TORCH_SELECTIVE_NAME("torchvision::roi_pool"),
      TORCH_FN(roi_pool_forward_kernel));
  m.impl(
      TORCH_SELECTIVE_NAME("torchvision::_roi_pool_backward"),
      TORCH_FN(roi_pool_backward_kernel));
246
247
}

248
249
} // namespace ops
} // namespace vision