Compute Library
 21.08
Utils.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016-2021 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 namespace arm_compute
37 {
38 std::string 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 &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 &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 
135 const std::string &string_from_data_type(DataType dt)
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<InterpolationPolicy, const std::string> interpolation_policy_map =
190  {
191  { InterpolationPolicy::AREA, "AREA" },
192  { InterpolationPolicy::BILINEAR, "BILINEAR" },
193  { InterpolationPolicy::NEAREST_NEIGHBOR, "NEAREST_NEIGHBOUR" },
194  };
195 
196  return interpolation_policy_map[policy];
197 }
198 
199 const std::string &string_from_border_mode(BorderMode border_mode)
200 {
201  static std::map<BorderMode, const std::string> border_mode_map =
202  {
203  { BorderMode::UNDEFINED, "UNDEFINED" },
204  { BorderMode::CONSTANT, "CONSTANT" },
205  { BorderMode::REPLICATE, "REPLICATE" },
206  };
207 
208  return border_mode_map[border_mode];
209 }
210 
212 {
213  static std::map<NormType, const std::string> norm_type_map =
214  {
215  { NormType::IN_MAP_1D, "IN_MAP_1D" },
216  { NormType::IN_MAP_2D, "IN_MAP_2D" },
217  { NormType::CROSS_MAP, "CROSS_MAP" },
218  };
219 
220  return norm_type_map[type];
221 }
222 
224 {
225  static std::map<PoolingType, const std::string> pool_type_map =
226  {
227  { PoolingType::MAX, "MAX" },
228  { PoolingType::AVG, "AVG" },
229  { PoolingType::L2, "L2" },
230  };
231 
232  return pool_type_map[type];
233 }
234 
236 {
237  static std::map<GEMMLowpOutputStageType, const std::string> output_stage_map =
238  {
240  { GEMMLowpOutputStageType::QUANTIZE_DOWN, "quantize_down" },
241  { GEMMLowpOutputStageType::QUANTIZE_DOWN_FIXEDPOINT, "quantize_down_fixedpoint" },
242  { GEMMLowpOutputStageType::QUANTIZE_DOWN_FLOAT, "quantize_down_float" }
243  };
244 
245  return output_stage_map[output_stage];
246 }
247 
248 std::string string_from_pixel_value(const PixelValue &value, const DataType data_type)
249 {
250  std::stringstream ss;
251  std::string converted_string;
252 
253  switch(data_type)
254  {
255  case DataType::U8:
256  case DataType::QASYMM8:
257  // Needs conversion to 32 bit, otherwise interpreted as ASCII values
258  ss << uint32_t(value.get<uint8_t>());
259  converted_string = ss.str();
260  break;
261  case DataType::S8:
264  // Needs conversion to 32 bit, otherwise interpreted as ASCII values
265  ss << int32_t(value.get<int8_t>());
266  converted_string = ss.str();
267  break;
268  case DataType::U16:
269  case DataType::QASYMM16:
270  ss << value.get<uint16_t>();
271  converted_string = ss.str();
272  break;
273  case DataType::S16:
274  case DataType::QSYMM16:
275  ss << value.get<int16_t>();
276  converted_string = ss.str();
277  break;
278  case DataType::U32:
279  ss << value.get<uint32_t>();
280  converted_string = ss.str();
281  break;
282  case DataType::S32:
283  ss << value.get<int32_t>();
284  converted_string = ss.str();
285  break;
286  case DataType::F32:
287  converted_string = float_to_string_with_full_precision(value.get<float>());
288  break;
289  case DataType::F16:
290  static_assert(sizeof(half) == 2, "Half must be 16 bit");
291  ss << value.get<half>();
292  converted_string = ss.str();
293  break;
294  default:
295  ARM_COMPUTE_ERROR("Not handled");
296  }
297 
298  return converted_string;
299 }
300 
301 DataType data_type_from_name(const std::string &name)
302 {
303  static const std::map<std::string, DataType> data_types =
304  {
305  { "f16", DataType::F16 },
306  { "f32", DataType::F32 },
307  { "qasymm8", DataType::QASYMM8 },
308  { "qasymm8_signed", DataType::QASYMM8_SIGNED },
309  };
310 
311 #ifndef ARM_COMPUTE_EXCEPTIONS_DISABLED
312  try
313  {
314 #endif /* ARM_COMPUTE_EXCEPTIONS_DISABLED */
315  return data_types.at(utility::tolower(name));
316 
317 #ifndef ARM_COMPUTE_EXCEPTIONS_DISABLED
318  }
319  catch(const std::out_of_range &)
320  {
321  ARM_COMPUTE_ERROR_VAR("Invalid data type name: %s", name.c_str());
322  }
323 #endif /* ARM_COMPUTE_EXCEPTIONS_DISABLED */
324 }
325 
326 std::string 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 
339  const unsigned int width_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
340  const unsigned int height_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
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> 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> 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 
429 std::pair<int, int> scaled_dimensions_signed(int width, int height,
430  int kernel_width, int kernel_height,
431  const PadStrideInfo &pad_stride_info)
432 {
433  const int pad_left = pad_stride_info.pad_left();
434  const int pad_top = pad_stride_info.pad_top();
435  const int pad_right = pad_stride_info.pad_right();
436  const int pad_bottom = pad_stride_info.pad_bottom();
437  const int stride_x = pad_stride_info.stride().first;
438  const int stride_y = pad_stride_info.stride().second;
439  int w = 0;
440  int h = 0;
441  switch(pad_stride_info.round())
442  {
444  w = static_cast<int>(std::floor((static_cast<float>(width + pad_left + pad_right - kernel_width) / stride_x) + 1));
445  h = static_cast<int>(std::floor((static_cast<float>(height + pad_top + pad_bottom - kernel_height) / stride_y) + 1));
446  break;
448  w = static_cast<int>(std::ceil((static_cast<float>(width + pad_left + pad_right - kernel_width) / stride_x) + 1));
449  h = static_cast<int>(std::ceil((static_cast<float>(height + pad_top + pad_bottom - kernel_height) / stride_y) + 1));
450  break;
451  default:
452  ARM_COMPUTE_ERROR("Unsupported rounding type");
453  }
454 
455  return std::make_pair(static_cast<int>(w), static_cast<int>(h));
456 }
457 
459 {
460  const bool is_min_max = (op == ReductionOperation::MAX || op == ReductionOperation::MIN);
461  const bool is_quantized_type = is_data_type_quantized(dt);
462  const bool is_first_dim = (axis == 0);
463 
464  return !is_first_dim || is_min_max || is_quantized_type;
465 }
466 
468 {
469  // Note: Output quantization info for softmax should always have
470  // * Softmax with QASYMM8: scale = 1/256, offset = 0
471  // * Softmax with QASYMM8_SIGNED: scale = 1/256, offset = -128
472  // * LogSoftmax with QASYMM8: scale = 1/256, offset = 0
473  // * LogSoftmax with QASYMM8_SIGNED: scale = 16/256, offset = 127
475  {
476  if(is_log)
477  {
478  return QuantizationInfo(16.f / 256, 127);
479  }
480  else
481  {
482  return QuantizationInfo(1.f / 256, -128);
483  }
484  }
485  return QuantizationInfo(1.f / 256, 0);
486 }
487 
489 {
490  const bool is_qasymm8_signed = is_data_type_quantized_asymmetric_signed(data_type);
491  const auto a = act_info.a();
492  const auto b = act_info.b();
493  const int a_int = is_qasymm8_signed ? quantize_qasymm8_signed(a, oq_info) : quantize_qasymm8(a, oq_info);
494  const int b_int = is_qasymm8_signed ? quantize_qasymm8_signed(b, oq_info) : quantize_qasymm8(b, oq_info);
495  const auto type_max_value = std::get<1>(get_min_max(data_type)).get<int32_t>();
496 
497  const int32_t min_activation = act_info.activation() != ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU ? oq_info.offset : b_int;
498  const int32_t max_activation = act_info.activation() == ActivationLayerInfo::ActivationFunction::RELU ? type_max_value : a_int;
499 
500  return std::make_pair(min_activation, max_activation);
501 }
502 
503 std::unordered_map<const ITensorInfo *, PaddingSize> get_padding_info(std::initializer_list<const ITensor *> tensors)
504 {
505  std::unordered_map<const ITensorInfo *, PaddingSize> res;
506 
507  for(const ITensor *tensor : tensors)
508  {
509  if(tensor)
510  {
511  res.insert({ tensor->info(), tensor->info()->padding() });
512  }
513  }
514 
515  return res;
516 }
517 
518 std::unordered_map<const ITensorInfo *, PaddingSize> get_padding_info(std::initializer_list<const ITensorInfo *> infos)
519 {
520  std::unordered_map<const ITensorInfo *, PaddingSize> res;
521 
522  for(const ITensorInfo *info : infos)
523  {
524  if(info)
525  {
526  res.insert({ info, info->padding() });
527  }
528  }
529 
530  return res;
531 }
532 
533 bool has_padding_changed(const std::unordered_map<const ITensorInfo *, PaddingSize> &padding_map)
534 {
535  return std::find_if(padding_map.begin(), padding_map.end(), [](const std::pair<const ITensorInfo *, PaddingSize> &padding_info)
536  {
537  return (padding_info.first->padding() != padding_info.second);
538  })
539  != padding_map.end();
540 }
541 
542 #ifdef ARM_COMPUTE_ASSERTS_ENABLED
543 void print_consecutive_elements(std::ostream &s, DataType dt, const uint8_t *ptr, unsigned int n, int stream_width, const std::string &element_delim)
544 {
545  switch(dt)
546  {
547  case DataType::U8:
548  case DataType::QASYMM8:
549  print_consecutive_elements_impl<uint8_t>(s, ptr, n, stream_width, element_delim);
550  break;
551  case DataType::S8:
552  case DataType::QSYMM8:
555  print_consecutive_elements_impl<int8_t>(s, reinterpret_cast<const int8_t *>(ptr), n, stream_width, element_delim);
556  break;
557  case DataType::U16:
558  case DataType::QASYMM16:
559  print_consecutive_elements_impl<uint16_t>(s, reinterpret_cast<const uint16_t *>(ptr), n, stream_width, element_delim);
560  break;
561  case DataType::S16:
562  case DataType::QSYMM16:
563  print_consecutive_elements_impl<int16_t>(s, reinterpret_cast<const int16_t *>(ptr), n, stream_width, element_delim);
564  break;
565  case DataType::U32:
566  print_consecutive_elements_impl<uint32_t>(s, reinterpret_cast<const uint32_t *>(ptr), n, stream_width, element_delim);
567  break;
568  case DataType::S32:
569  print_consecutive_elements_impl<int32_t>(s, reinterpret_cast<const int32_t *>(ptr), n, stream_width, element_delim);
570  break;
571  case DataType::BFLOAT16:
572  print_consecutive_elements_impl<bfloat16>(s, reinterpret_cast<const bfloat16 *>(ptr), n, stream_width, element_delim);
573  break;
574  case DataType::F16:
575  print_consecutive_elements_impl<half>(s, reinterpret_cast<const half *>(ptr), n, stream_width, element_delim);
576  break;
577  case DataType::F32:
578  print_consecutive_elements_impl<float>(s, reinterpret_cast<const float *>(ptr), n, stream_width, element_delim);
579  break;
580  default:
581  ARM_COMPUTE_ERROR("Undefined element size for given data type");
582  }
583 }
584 
585 int max_consecutive_elements_display_width(std::ostream &s, DataType dt, const uint8_t *ptr, unsigned int n)
586 {
587  switch(dt)
588  {
589  case DataType::U8:
590  case DataType::QASYMM8:
591  return max_consecutive_elements_display_width_impl<uint8_t>(s, ptr, n);
592  case DataType::S8:
593  case DataType::QSYMM8:
596  return max_consecutive_elements_display_width_impl<int8_t>(s, reinterpret_cast<const int8_t *>(ptr), n);
597  case DataType::U16:
598  case DataType::QASYMM16:
599  return max_consecutive_elements_display_width_impl<uint16_t>(s, reinterpret_cast<const uint16_t *>(ptr), n);
600  case DataType::S16:
601  case DataType::QSYMM16:
602  return max_consecutive_elements_display_width_impl<int16_t>(s, reinterpret_cast<const int16_t *>(ptr), n);
603  case DataType::U32:
604  return max_consecutive_elements_display_width_impl<uint32_t>(s, reinterpret_cast<const uint32_t *>(ptr), n);
605  case DataType::S32:
606  return max_consecutive_elements_display_width_impl<int32_t>(s, reinterpret_cast<const int32_t *>(ptr), n);
607  case DataType::BFLOAT16:
608  return max_consecutive_elements_display_width_impl<bfloat16>(s, reinterpret_cast<const bfloat16 *>(ptr), n);
609  case DataType::F16:
610  return max_consecutive_elements_display_width_impl<half>(s, reinterpret_cast<const half *>(ptr), n);
611  case DataType::F32:
612  return max_consecutive_elements_display_width_impl<float>(s, reinterpret_cast<const float *>(ptr), n);
613  default:
614  ARM_COMPUTE_ERROR("Undefined element size for given data type");
615  }
616  return 0;
617 }
618 #endif /* ARM_COMPUTE_ASSERTS_ENABLED */
619 
620 } // namespace arm_compute
BorderMode
Methods available to handle borders.
Definition: Types.h:256
bool is_data_type_quantized(DataType dt)
Check if a given data type is of quantized type.
Definition: Utils.h:981
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:458
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:389
SimpleTensor< float > w
Definition: DFT.cpp:156
Second channel (used by formats with unknown channel types).
Shape of a tensor.
Definition: TensorShape.h:39
Quantize using a fixed point multiplication.
DimensionRoundingType round() const
Get the rounding type.
Definition: Types.h:742
quantized, symmetric fixed-point 16-bit number
ReductionOperation
Available reduction operations.
Definition: Types.h:454
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&#39;s output tensor.
Definition: Utils.cpp:375
Brain floating point representation class.
Definition: Bfloat16.h:81
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:1515
void get(uint8_t &v) const
Interpret the pixel value as a U8.
Definition: PixelValue.h:244
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:528
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::stringstream ss(mlgo_str)
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:248
#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 DataLayout data_layout
Definition: Im2Col.cpp:151
const std::string & string_from_activation_func(ActivationLayerInfo::ActivationFunction act)
Translates a given activation function to a string.
Definition: Utils.cpp:163
Store the tensor&#39;s metadata.
Definition: ITensorInfo.h:40
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:467
Quantization info when assuming per layer quantization.
quantized, asymmetric fixed-point 16-bit number
1 channel, 1 U16 per channel
size_t x() const
Semantic accessor for width as x.
Definition: Size2D.h:74
unsigned int pad_top() const
Get the top padding.
Definition: Types.h:731
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:235
std::string lower_string(const std::string &val)
Lower a given string.
Definition: Utils.cpp:326
Activation Layer Information class.
Definition: Types.h:1475
decltype(strategy::transforms) typedef type
Interface for CPU tensor.
Definition: ITensor.h:36
A 2 plane YUV format of Luma (Y) and interleaved VU data at 4:2:0 sampling.
Copyright (c) 2017-2021 Arm Limited.
ActivationFunction
Available activation functions.
Definition: Types.h:1479
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:211
DataType dt
const std::string & string_from_border_mode(BorderMode border_mode)
Translates a given border mode policy to a string.
Definition: Utils.cpp:199
1 channel, 1 S32 per channel
std::pair< int, int > scaled_dimensions_signed(int width, int height, int kernel_width, int kernel_height, const PadStrideInfo &pad_stride_info)
Returns calculated width and height of output scaled tensor depending on dimensions rounding mode...
Definition: Utils.cpp:429
16-bit brain floating-point number
signed 64-bit number
3 channels, 1 U8 per channel
const DataType data_type
Definition: Im2Col.cpp:150
std::string tolower(std::string string)
Convert string to lower case.
Definition: Utility.h:205
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:1075
Normalization applied within the same map in 1D region.
Channel
Available channels.
Definition: Types.h:437
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:488
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:695
const std::string & string_from_interpolation_policy(InterpolationPolicy policy)
Translates a given interpolation policy to a string.
Definition: Utils.cpp:187
bool is_data_type_quantized_asymmetric_signed(DataType dt)
Check if a given data type is of asymmetric quantized signed type.
Definition: Utils.h:1022
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:726
Quantize using a floating point multiplication.
Padding and stride information class.
Definition: Types.h:647
void end(TokenStream &in, bool &valid)
Definition: MLGOParser.cpp:290
GEMMLowpOutputStageType
GEMMLowp output stage type.
Definition: Types.h:1879
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...
bool has_padding_changed(const std::unordered_map< const ITensorInfo *, PaddingSize > &padding_map)
Check if the previously stored padding info has changed after configuring a kernel.
Definition: Utils.cpp:533
quantized, symmetric fixed-point 8-bit number
Num samples, channels, height, width.
size_t y() const
Semantic accessor for height as y.
Definition: Size2D.h:83
const char * name
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:535
ScaleKernelInfo info(interpolation_policy, default_border_mode, PixelValue(), sampling_policy, false)
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.
std::unordered_map< const ITensorInfo *, PaddingSize > get_padding_info(std::initializer_list< const ITensorInfo *> infos)
Stores padding information before configuring a kernel.
Definition: Utils.cpp:518
2 channel, 1 U8 per channel
ActivationFunction activation() const
Get the type of activation function.
Definition: Types.h:1510
float b() const
Get the beta value.
Definition: Types.h:1520
quantized, asymmetric fixed-point 8-bit number signed
DataLayout dl
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:193
DataType data_type_from_name(const std::string &name)
Convert a string to DataType.
Definition: Utils.cpp:301
unsigned int pad_bottom() const
Get the bottom padding.
Definition: Types.h:736
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:721
DataLayout
[DataLayout enum definition]
Definition: Types.h:111
const std::string & string_from_pooling_type(PoolingType type)
Translates a given pooling type to a string.
Definition: Utils.cpp:223
NormType
The normalization type used for the normalization layer.
Definition: Types.h:502
signed 8-bit number
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:564
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