Compute Library
 21.02
ROIAlignLayer.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018-2020 Arm Limited.
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to
8  * deal in the Software without restriction, including without limitation the
9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10  * sell copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24 #include "ROIAlignLayer.h"
25 
26 #include "arm_compute/core/Types.h"
29 
30 #include <algorithm>
31 
32 namespace arm_compute
33 {
34 namespace test
35 {
36 namespace validation
37 {
38 namespace reference
39 {
40 namespace
41 {
42 /** Average pooling over an aligned window */
43 inline float roi_align_1x1(const float *input, TensorShape input_shape,
44  float region_start_x,
45  float bin_size_x,
46  int grid_size_x,
47  float region_end_x,
48  float region_start_y,
49  float bin_size_y,
50  int grid_size_y,
51  float region_end_y,
52  int pz)
53 {
54  if((region_end_x <= region_start_x) || (region_end_y <= region_start_y))
55  {
56  return 0;
57  }
58  else
59  {
60  float avg = 0;
61  // Iterate through the aligned pooling region
62  for(int iy = 0; iy < grid_size_y; ++iy)
63  {
64  for(int ix = 0; ix < grid_size_x; ++ix)
65  {
66  // Align the window in the middle of every bin
67  float y = region_start_y + (iy + 0.5) * bin_size_y / float(grid_size_y);
68  float x = region_start_x + (ix + 0.5) * bin_size_x / float(grid_size_x);
69 
70  // Interpolation in the [0,0] [0,1] [1,0] [1,1] square
71  const int y_low = y;
72  const int x_low = x;
73  const int y_high = y_low + 1;
74  const int x_high = x_low + 1;
75 
76  const float ly = y - y_low;
77  const float lx = x - x_low;
78  const float hy = 1. - ly;
79  const float hx = 1. - lx;
80 
81  const float w1 = hy * hx;
82  const float w2 = hy * lx;
83  const float w3 = ly * hx;
84  const float w4 = ly * lx;
85 
86  const size_t idx1 = coord2index(input_shape, Coordinates(x_low, y_low, pz));
87  float data1 = input[idx1];
88 
89  const size_t idx2 = coord2index(input_shape, Coordinates(x_high, y_low, pz));
90  float data2 = input[idx2];
91 
92  const size_t idx3 = coord2index(input_shape, Coordinates(x_low, y_high, pz));
93  float data3 = input[idx3];
94 
95  const size_t idx4 = coord2index(input_shape, Coordinates(x_high, y_high, pz));
96  float data4 = input[idx4];
97 
98  avg += w1 * data1 + w2 * data2 + w3 * data3 + w4 * data4;
99  }
100  }
101 
102  avg /= grid_size_x * grid_size_y;
103 
104  return avg;
105  }
106 }
107 
108 template <typename TI, typename TO>
109 SimpleTensor<TO> float_converter(const SimpleTensor<TI> &tensor, DataType dst_dt)
110 {
111  SimpleTensor<TO> dst{ tensor.shape(), dst_dt, 1, QuantizationInfo(), tensor.data_layout() };
112 #if defined(_OPENMP)
113  #pragma omp parallel for
114 #endif /* _OPENMP */
115  for(int i = 0; i < tensor.num_elements(); ++i)
116  {
117  dst[i] = tensor[i];
118  }
119  return dst;
120 }
121 
122 SimpleTensor<float> convert_rois_from_asymmetric(SimpleTensor<uint16_t> rois)
123 {
124  const UniformQuantizationInfo &quantization_info = rois.quantization_info().uniform();
125  SimpleTensor<float> dst{ rois.shape(), DataType::F32, 1, QuantizationInfo(), rois.data_layout() };
126 
127  for(int i = 0; i < rois.num_elements(); i += 5)
128  {
129  dst[i] = static_cast<float>(rois[i]); // batch idx
130  dst[i + 1] = dequantize_qasymm16(rois[i + 1], quantization_info);
131  dst[i + 2] = dequantize_qasymm16(rois[i + 2], quantization_info);
132  dst[i + 3] = dequantize_qasymm16(rois[i + 3], quantization_info);
133  dst[i + 4] = dequantize_qasymm16(rois[i + 4], quantization_info);
134  }
135  return dst;
136 }
137 } // namespace
138 
139 template <>
141 {
142  ARM_COMPUTE_UNUSED(output_qinfo);
143 
144  const size_t values_per_roi = rois.shape()[0];
145  const size_t num_rois = rois.shape()[1];
146  DataType dst_data_type = src.data_type();
147 
148  const auto *rois_ptr = static_cast<const float *>(rois.data());
149 
150  TensorShape input_shape = src.shape();
151  TensorShape output_shape(pool_info.pooled_width(), pool_info.pooled_height(), src.shape()[2], num_rois);
152  SimpleTensor<float> dst(output_shape, dst_data_type);
153 
154  // Iterate over every pixel of the input image
155  for(size_t px = 0; px < pool_info.pooled_width(); ++px)
156  {
157  for(size_t py = 0; py < pool_info.pooled_height(); ++py)
158  {
159  for(size_t pw = 0; pw < num_rois; ++pw)
160  {
161  const unsigned int roi_batch = rois_ptr[values_per_roi * pw];
162  const auto x1 = float(rois_ptr[values_per_roi * pw + 1]);
163  const auto y1 = float(rois_ptr[values_per_roi * pw + 2]);
164  const auto x2 = float(rois_ptr[values_per_roi * pw + 3]);
165  const auto y2 = float(rois_ptr[values_per_roi * pw + 4]);
166 
167  const float roi_anchor_x = x1 * pool_info.spatial_scale();
168  const float roi_anchor_y = y1 * pool_info.spatial_scale();
169  const float roi_dims_x = std::max((x2 - x1) * pool_info.spatial_scale(), 1.0f);
170  const float roi_dims_y = std::max((y2 - y1) * pool_info.spatial_scale(), 1.0f);
171 
172  float bin_size_x = roi_dims_x / pool_info.pooled_width();
173  float bin_size_y = roi_dims_y / pool_info.pooled_height();
174  float region_start_x = px * bin_size_x + roi_anchor_x;
175  float region_start_y = py * bin_size_y + roi_anchor_y;
176  float region_end_x = (px + 1) * bin_size_x + roi_anchor_x;
177  float region_end_y = (py + 1) * bin_size_y + roi_anchor_y;
178 
179  region_start_x = utility::clamp(region_start_x, 0.0f, float(input_shape[0]));
180  region_start_y = utility::clamp(region_start_y, 0.0f, float(input_shape[1]));
181  region_end_x = utility::clamp(region_end_x, 0.0f, float(input_shape[0]));
182  region_end_y = utility::clamp(region_end_y, 0.0f, float(input_shape[1]));
183 
184  const int roi_bin_grid_x = (pool_info.sampling_ratio() > 0) ? pool_info.sampling_ratio() : int(ceil(bin_size_x));
185  const int roi_bin_grid_y = (pool_info.sampling_ratio() > 0) ? pool_info.sampling_ratio() : int(ceil(bin_size_y));
186 
187  // Move input and output pointer across the fourth dimension
188  const size_t input_stride_w = input_shape[0] * input_shape[1] * input_shape[2];
189  const size_t output_stride_w = output_shape[0] * output_shape[1] * output_shape[2];
190  const float *input_ptr = src.data() + roi_batch * input_stride_w;
191  float *output_ptr = dst.data() + px + py * output_shape[0] + pw * output_stride_w;
192 
193  for(int pz = 0; pz < int(input_shape[2]); ++pz)
194  {
195  // For every pixel pool over an aligned region
196  *(output_ptr + pz * output_shape[0] * output_shape[1]) = roi_align_1x1(input_ptr, input_shape,
197  region_start_x,
198  bin_size_x,
199  roi_bin_grid_x,
200  region_end_x,
201  region_start_y,
202  bin_size_y,
203  roi_bin_grid_y,
204  region_end_y, pz);
205  }
206  }
207  }
208  }
209  return dst;
210 }
211 
212 template <>
214 {
215  SimpleTensor<float> src_tmp = float_converter<half, float>(src, DataType::F32);
216  SimpleTensor<float> rois_tmp = float_converter<half, float>(rois, DataType::F32);
217  SimpleTensor<float> dst_tmp = roi_align_layer<float, float>(src_tmp, rois_tmp, pool_info, output_qinfo);
218  SimpleTensor<half> dst = float_converter<float, half>(dst_tmp, DataType::F16);
219  return dst;
220 }
221 
222 template <>
224 {
226  SimpleTensor<float> rois_tmp = convert_rois_from_asymmetric(rois);
227  SimpleTensor<float> dst_tmp = roi_align_layer<float, float>(src_tmp, rois_tmp, pool_info, output_qinfo);
228  SimpleTensor<uint8_t> dst = convert_to_asymmetric<uint8_t>(dst_tmp, output_qinfo);
229  return dst;
230 }
231 template <>
233 {
235  SimpleTensor<float> rois_tmp = convert_rois_from_asymmetric(rois);
236  SimpleTensor<float> dst_tmp = roi_align_layer<float, float>(src_tmp, rois_tmp, pool_info, output_qinfo);
237  SimpleTensor<int8_t> dst = convert_to_asymmetric<int8_t>(dst_tmp, output_qinfo);
238  return dst;
239 }
240 } // namespace reference
241 } // namespace validation
242 } // namespace test
243 } // namespace arm_compute
input_data_type roi_align_1x1(const ITensor *input, unsigned int roi_batch, float region_start_x, float bin_size_x, int grid_size_x, float region_end_x, float region_start_y, float bin_size_y, int grid_size_y, float region_end_y, int pz)
Average pooling over an aligned window.
Shape of a tensor.
Definition: TensorShape.h:39
1 channel, 1 F32 per channel
DataType data_type() const override
Data type of the tensor.
Definition: SimpleTensor.h:357
SimpleTensor< float > convert_from_asymmetric(const SimpleTensor< uint8_t > &src)
Definition: Helpers.cpp:112
TensorShape shape() const override
Shape of the tensor.
Definition: SimpleTensor.h:320
unsigned int pooled_width() const
Get the pooled width of the layer.
Definition: Types.h:1324
SimpleTensor< float > src
Definition: DFT.cpp:155
Copyright (c) 2017-2021 Arm Limited.
int coord2index(const TensorShape &shape, const Coordinates &coord)
Linearise the given coordinate.
Definition: Utils.h:489
1 channel, 1 F16 per channel
DataType clamp(const DataType &n, const DataType &lower=std::numeric_limits< RangeType >::lowest(), const DataType &upper=std::numeric_limits< RangeType >::max())
Performs clamping among a lower and upper value.
Definition: Utility.h:99
float dequantize_qasymm16(uint16_t value, const UniformQuantizationInfo &qinfo)
Dequantize a value given a 16-bit asymmetric quantization scheme.
Quantization information.
TensorShape input_shape
Validate test suite is to test ARM_COMPUTE_RETURN_ON_* macros we use to check the validity of given a...
#define ARM_COMPUTE_UNUSED(...)
To avoid unused variables warnings.
Definition: Error.h:152
unsigned int sampling_ratio() const
Get sampling ratio.
Definition: Types.h:1339
Simple tensor object that stores elements in a consecutive chunk of memory.
Definition: SimpleTensor.h:58
unsigned int pooled_height() const
Get the pooled height of the layer.
Definition: Types.h:1329
ROI Pooling Layer Information class.
Definition: Types.h:1309
float spatial_scale() const
Get the spatial scale.
Definition: Types.h:1334
DataType
Available data types.
Definition: Types.h:77
SimpleTensor< float > roi_align_layer(const SimpleTensor< float > &src, const SimpleTensor< float > &rois, const ROIPoolingLayerInfo &pool_info, const QuantizationInfo &output_qinfo)
const T * data() const
Constant pointer to the underlying buffer.
Definition: SimpleTensor.h:418