Compute Library
 20.08
Utils.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016-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 
26 
27 #include "arm_compute/core/Utils.h"
28 
29 #include <algorithm>
30 #include <cmath>
31 #include <cstdint>
32 #include <fstream>
33 #include <map>
34 #include <string>
35 
36 using namespace arm_compute;
37 
38 std::string arm_compute::read_file(const std::string &filename, bool binary)
39 {
40  std::string out;
41  std::ifstream fs;
42 
43 #ifndef ARM_COMPUTE_EXCEPTIONS_DISABLED
44  try
45  {
46 #endif /* ARM_COMPUTE_EXCEPTIONS_DISABLED */
47  fs.exceptions(std::ifstream::failbit | std::ifstream::badbit);
48  std::ios_base::openmode mode = std::ios::in;
49 
50  if(binary)
51  {
52  mode |= std::ios::binary;
53  }
54 
55  fs.open(filename, mode);
56 
57  // Go to the end of the file
58  fs.seekg(0, std::ios::end);
59  // Reserve the memory required to store the file's content
60  out.reserve(fs.tellg());
61  // Go back to the beginning of the file
62  fs.seekg(0, std::ios::beg);
63  // Copy the content of the file
64  out.assign(std::istreambuf_iterator<char>(fs), std::istreambuf_iterator<char>());
65 #ifndef ARM_COMPUTE_EXCEPTIONS_DISABLED
66  }
67  catch(const std::ifstream::failure &e)
68  {
69  ARM_COMPUTE_ERROR_VAR("Accessing %s: %s", filename.c_str(), e.what());
70  }
71 #endif /* ARM_COMPUTE_EXCEPTIONS_DISABLED */
72 
73  return out;
74 }
75 
76 const std::string &arm_compute::string_from_format(Format format)
77 {
78  static std::map<Format, const std::string> formats_map =
79  {
80  { Format::UNKNOWN, "UNKNOWN" },
81  { Format::U8, "U8" },
82  { Format::S16, "S16" },
83  { Format::U16, "U16" },
84  { Format::S32, "S32" },
85  { Format::U32, "U32" },
86  { Format::F16, "F16" },
87  { Format::F32, "F32" },
88  { Format::UV88, "UV88" },
89  { Format::RGB888, "RGB888" },
90  { Format::RGBA8888, "RGBA8888" },
91  { Format::YUV444, "YUV444" },
92  { Format::YUYV422, "YUYV422" },
93  { Format::NV12, "NV12" },
94  { Format::NV21, "NV21" },
95  { Format::IYUV, "IYUV" },
96  { Format::UYVY422, "UYVY422" }
97  };
98 
99  return formats_map[format];
100 }
101 
102 const std::string &arm_compute::string_from_channel(Channel channel)
103 {
104  static std::map<Channel, const std::string> channels_map =
105  {
106  { Channel::UNKNOWN, "UNKNOWN" },
107  { Channel::R, "R" },
108  { Channel::G, "G" },
109  { Channel::B, "B" },
110  { Channel::A, "A" },
111  { Channel::Y, "Y" },
112  { Channel::U, "U" },
113  { Channel::V, "V" },
114  { Channel::C0, "C0" },
115  { Channel::C1, "C1" },
116  { Channel::C2, "C2" },
117  { Channel::C3, "C3" }
118  };
119 
120  return channels_map[channel];
121 }
122 
124 {
125  static std::map<DataLayout, const std::string> dl_map =
126  {
127  { DataLayout::UNKNOWN, "UNKNOWN" },
128  { DataLayout::NCHW, "NCHW" },
129  { DataLayout::NHWC, "NHWC" },
130  };
131 
132  return dl_map[dl];
133 }
134 
136 {
137  static std::map<DataType, const std::string> dt_map =
138  {
139  { DataType::UNKNOWN, "UNKNOWN" },
140  { DataType::S8, "S8" },
141  { DataType::U8, "U8" },
142  { DataType::S16, "S16" },
143  { DataType::U16, "U16" },
144  { DataType::S32, "S32" },
145  { DataType::U32, "U32" },
146  { DataType::S64, "S64" },
147  { DataType::U64, "U64" },
148  { DataType::F16, "F16" },
149  { DataType::F32, "F32" },
150  { DataType::F64, "F64" },
151  { DataType::SIZET, "SIZET" },
152  { DataType::QSYMM8, "QSYMM8" },
153  { DataType::QSYMM8_PER_CHANNEL, "QSYMM8_PER_CHANNEL" },
154  { DataType::QASYMM8, "QASYMM8" },
155  { DataType::QASYMM8_SIGNED, "QASYMM8_SIGNED" },
156  { DataType::QSYMM16, "QSYMM16" },
157  { DataType::QASYMM16, "QASYMM16" },
158  };
159 
160  return dt_map[dt];
161 }
162 
164 {
165  static std::map<ActivationLayerInfo::ActivationFunction, const std::string> act_map =
166  {
181 
182  };
183 
184  return act_map[act];
185 }
186 
188 {
189  static std::map<MatrixPattern, const std::string> pattern_map =
190  {
191  { MatrixPattern::BOX, "BOX" },
192  { MatrixPattern::CROSS, "CROSS" },
193  { MatrixPattern::DISK, "DISK" },
194  { MatrixPattern::OTHER, "OTHER" },
195  };
196 
197  return pattern_map[pattern];
198 }
199 
201 {
202  static std::map<NonLinearFilterFunction, const std::string> func_map =
203  {
204  { NonLinearFilterFunction::MAX, "MAX" },
205  { NonLinearFilterFunction::MEDIAN, "MEDIAN" },
206  { NonLinearFilterFunction::MIN, "MIN" },
207  };
208 
209  return func_map[function];
210 }
211 
213 {
214  static std::map<InterpolationPolicy, const std::string> interpolation_policy_map =
215  {
216  { InterpolationPolicy::AREA, "AREA" },
217  { InterpolationPolicy::BILINEAR, "BILINEAR" },
218  { InterpolationPolicy::NEAREST_NEIGHBOR, "NEAREST_NEIGHBOUR" },
219  };
220 
221  return interpolation_policy_map[policy];
222 }
223 
225 {
226  static std::map<BorderMode, const std::string> border_mode_map =
227  {
228  { BorderMode::UNDEFINED, "UNDEFINED" },
229  { BorderMode::CONSTANT, "CONSTANT" },
230  { BorderMode::REPLICATE, "REPLICATE" },
231  };
232 
233  return border_mode_map[border_mode];
234 }
235 
237 {
238  static std::map<NormType, const std::string> norm_type_map =
239  {
240  { NormType::IN_MAP_1D, "IN_MAP_1D" },
241  { NormType::IN_MAP_2D, "IN_MAP_2D" },
242  { NormType::CROSS_MAP, "CROSS_MAP" },
243  };
244 
245  return norm_type_map[type];
246 }
247 
249 {
250  static std::map<PoolingType, const std::string> pool_type_map =
251  {
252  { PoolingType::MAX, "MAX" },
253  { PoolingType::AVG, "AVG" },
254  { PoolingType::L2, "L2" },
255  };
256 
257  return pool_type_map[type];
258 }
259 
261 {
262  static std::map<GEMMLowpOutputStageType, const std::string> output_stage_map =
263  {
265  { GEMMLowpOutputStageType::QUANTIZE_DOWN, "quantize_down" },
266  { GEMMLowpOutputStageType::QUANTIZE_DOWN_FIXEDPOINT, "quantize_down_fixedpoint" },
267  { GEMMLowpOutputStageType::QUANTIZE_DOWN_FLOAT, "quantize_down_float" }
268  };
269 
270  return output_stage_map[output_stage];
271 }
272 
274 {
275  std::stringstream ss;
276  std::string converted_string;
277 
278  switch(data_type)
279  {
280  case DataType::U8:
281  case DataType::QASYMM8:
282  // Needs conversion to 32 bit, otherwise interpreted as ASCII values
283  ss << uint32_t(value.get<uint8_t>());
284  converted_string = ss.str();
285  break;
286  case DataType::S8:
289  // Needs conversion to 32 bit, otherwise interpreted as ASCII values
290  ss << int32_t(value.get<int8_t>());
291  converted_string = ss.str();
292  break;
293  case DataType::U16:
294  case DataType::QASYMM16:
295  ss << value.get<uint16_t>();
296  converted_string = ss.str();
297  break;
298  case DataType::S16:
299  case DataType::QSYMM16:
300  ss << value.get<int16_t>();
301  converted_string = ss.str();
302  break;
303  case DataType::U32:
304  ss << value.get<uint32_t>();
305  converted_string = ss.str();
306  break;
307  case DataType::S32:
308  ss << value.get<int32_t>();
309  converted_string = ss.str();
310  break;
311  case DataType::F32:
312  converted_string = float_to_string_with_full_precision(value.get<float>());
313  break;
314  case DataType::F16:
315  static_assert(sizeof(half) == 2, "Half must be 16 bit");
316  ss << value.get<half>();
317  converted_string = ss.str();
318  break;
319  default:
320  ARM_COMPUTE_ERROR("Not handled");
321  }
322 
323  return converted_string;
324 }
325 
326 std::string arm_compute::lower_string(const std::string &val)
327 {
328  std::string res = val;
329  std::transform(res.begin(), res.end(), res.begin(), ::tolower);
330  return res;
331 }
332 
334  const DimensionRoundingType &rounding_type)
335 {
336  const auto &strides = conv_info.stride();
337  ARM_COMPUTE_ERROR_ON_MSG((strides.first < 1 || strides.second < 1), "Stride values should be greater than or equal to 1.");
338 
341  const unsigned int in_width = input_shape[width_idx];
342  const unsigned int in_height = input_shape[height_idx];
343  const unsigned int kernel_width = weights_shape[width_idx];
344  const unsigned int kernel_height = weights_shape[height_idx];
345 
346  // Calculate output dimensions
347  const auto is_ceil = static_cast<unsigned int>(rounding_type == DimensionRoundingType::CEIL);
348  const unsigned int out_width = ((in_width - is_ceil) + strides.first - 1) / strides.first + is_ceil;
349  const unsigned int out_height = ((in_height - is_ceil) + strides.second - 1) / strides.second + is_ceil;
350 
351  // Calculate effective weights sizes
352  const int real_weight_width = (kernel_width - 1) * dilation.x() + 1;
353  const int real_weight_height = (kernel_height - 1) * dilation.y() + 1;
354 
355  // Calculate total pad
356  const int pad_width = std::max(0, static_cast<int>((out_width - 1) * strides.first + real_weight_width - in_width));
357  const int pad_height = std::max(0, static_cast<int>((out_height - 1) * strides.second + real_weight_height - in_height));
358 
359  // Calculate individual paddings
360  const unsigned int pad_left = pad_width / 2;
361  const unsigned int pad_top = pad_height / 2;
362  const unsigned int pad_right = pad_width - pad_left;
363  const unsigned int pad_bottom = pad_height - pad_top;
364 
365  PadStrideInfo same_info(strides.first, strides.second, pad_left, pad_right, pad_top, pad_bottom, rounding_type);
366 
367  // Check for correctness of predicted output shape against the one calculated using the generated info
368  const auto out_dims = scaled_dimensions(in_width, in_height, kernel_width, kernel_height, same_info, dilation);
369  ARM_COMPUTE_ERROR_ON(out_dims.first != out_width || out_dims.second != out_height);
370  ARM_COMPUTE_UNUSED(out_dims);
371 
372  return same_info;
373 }
374 
375 std::pair<unsigned int, unsigned int> arm_compute::deconvolution_output_dimensions(unsigned int in_width, unsigned int in_height,
376  unsigned int kernel_width, unsigned int kernel_height,
377  const PadStrideInfo &pad_stride_info)
378 {
379  const unsigned int pad_left = pad_stride_info.pad_left();
380  const unsigned int pad_top = pad_stride_info.pad_top();
381  const unsigned int pad_right = pad_stride_info.pad_right();
382  const unsigned int pad_bottom = pad_stride_info.pad_bottom();
383  const unsigned int stride_x = pad_stride_info.stride().first;
384  const unsigned int stride_y = pad_stride_info.stride().second;
385 
386  ARM_COMPUTE_ERROR_ON(in_width < 1 || in_height < 1);
387  ARM_COMPUTE_ERROR_ON(((in_width - 1) * stride_x + kernel_width) < (pad_left + pad_right));
388  ARM_COMPUTE_ERROR_ON(((in_height - 1) * stride_y + kernel_height) < (pad_top + pad_bottom));
389  const int w = stride_x * (in_width - 1) + kernel_width - (pad_left + pad_right);
390  const int h = stride_y * (in_height - 1) + kernel_height - (pad_top + pad_bottom);
391 
392  return std::make_pair<unsigned int, unsigned int>(w, h);
393 }
394 
395 std::pair<unsigned int, unsigned int> arm_compute::scaled_dimensions(int width, int height,
396  int kernel_width, int kernel_height,
397  const PadStrideInfo &pad_stride_info,
398  const Size2D &dilation)
399 {
400  const int dilation_x = dilation.x();
401  const int dilation_y = dilation.y();
402  const int pad_left = pad_stride_info.pad_left();
403  const int pad_top = pad_stride_info.pad_top();
404  const int pad_right = pad_stride_info.pad_right();
405  const int pad_bottom = pad_stride_info.pad_bottom();
406  const int stride_x = pad_stride_info.stride().first;
407  const int stride_y = pad_stride_info.stride().second;
408  int w = 0;
409  int h = 0;
410  switch(pad_stride_info.round())
411  {
413  w = static_cast<int>(std::floor((static_cast<float>(width + pad_left + pad_right - (dilation_x * (kernel_width - 1) + 1)) / stride_x) + 1));
414  h = static_cast<int>(std::floor((static_cast<float>(height + pad_top + pad_bottom - (dilation_y * (kernel_height - 1) + 1)) / stride_y) + 1));
415  break;
417  w = static_cast<int>(std::ceil((static_cast<float>(width + pad_left + pad_right - (dilation_x * (kernel_width - 1) + 1)) / stride_x) + 1));
418  h = static_cast<int>(std::ceil((static_cast<float>(height + pad_top + pad_bottom - (dilation_y * (kernel_height - 1) + 1)) / stride_y) + 1));
419  break;
420  default:
421  ARM_COMPUTE_ERROR("Unsupported rounding type");
422  }
423 
424  w = std::max(1, w);
425  h = std::max(1, h);
426  return std::make_pair(static_cast<unsigned int>(w), static_cast<unsigned int>(h));
427 }
428 
430 {
431  const bool is_min_max = (op == ReductionOperation::MAX || op == ReductionOperation::MIN);
432  const bool is_quantized_type = is_data_type_quantized(dt);
433  const bool is_first_dim = (axis == 0);
434 
435  return !is_first_dim || is_min_max || is_quantized_type;
436 }
437 
439 {
440  // Note: Output quantization info for softmax should always have
441  // * Softmax with QASYMM8: scale = 1/256, offset = 0
442  // * Softmax with QASYMM8_SIGNED: scale = 1/256, offset = -128
443  // * LogSoftmax with QASYMM8: scale = 1/256, offset = 0
444  // * LogSoftmax with QASYMM8_SIGNED: scale = 16/256, offset = 127
446  {
447  if(is_log)
448  {
449  return QuantizationInfo(16.f / 256, 127);
450  }
451  else
452  {
453  return QuantizationInfo(1.f / 256, -128);
454  }
455  }
456  return QuantizationInfo(1.f / 256, 0);
457 }
458 
460 {
461  const bool is_qasymm8_signed = is_data_type_quantized_asymmetric_signed(data_type);
462  const auto a = act_info.a();
463  const auto b = act_info.b();
464  const int a_int = is_qasymm8_signed ? quantize_qasymm8_signed(a, oq_info) : quantize_qasymm8(a, oq_info);
465  const int b_int = is_qasymm8_signed ? quantize_qasymm8_signed(b, oq_info) : quantize_qasymm8(b, oq_info);
466  const auto type_max_value = std::get<1>(get_min_max(data_type)).get<int32_t>();
467 
468  const int32_t min_activation = act_info.activation() != ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU ? oq_info.offset : b_int;
469  const int32_t max_activation = act_info.activation() == ActivationLayerInfo::ActivationFunction::RELU ? type_max_value : a_int;
470 
471  return std::make_pair(min_activation, max_activation);
472 }
473 
474 #ifdef ARM_COMPUTE_ASSERTS_ENABLED
475 void arm_compute::print_consecutive_elements(std::ostream &s, DataType dt, const uint8_t *ptr, unsigned int n, int stream_width, const std::string &element_delim)
476 {
477  switch(dt)
478  {
479  case DataType::U8:
480  case DataType::QASYMM8:
481  print_consecutive_elements_impl<uint8_t>(s, ptr, n, stream_width, element_delim);
482  break;
483  case DataType::S8:
484  case DataType::QSYMM8:
487  print_consecutive_elements_impl<int8_t>(s, reinterpret_cast<const int8_t *>(ptr), n, stream_width, element_delim);
488  break;
489  case DataType::U16:
490  case DataType::QASYMM16:
491  print_consecutive_elements_impl<uint16_t>(s, reinterpret_cast<const uint16_t *>(ptr), n, stream_width, element_delim);
492  break;
493  case DataType::S16:
494  case DataType::QSYMM16:
495  print_consecutive_elements_impl<int16_t>(s, reinterpret_cast<const int16_t *>(ptr), n, stream_width, element_delim);
496  break;
497  case DataType::U32:
498  print_consecutive_elements_impl<uint32_t>(s, reinterpret_cast<const uint32_t *>(ptr), n, stream_width, element_delim);
499  break;
500  case DataType::S32:
501  print_consecutive_elements_impl<int32_t>(s, reinterpret_cast<const int32_t *>(ptr), n, stream_width, element_delim);
502  break;
503  case DataType::BFLOAT16:
504  print_consecutive_elements_impl<bfloat16>(s, reinterpret_cast<const bfloat16 *>(ptr), n, stream_width, element_delim);
505  break;
506  case DataType::F16:
507  print_consecutive_elements_impl<half>(s, reinterpret_cast<const half *>(ptr), n, stream_width, element_delim);
508  break;
509  case DataType::F32:
510  print_consecutive_elements_impl<float>(s, reinterpret_cast<const float *>(ptr), n, stream_width, element_delim);
511  break;
512  default:
513  ARM_COMPUTE_ERROR("Undefined element size for given data type");
514  }
515 }
516 
517 int arm_compute::max_consecutive_elements_display_width(std::ostream &s, DataType dt, const uint8_t *ptr, unsigned int n)
518 {
519  switch(dt)
520  {
521  case DataType::U8:
522  case DataType::QASYMM8:
523  return max_consecutive_elements_display_width_impl<uint8_t>(s, ptr, n);
524  case DataType::S8:
525  case DataType::QSYMM8:
528  return max_consecutive_elements_display_width_impl<int8_t>(s, reinterpret_cast<const int8_t *>(ptr), n);
529  case DataType::U16:
530  case DataType::QASYMM16:
531  return max_consecutive_elements_display_width_impl<uint16_t>(s, reinterpret_cast<const uint16_t *>(ptr), n);
532  case DataType::S16:
533  case DataType::QSYMM16:
534  return max_consecutive_elements_display_width_impl<int16_t>(s, reinterpret_cast<const int16_t *>(ptr), n);
535  case DataType::U32:
536  return max_consecutive_elements_display_width_impl<uint32_t>(s, reinterpret_cast<const uint32_t *>(ptr), n);
537  case DataType::S32:
538  return max_consecutive_elements_display_width_impl<int32_t>(s, reinterpret_cast<const int32_t *>(ptr), n);
539  case DataType::BFLOAT16:
540  return max_consecutive_elements_display_width_impl<bfloat16>(s, reinterpret_cast<const bfloat16 *>(ptr), n);
541  case DataType::F16:
542  return max_consecutive_elements_display_width_impl<half>(s, reinterpret_cast<const half *>(ptr), n);
543  case DataType::F32:
544  return max_consecutive_elements_display_width_impl<float>(s, reinterpret_cast<const float *>(ptr), n);
545  default:
546  ARM_COMPUTE_ERROR("Undefined element size for given data type");
547  }
548  return 0;
549 }
550 #endif /* ARM_COMPUTE_ASSERTS_ENABLED */
BorderMode
Methods available to handle borders.
Definition: Types.h:264
bool is_data_type_quantized(DataType dt)
Check if a given data type is of quantized type.
Definition: Utils.h:1121
bool needs_serialized_reduction(ReductionOperation op, DataType dt, unsigned int axis)
Check if the given reduction operation should be handled in a serial way.
Definition: Utils.cpp:429
Class describing the value of a pixel for any image format.
Definition: PixelValue.h:34
A single plane of 32-bit macro pixel of U0, Y0, V0, Y1 byte.
InterpolationPolicy
Interpolation method.
Definition: Types.h:369
SimpleTensor< float > w
Definition: DFT.cpp:156
Second channel (used by formats with unknown channel types).
Shape of a tensor.
Definition: TensorShape.h:39
const DataLayout data_layout
Definition: Im2Col.cpp:146
Quantize using a fixed point multiplication.
DimensionRoundingType round() const
Get the rounding type.
Definition: Types.h:784
quantized, symmetric fixed-point 16-bit number
ReductionOperation
Available reduction operations.
Definition: Types.h:498
const std::string & string_from_matrix_pattern(MatrixPattern pattern)
Convert a matrix pattern into a string.
Definition: Utils.cpp:187
SimpleTensor< float > b
Definition: DFT.cpp:157
const std::string & string_from_channel(Channel channel)
Convert a channel identity into a string.
Definition: Utils.cpp:102
uint8_t quantize_qasymm8(float value, const INFO_TYPE &qinfo, RoundingPolicy rounding_policy=RoundingPolicy::TO_NEAREST_UP)
Quantize a value given an unsigned 8-bit asymmetric quantization scheme.
std::pair< unsigned int, unsigned int > deconvolution_output_dimensions(unsigned int in_width, unsigned int in_height, unsigned int kernel_width, unsigned int kernel_height, const PadStrideInfo &pad_stride_info)
Returns expected width and height of the deconvolution's output tensor.
Definition: Utils.cpp:375
Cr/V/Value channel.
#define ARM_COMPUTE_ERROR(msg)
Print the given message then throw an std::runtime_error.
Definition: Error.h:352
1 channel, 1 U8 per channel
float a() const
Get the alpha value.
Definition: Types.h:1557
void get(uint8_t &v) const
Interpret the pixel value as a U8.
Definition: PixelValue.h:241
half_float::half half
16-bit floating point type
Definition: Types.h:46
1 channel, 1 F32 per channel
DimensionRoundingType
Dimension rounding type when down-scaling on CNNs.
Definition: Types.h:570
Unknown channel format.
Output values are defined by bilinear interpolation between the pixels.
#define ARM_COMPUTE_ERROR_VAR(msg,...)
Print the given message then throw an std::runtime_error.
Definition: Error.h:346
std::string string_from_pixel_value(const PixelValue &value, const DataType data_type)
Convert a PixelValue to a string, represented through the specific data type.
Definition: Utils.cpp:273
#define ARM_COMPUTE_ERROR_ON(cond)
If the condition is true then an error message is printed and an exception thrown.
Definition: Error.h:466
const std::string & string_from_activation_func(ActivationLayerInfo::ActivationFunction act)
Translates a given activation function to a string.
Definition: Utils.cpp:163
A 2 plane YUV format of Luma (Y) and interleaved UV data at 4:2:0 sampling.
QuantizationInfo get_softmax_output_quantization_info(DataType input_type, bool is_log)
Returns output quantization information for softmax layer.
Definition: Utils.cpp:438
Quantization info when assuming per layer quantization.
quantized, asymmetric fixed-point 16-bit number
1 channel, 1 U16 per channel
unsigned int pad_top() const
Get the top padding.
Definition: Types.h:773
Output values are defined to match the source pixel whose center is nearest to the sample position.
const std::string & string_from_gemmlowp_output_stage(GEMMLowpOutputStageType output_stage)
Translates a given GEMMLowp output stage to a string.
Definition: Utils.cpp:260
std::string lower_string(const std::string &val)
Lower a given string.
Definition: Utils.cpp:326
Activation Layer Information class.
Definition: Types.h:1517
A 2 plane YUV format of Luma (Y) and interleaved VU data at 4:2:0 sampling.
Copyright (c) 2017-2020 Arm Limited.
ActivationFunction
Available activation functions.
Definition: Types.h:1521
1 channel, 1 F16 per channel
std::pair< unsigned int, unsigned int > scaled_dimensions(int width, int height, int kernel_width, int kernel_height, const PadStrideInfo &pad_stride_info, const Size2D &dilation=Size2D(1U, 1U))
Returns expected width and height of output scaled tensor depending on dimensions rounding mode.
Definition: Utils.cpp:395
const std::string & string_from_norm_type(NormType type)
Translates a given normalization type to a string.
Definition: Utils.cpp:236
const std::string & string_from_border_mode(BorderMode border_mode)
Translates a given border mode policy to a string.
Definition: Utils.cpp:224
1 channel, 1 S32 per channel
16-bit brain floating-point number
signed 64-bit number
3 channels, 1 U8 per channel
std::string tolower(std::string string)
Convert string to lower case.
Definition: Utility.h:203
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...
const std::string & string_from_data_type(DataType dt)
Convert a data type identity into a string.
Definition: Utils.cpp:135
#define ARM_COMPUTE_UNUSED(...)
To avoid unused variables warnings.
Definition: Error.h:152
std::string read_file(const std::string &filename, bool binary)
Load an entire file in memory.
Definition: Utils.cpp:38
Third channel (used by formats with unknown channel types).
1 channel, 1 U32 per channel
std::string float_to_string_with_full_precision(float val)
Create a string with the float in full precision.
Definition: Utils.h:1215
Normalization applied within the same map in 1D region.
Channel
Available channels.
Definition: Types.h:464
Format
Image colour formats.
Definition: Types.h:54
std::pair< int32_t, int32_t > get_quantized_activation_min_max(ActivationLayerInfo act_info, DataType data_type, UniformQuantizationInfo oq_info)
Returns a pair of minimum and maximum values for a quantized activation.
Definition: Utils.cpp:459
int8_t quantize_qasymm8_signed(float value, const INFO_TYPE &qinfo, RoundingPolicy rounding_policy=RoundingPolicy::TO_NEAREST_UP)
Quantize a value given a signed 8-bit asymmetric quantization scheme.
quantized, asymmetric fixed-point 8-bit number unsigned
#define ARM_COMPUTE_ERROR_ON_MSG(cond, msg)
Definition: Error.h:456
std::pair< unsigned int, unsigned int > stride() const
Get the stride.
Definition: Types.h:737
const std::string & string_from_interpolation_policy(InterpolationPolicy policy)
Translates a given interpolation policy to a string.
Definition: Utils.cpp:212
bool is_data_type_quantized_asymmetric_signed(DataType dt)
Check if a given data type is of asymmetric quantized signed type.
Definition: Utils.h:1162
A 3 plane of 8 bit 4:4:4 sampled Y, U, V planes.
Fourth channel (used by formats with unknown channel types).
unsigned int pad_right() const
Get the right padding.
Definition: Types.h:768
const std::string & string_from_non_linear_filter_function(NonLinearFilterFunction function)
Translates a given non linear function to a string.
Definition: Utils.cpp:200
Quantize using a floating point multiplication.
Padding and stride information class.
Definition: Types.h:689
GEMMLowpOutputStageType
GEMMLowp output stage type.
Definition: Types.h:1872
Quantize using an integer multiplication.
1 channel, 1 S16 per channel
Output values are determined by averaging the source pixels whose areas fall under the area of the de...
quantized, symmetric fixed-point 8-bit number
Num samples, channels, height, width.
quantized, symmetric per channel fixed-point 8-bit number
A 3 plane of 8-bit 4:2:0 sampled Y, U, V planes.
4 channels, 1 U8 per channel
PoolingType
Available pooling types.
Definition: Types.h:577
const std::string & string_from_data_layout(DataLayout dl)
Convert a data layout identity into a string.
Definition: Utils.cpp:123
Borders are left undefined.
Pixels outside the image are assumed to have the same value as the closest image pixel.
Class for specifying the size of an image or rectangle.
Definition: Size2D.h:34
Num samples, height, width, channels.
2 channel, 1 U8 per channel
ActivationFunction activation() const
Get the type of activation function.
Definition: Types.h:1552
float b() const
Get the beta value.
Definition: Types.h:1562
quantized, asymmetric fixed-point 8-bit number signed
64-bit floating-point number
size_t get_data_layout_dimension_index(const DataLayout data_layout, const DataLayoutDimension data_layout_dimension)
Get the index of the given dimension.
Definition: Helpers.inl:332
unsigned int pad_bottom() const
Get the bottom padding.
Definition: Types.h:778
A single plane of 32-bit macro pixel of Y0, U0, Y1, V0 bytes.
unsigned 64-bit number
DataType
Available data types.
Definition: Types.h:77
unsigned int pad_left() const
Get the left padding.
Definition: Types.h:763
DataLayout
[DataLayout enum definition]
Definition: Types.h:120
const std::string & string_from_pooling_type(PoolingType type)
Translates a given pooling type to a string.
Definition: Utils.cpp:248
NormType
The normalization type used for the normalization layer.
Definition: Types.h:536
signed 8-bit number
MatrixPattern
Available matrix patterns.
Definition: Types.h:481
Normalization applied cross maps.
std::tuple< PixelValue, PixelValue > get_min_max(DataType dt)
Compute the mininum and maximum values a data type can take.
Definition: Utils.h:560
Any other matrix pattern.
NonLinearFilterFunction
Available non linear functions.
Definition: Types.h:490
Normalization applied within the same map in 2D region.
PadStrideInfo calculate_same_pad(TensorShape input_shape, TensorShape weights_shape, PadStrideInfo conv_info, DataLayout data_layout=DataLayout::NCHW, const Size2D &dilation=Size2D(1u, 1u), const DimensionRoundingType &rounding_type=DimensionRoundingType::FLOOR)
Calculate padding requirements in case of SAME padding.
Definition: Utils.cpp:333
const std::string & string_from_format(Format format)
Convert a tensor format into a string.
Definition: Utils.cpp:76