Compute Library
 21.08
Utils.h
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 #ifndef ARM_COMPUTE_UTILS_H
25 #define ARM_COMPUTE_UTILS_H
26 
27 #include "arm_compute/core/Error.h"
30 #include "arm_compute/core/Types.h"
32 
33 #include <algorithm>
34 #include <cstdint>
35 #include <cstdlib>
36 #include <iomanip>
37 #include <numeric>
38 #include <sstream>
39 #include <string>
40 #include <type_traits>
41 #include <unordered_map>
42 #include <utility>
43 #include <vector>
44 
45 namespace arm_compute
46 {
47 class ITensor;
48 class ITensorInfo;
49 
50 /** Calculate the rounded up quotient of val / m.
51  *
52  * @param[in] val Value to divide and round up.
53  * @param[in] m Value to divide by.
54  *
55  * @return the result.
56  */
57 template <typename S, typename T>
58 constexpr auto DIV_CEIL(S val, T m) -> decltype((val + m - 1) / m)
59 {
60  return (val + m - 1) / m;
61 }
62 
63 /** Computes the smallest number larger or equal to value that is a multiple of divisor.
64  *
65  * @param[in] value Lower bound value
66  * @param[in] divisor Value to compute multiple of.
67  *
68  * @return the result.
69  */
70 template <typename S, typename T>
71 inline auto ceil_to_multiple(S value, T divisor) -> decltype(((value + divisor - 1) / divisor) * divisor)
72 {
73  ARM_COMPUTE_ERROR_ON(value < 0 || divisor <= 0);
74  return DIV_CEIL(value, divisor) * divisor;
75 }
76 
77 /** Computes the largest number smaller or equal to value that is a multiple of divisor.
78  *
79  * @param[in] value Upper bound value
80  * @param[in] divisor Value to compute multiple of.
81  *
82  * @return the result.
83  */
84 template <typename S, typename T>
85 inline auto floor_to_multiple(S value, T divisor) -> decltype((value / divisor) * divisor)
86 {
87  ARM_COMPUTE_ERROR_ON(value < 0 || divisor <= 0);
88  return (value / divisor) * divisor;
89 }
90 
91 /** Load an entire file in memory
92  *
93  * @param[in] filename Name of the file to read.
94  * @param[in] binary Is it a binary file ?
95  *
96  * @return The content of the file.
97  */
98 std::string read_file(const std::string &filename, bool binary);
99 
100 /** The size in bytes of the data type
101  *
102  * @param[in] data_type Input data type
103  *
104  * @return The size in bytes of the data type
105  */
107 {
108  switch(data_type)
109  {
110  case DataType::U8:
111  case DataType::S8:
112  case DataType::QSYMM8:
113  case DataType::QASYMM8:
116  return 1;
117  case DataType::U16:
118  case DataType::S16:
119  case DataType::QSYMM16:
120  case DataType::QASYMM16:
121  case DataType::BFLOAT16:
122  case DataType::F16:
123  return 2;
124  case DataType::F32:
125  case DataType::U32:
126  case DataType::S32:
127  return 4;
128  case DataType::F64:
129  case DataType::U64:
130  case DataType::S64:
131  return 8;
132  case DataType::SIZET:
133  return sizeof(size_t);
134  default:
135  ARM_COMPUTE_ERROR("Invalid data type");
136  return 0;
137  }
138 }
139 
140 /** The size in bytes of the pixel format
141  *
142  * @param[in] format Input format
143  *
144  * @return The size in bytes of the pixel format
145  */
146 inline size_t pixel_size_from_format(Format format)
147 {
148  switch(format)
149  {
150  case Format::U8:
151  return 1;
152  case Format::U16:
153  case Format::S16:
154  case Format::BFLOAT16:
155  case Format::F16:
156  case Format::UV88:
157  case Format::YUYV422:
158  case Format::UYVY422:
159  return 2;
160  case Format::RGB888:
161  return 3;
162  case Format::RGBA8888:
163  return 4;
164  case Format::U32:
165  case Format::S32:
166  case Format::F32:
167  return 4;
168  //Doesn't make sense for planar formats:
169  case Format::NV12:
170  case Format::NV21:
171  case Format::IYUV:
172  case Format::YUV444:
173  default:
174  ARM_COMPUTE_ERROR("Undefined pixel size for given format");
175  return 0;
176  }
177 }
178 
179 /** The size in bytes of the data type
180  *
181  * @param[in] dt Input data type
182  *
183  * @return The size in bytes of the data type
184  */
186 {
187  switch(dt)
188  {
189  case DataType::S8:
190  case DataType::U8:
191  case DataType::QSYMM8:
192  case DataType::QASYMM8:
195  return 1;
196  case DataType::U16:
197  case DataType::S16:
198  case DataType::QSYMM16:
199  case DataType::QASYMM16:
200  case DataType::BFLOAT16:
201  case DataType::F16:
202  return 2;
203  case DataType::U32:
204  case DataType::S32:
205  case DataType::F32:
206  return 4;
207  default:
208  ARM_COMPUTE_ERROR("Undefined element size for given data type");
209  return 0;
210  }
211 }
212 
213 /** Return the data type used by a given single-planar pixel format
214  *
215  * @param[in] format Input format
216  *
217  * @return The size in bytes of the pixel format
218  */
220 {
221  switch(format)
222  {
223  case Format::U8:
224  case Format::UV88:
225  case Format::RGB888:
226  case Format::RGBA8888:
227  case Format::YUYV422:
228  case Format::UYVY422:
229  return DataType::U8;
230  case Format::U16:
231  return DataType::U16;
232  case Format::S16:
233  return DataType::S16;
234  case Format::U32:
235  return DataType::U32;
236  case Format::S32:
237  return DataType::S32;
238  case Format::BFLOAT16:
239  return DataType::BFLOAT16;
240  case Format::F16:
241  return DataType::F16;
242  case Format::F32:
243  return DataType::F32;
244  //Doesn't make sense for planar formats:
245  case Format::NV12:
246  case Format::NV21:
247  case Format::IYUV:
248  case Format::YUV444:
249  default:
250  ARM_COMPUTE_ERROR("Not supported data_type for given format");
251  return DataType::UNKNOWN;
252  }
253 }
254 
255 /** Return the plane index of a given channel given an input format.
256  *
257  * @param[in] format Input format
258  * @param[in] channel Input channel
259  *
260  * @return The plane index of the specific channel of the specific format
261  */
262 inline int plane_idx_from_channel(Format format, Channel channel)
263 {
264  switch(format)
265  {
266  // Single planar formats have a single plane
267  case Format::U8:
268  case Format::U16:
269  case Format::S16:
270  case Format::U32:
271  case Format::S32:
272  case Format::BFLOAT16:
273  case Format::F16:
274  case Format::F32:
275  case Format::UV88:
276  case Format::RGB888:
277  case Format::RGBA8888:
278  case Format::YUYV422:
279  case Format::UYVY422:
280  return 0;
281  // Multi planar formats
282  case Format::NV12:
283  case Format::NV21:
284  {
285  // Channel U and V share the same plane of format UV88
286  switch(channel)
287  {
288  case Channel::Y:
289  return 0;
290  case Channel::U:
291  case Channel::V:
292  return 1;
293  default:
294  ARM_COMPUTE_ERROR("Not supported channel");
295  return 0;
296  }
297  }
298  case Format::IYUV:
299  case Format::YUV444:
300  {
301  switch(channel)
302  {
303  case Channel::Y:
304  return 0;
305  case Channel::U:
306  return 1;
307  case Channel::V:
308  return 2;
309  default:
310  ARM_COMPUTE_ERROR("Not supported channel");
311  return 0;
312  }
313  }
314  default:
315  ARM_COMPUTE_ERROR("Not supported format");
316  return 0;
317  }
318 }
319 
320 /** Return the channel index of a given channel given an input format.
321  *
322  * @param[in] format Input format
323  * @param[in] channel Input channel
324  *
325  * @return The channel index of the specific channel of the specific format
326  */
327 inline int channel_idx_from_format(Format format, Channel channel)
328 {
329  switch(format)
330  {
331  case Format::RGB888:
332  {
333  switch(channel)
334  {
335  case Channel::R:
336  return 0;
337  case Channel::G:
338  return 1;
339  case Channel::B:
340  return 2;
341  default:
342  ARM_COMPUTE_ERROR("Not supported channel");
343  return 0;
344  }
345  }
346  case Format::RGBA8888:
347  {
348  switch(channel)
349  {
350  case Channel::R:
351  return 0;
352  case Channel::G:
353  return 1;
354  case Channel::B:
355  return 2;
356  case Channel::A:
357  return 3;
358  default:
359  ARM_COMPUTE_ERROR("Not supported channel");
360  return 0;
361  }
362  }
363  case Format::YUYV422:
364  {
365  switch(channel)
366  {
367  case Channel::Y:
368  return 0;
369  case Channel::U:
370  return 1;
371  case Channel::V:
372  return 3;
373  default:
374  ARM_COMPUTE_ERROR("Not supported channel");
375  return 0;
376  }
377  }
378  case Format::UYVY422:
379  {
380  switch(channel)
381  {
382  case Channel::Y:
383  return 1;
384  case Channel::U:
385  return 0;
386  case Channel::V:
387  return 2;
388  default:
389  ARM_COMPUTE_ERROR("Not supported channel");
390  return 0;
391  }
392  }
393  case Format::NV12:
394  {
395  switch(channel)
396  {
397  case Channel::Y:
398  return 0;
399  case Channel::U:
400  return 0;
401  case Channel::V:
402  return 1;
403  default:
404  ARM_COMPUTE_ERROR("Not supported channel");
405  return 0;
406  }
407  }
408  case Format::NV21:
409  {
410  switch(channel)
411  {
412  case Channel::Y:
413  return 0;
414  case Channel::U:
415  return 1;
416  case Channel::V:
417  return 0;
418  default:
419  ARM_COMPUTE_ERROR("Not supported channel");
420  return 0;
421  }
422  }
423  case Format::YUV444:
424  case Format::IYUV:
425  {
426  switch(channel)
427  {
428  case Channel::Y:
429  return 0;
430  case Channel::U:
431  return 0;
432  case Channel::V:
433  return 0;
434  default:
435  ARM_COMPUTE_ERROR("Not supported channel");
436  return 0;
437  }
438  }
439  default:
440  ARM_COMPUTE_ERROR("Not supported format");
441  return 0;
442  }
443 }
444 
445 /** Return the number of planes for a given format
446  *
447  * @param[in] format Input format
448  *
449  * @return The number of planes for a given image format.
450  */
451 inline size_t num_planes_from_format(Format format)
452 {
453  switch(format)
454  {
455  case Format::U8:
456  case Format::S16:
457  case Format::U16:
458  case Format::S32:
459  case Format::U32:
460  case Format::BFLOAT16:
461  case Format::F16:
462  case Format::F32:
463  case Format::RGB888:
464  case Format::RGBA8888:
465  case Format::YUYV422:
466  case Format::UYVY422:
467  return 1;
468  case Format::NV12:
469  case Format::NV21:
470  return 2;
471  case Format::IYUV:
472  case Format::YUV444:
473  return 3;
474  default:
475  ARM_COMPUTE_ERROR("Not supported format");
476  return 0;
477  }
478 }
479 
480 /** Return the number of channels for a given single-planar pixel format
481  *
482  * @param[in] format Input format
483  *
484  * @return The number of channels for a given image format.
485  */
486 inline size_t num_channels_from_format(Format format)
487 {
488  switch(format)
489  {
490  case Format::U8:
491  case Format::U16:
492  case Format::S16:
493  case Format::U32:
494  case Format::S32:
495  case Format::BFLOAT16:
496  case Format::F16:
497  case Format::F32:
498  return 1;
499  // Because the U and V channels are subsampled
500  // these formats appear like having only 2 channels:
501  case Format::YUYV422:
502  case Format::UYVY422:
503  return 2;
504  case Format::UV88:
505  return 2;
506  case Format::RGB888:
507  return 3;
508  case Format::RGBA8888:
509  return 4;
510  //Doesn't make sense for planar formats:
511  case Format::NV12:
512  case Format::NV21:
513  case Format::IYUV:
514  case Format::YUV444:
515  default:
516  return 0;
517  }
518 }
519 
520 /** Return the promoted data type of a given data type.
521  *
522  * @note If promoted data type is not supported an error will be thrown
523  *
524  * @param[in] dt Data type to get the promoted type of.
525  *
526  * @return Promoted data type
527  */
529 {
530  switch(dt)
531  {
532  case DataType::U8:
533  return DataType::U16;
534  case DataType::S8:
535  return DataType::S16;
536  case DataType::U16:
537  return DataType::U32;
538  case DataType::S16:
539  return DataType::S32;
540  case DataType::QSYMM8:
541  case DataType::QASYMM8:
544  case DataType::QSYMM16:
545  case DataType::QASYMM16:
546  case DataType::BFLOAT16:
547  case DataType::F16:
548  case DataType::U32:
549  case DataType::S32:
550  case DataType::F32:
551  ARM_COMPUTE_ERROR("Unsupported data type promotions!");
552  default:
553  ARM_COMPUTE_ERROR("Undefined data type!");
554  }
555  return DataType::UNKNOWN;
556 }
557 
558 /** Compute the mininum and maximum values a data type can take
559  *
560  * @param[in] dt Data type to get the min/max bounds of
561  *
562  * @return A tuple (min,max) with the minimum and maximum values respectively wrapped in PixelValue.
563  */
564 inline std::tuple<PixelValue, PixelValue> get_min_max(DataType dt)
565 {
566  PixelValue min{};
567  PixelValue max{};
568  switch(dt)
569  {
570  case DataType::U8:
571  case DataType::QASYMM8:
572  {
573  min = PixelValue(static_cast<int32_t>(std::numeric_limits<uint8_t>::lowest()));
574  max = PixelValue(static_cast<int32_t>(std::numeric_limits<uint8_t>::max()));
575  break;
576  }
577  case DataType::S8:
578  case DataType::QSYMM8:
581  {
582  min = PixelValue(static_cast<int32_t>(std::numeric_limits<int8_t>::lowest()));
583  max = PixelValue(static_cast<int32_t>(std::numeric_limits<int8_t>::max()));
584  break;
585  }
586  case DataType::U16:
587  case DataType::QASYMM16:
588  {
589  min = PixelValue(static_cast<int32_t>(std::numeric_limits<uint16_t>::lowest()));
590  max = PixelValue(static_cast<int32_t>(std::numeric_limits<uint16_t>::max()));
591  break;
592  }
593  case DataType::S16:
594  case DataType::QSYMM16:
595  {
596  min = PixelValue(static_cast<int32_t>(std::numeric_limits<int16_t>::lowest()));
597  max = PixelValue(static_cast<int32_t>(std::numeric_limits<int16_t>::max()));
598  break;
599  }
600  case DataType::U32:
601  {
603  max = PixelValue(std::numeric_limits<uint32_t>::max());
604  break;
605  }
606  case DataType::S32:
607  {
609  max = PixelValue(std::numeric_limits<int32_t>::max());
610  break;
611  }
612  case DataType::BFLOAT16:
613  {
614  min = PixelValue(bfloat16::lowest());
615  max = PixelValue(bfloat16::max());
616  break;
617  }
618  case DataType::F16:
619  {
621  max = PixelValue(std::numeric_limits<half>::max());
622  break;
623  }
624  case DataType::F32:
625  {
627  max = PixelValue(std::numeric_limits<float>::max());
628  break;
629  }
630  default:
631  ARM_COMPUTE_ERROR("Undefined data type!");
632  }
633  return std::make_tuple(min, max);
634 }
635 
636 /** Return true if the given format has horizontal subsampling.
637  *
638  * @param[in] format Format to determine subsampling.
639  *
640  * @return True if the format can be subsampled horizontaly.
641  */
643 {
644  return (format == Format::YUYV422 || format == Format::UYVY422 || format == Format::NV12 || format == Format::NV21 || format == Format::IYUV || format == Format::UV88) ? true : false;
645 }
646 
647 /** Return true if the given format has vertical subsampling.
648  *
649  * @param[in] format Format to determine subsampling.
650  *
651  * @return True if the format can be subsampled verticaly.
652  */
654 {
655  return (format == Format::NV12 || format == Format::NV21 || format == Format::IYUV || format == Format::UV88) ? true : false;
656 }
657 
658 /** Adjust tensor shape size if width or height are odd for a given multi-planar format. No modification is done for other formats.
659  *
660  * @note Adding here a few links discussing the issue of odd size and sharing the same solution:
661  * <a href="https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/graphics/java/android/graphics/YuvImage.java">Android Source</a>
662  * <a href="https://groups.google.com/a/webmproject.org/forum/#!topic/webm-discuss/LaCKpqiDTXM">WebM</a>
663  * <a href="https://bugs.chromium.org/p/libyuv/issues/detail?id=198&amp;can=1&amp;q=odd%20width">libYUV</a>
664  * <a href="https://sourceforge.net/p/raw-yuvplayer/bugs/1/">YUVPlayer</a> *
665  *
666  * @param[in, out] shape Tensor shape of 2D size
667  * @param[in] format Format of the tensor
668  *
669  * @return The adjusted tensor shape.
670  */
672 {
673  TensorShape output{ shape };
674 
675  // Force width to be even for formats which require subsampling of the U and V channels
677  {
678  output.set(0, (output.x() + 1) & ~1U);
679  }
680 
681  // Force height to be even for formats which require subsampling of the U and V channels
683  {
684  output.set(1, (output.y() + 1) & ~1U);
685  }
686 
687  return output;
688 }
689 
690 /** Calculate subsampled shape for a given format and channel
691  *
692  * @param[in] shape Shape of the tensor to calculate the extracted channel.
693  * @param[in] format Format of the tensor.
694  * @param[in] channel Channel to create tensor shape to be extracted.
695  *
696  * @return The subsampled tensor shape.
697  */
699 {
700  TensorShape output{ shape };
701 
702  // Subsample shape only for U or V channel
703  if(Channel::U == channel || Channel::V == channel || Channel::UNKNOWN == channel)
704  {
705  // Subsample width for the tensor shape when channel is U or V
707  {
708  output.set(0, output.x() / 2U);
709  }
710 
711  // Subsample height for the tensor shape when channel is U or V
713  {
714  output.set(1, output.y() / 2U);
715  }
716  }
717 
718  return output;
719 }
720 
721 /** Permutes the given dimensions according the permutation vector
722  *
723  * @param[in,out] dimensions Dimensions to be permuted.
724  * @param[in] perm Vector describing the permutation.
725  *
726  */
727 template <typename T>
728 inline void permute_strides(Dimensions<T> &dimensions, const PermutationVector &perm)
729 {
730  const auto old_dim = utility::make_array<Dimensions<T>::num_max_dimensions>(dimensions.begin(), dimensions.end());
731  for(unsigned int i = 0; i < perm.num_dimensions(); ++i)
732  {
733  T dimension_val = old_dim[i];
734  dimensions.set(perm[i], dimension_val);
735  }
736 }
737 
738 /** Calculate padding requirements in case of SAME padding
739  *
740  * @param[in] input_shape Input shape
741  * @param[in] weights_shape Weights shape
742  * @param[in] conv_info Convolution information (containing strides)
743  * @param[in] data_layout (Optional) Data layout of the input and weights tensor
744  * @param[in] dilation (Optional) Dilation factor used in the convolution.
745  * @param[in] rounding_type (Optional) Dimension rounding type when down-scaling.
746  *
747  * @return PadStrideInfo for SAME padding
748  */
750  const DimensionRoundingType &rounding_type = DimensionRoundingType::FLOOR);
751 
752 /** Returns expected width and height of the deconvolution's output tensor.
753  *
754  * @param[in] in_width Width of input tensor (Number of columns)
755  * @param[in] in_height Height of input tensor (Number of rows)
756  * @param[in] kernel_width Kernel width.
757  * @param[in] kernel_height Kernel height.
758  * @param[in] pad_stride_info Pad and stride information.
759  *
760  * @return A pair with the new width in the first position and the new height in the second.
761  */
762 std::pair<unsigned int, unsigned int> deconvolution_output_dimensions(unsigned int in_width, unsigned int in_height,
763  unsigned int kernel_width, unsigned int kernel_height,
764  const PadStrideInfo &pad_stride_info);
765 
766 /** Returns expected width and height of output scaled tensor depending on dimensions rounding mode.
767  *
768  * @param[in] width Width of input tensor (Number of columns)
769  * @param[in] height Height of input tensor (Number of rows)
770  * @param[in] kernel_width Kernel width.
771  * @param[in] kernel_height Kernel height.
772  * @param[in] pad_stride_info Pad and stride information.
773  * @param[in] dilation (Optional) Dilation, in elements, across x and y. Defaults to (1, 1).
774  *
775  * @return A pair with the new width in the first position and the new height in the second.
776  */
777 std::pair<unsigned int, unsigned int> scaled_dimensions(int width, int height,
778  int kernel_width, int kernel_height,
779  const PadStrideInfo &pad_stride_info,
780  const Size2D &dilation = Size2D(1U, 1U));
781 
782 /** Returns calculated width and height of output scaled tensor depending on dimensions rounding mode.
783  *
784  * @param[in] width Width of input tensor (Number of columns)
785  * @param[in] height Height of input tensor (Number of rows)
786  * @param[in] kernel_width Kernel width.
787  * @param[in] kernel_height Kernel height.
788  * @param[in] pad_stride_info Pad and stride information.
789  *
790  * @return A pair with the new width in the first position and the new height in the second, returned values can be < 1
791  */
792 std::pair<int, int> scaled_dimensions_signed(int width, int height,
793  int kernel_width, int kernel_height,
794  const PadStrideInfo &pad_stride_info);
795 
796 /** Check if the given reduction operation should be handled in a serial way.
797  *
798  * @param[in] op Reduction operation to perform
799  * @param[in] dt Data type
800  * @param[in] axis Axis along which to reduce
801  *
802  * @return True if the given reduction operation should be handled in a serial way.
803  */
804 bool needs_serialized_reduction(ReductionOperation op, DataType dt, unsigned int axis);
805 
806 /** Returns output quantization information for softmax layer
807  *
808  * @param[in] input_type The data type of the input tensor
809  * @param[in] is_log True for log softmax
810  *
811  * @return Quantization information for the output tensor
812  */
814 
815 /** Returns a pair of minimum and maximum values for a quantized activation
816  *
817  * @param[in] act_info The information for activation
818  * @param[in] data_type The used data type
819  * @param[in] oq_info The output quantization information
820  *
821  * @return The pair with minimum and maximum values
822  */
824 
825 /** Convert a tensor format into a string.
826  *
827  * @param[in] format @ref Format to be translated to string.
828  *
829  * @return The string describing the format.
830  */
831 const std::string &string_from_format(Format format);
832 
833 /** Convert a channel identity into a string.
834  *
835  * @param[in] channel @ref Channel to be translated to string.
836  *
837  * @return The string describing the channel.
838  */
839 const std::string &string_from_channel(Channel channel);
840 /** Convert a data layout identity into a string.
841  *
842  * @param[in] dl @ref DataLayout to be translated to string.
843  *
844  * @return The string describing the data layout.
845  */
846 const std::string &string_from_data_layout(DataLayout dl);
847 /** Convert a data type identity into a string.
848  *
849  * @param[in] dt @ref DataType to be translated to string.
850  *
851  * @return The string describing the data type.
852  */
853 const std::string &string_from_data_type(DataType dt);
854 /** Translates a given activation function to a string.
855  *
856  * @param[in] act @ref ActivationLayerInfo::ActivationFunction to be translated to string.
857  *
858  * @return The string describing the activation function.
859  */
861 /** Translates a given interpolation policy to a string.
862  *
863  * @param[in] policy @ref InterpolationPolicy to be translated to string.
864  *
865  * @return The string describing the interpolation policy.
866  */
867 const std::string &string_from_interpolation_policy(InterpolationPolicy policy);
868 /** Translates a given border mode policy to a string.
869  *
870  * @param[in] border_mode @ref BorderMode to be translated to string.
871  *
872  * @return The string describing the border mode.
873  */
874 const std::string &string_from_border_mode(BorderMode border_mode);
875 /** Translates a given normalization type to a string.
876  *
877  * @param[in] type @ref NormType to be translated to string.
878  *
879  * @return The string describing the normalization type.
880  */
881 const std::string &string_from_norm_type(NormType type);
882 /** Translates a given pooling type to a string.
883  *
884  * @param[in] type @ref PoolingType to be translated to string.
885  *
886  * @return The string describing the pooling type.
887  */
888 const std::string &string_from_pooling_type(PoolingType type);
889 /** Translates a given GEMMLowp output stage to a string.
890  *
891  * @param[in] output_stage @ref GEMMLowpOutputStageInfo to be translated to string.
892  *
893  * @return The string describing the GEMMLowp output stage
894  */
895 const std::string &string_from_gemmlowp_output_stage(GEMMLowpOutputStageType output_stage);
896 /** Convert a PixelValue to a string, represented through the specific data type
897  *
898  * @param[in] value The PixelValue to convert
899  * @param[in] data_type The type to be used to convert the @p value
900  *
901  * @return String representation of the PixelValue through the given data type.
902  */
903 std::string string_from_pixel_value(const PixelValue &value, const DataType data_type);
904 /** Convert a string to DataType
905  *
906  * @param[in] name The name of the data type
907  *
908  * @return DataType
909  */
910 DataType data_type_from_name(const std::string &name);
911 /** Stores padding information before configuring a kernel
912  *
913  * @param[in] infos list of tensor infos to store the padding info for
914  *
915  * @return An unordered map where each tensor info pointer is paired with its original padding info
916  */
917 std::unordered_map<const ITensorInfo *, PaddingSize> get_padding_info(std::initializer_list<const ITensorInfo *> infos);
918 /** Stores padding information before configuring a kernel
919  *
920  * @param[in] tensors list of tensors to store the padding info for
921  *
922  * @return An unordered map where each tensor info pointer is paired with its original padding info
923  */
924 std::unordered_map<const ITensorInfo *, PaddingSize> get_padding_info(std::initializer_list<const ITensor *> tensors);
925 /** Check if the previously stored padding info has changed after configuring a kernel
926  *
927  * @param[in] padding_map an unordered map where each tensor info pointer is paired with its original padding info
928  *
929  * @return true if any of the tensor infos has changed its paddings
930  */
931 bool has_padding_changed(const std::unordered_map<const ITensorInfo *, PaddingSize> &padding_map);
932 
933 /** Input Stream operator for @ref DataType
934  *
935  * @param[in] stream Stream to parse
936  * @param[out] data_type Output data type
937  *
938  * @return Updated stream
939  */
940 inline ::std::istream &operator>>(::std::istream &stream, DataType &data_type)
941 {
942  std::string value;
943  stream >> value;
944  data_type = data_type_from_name(value);
945  return stream;
946 }
947 /** Lower a given string.
948  *
949  * @param[in] val Given string to lower.
950  *
951  * @return The lowered string
952  */
953 std::string lower_string(const std::string &val);
954 
955 /** Check if a given data type is of floating point type
956  *
957  * @param[in] dt Input data type.
958  *
959  * @return True if data type is of floating point type, else false.
960  */
962 {
963  switch(dt)
964  {
965  case DataType::F16:
966  case DataType::F32:
967  return true;
968  default:
969  return false;
970  }
971 }
972 
973 /** Check if a given data type is of quantized type
974  *
975  * @note Quantized is considered a super-set of fixed-point and asymmetric data types.
976  *
977  * @param[in] dt Input data type.
978  *
979  * @return True if data type is of quantized type, else false.
980  */
982 {
983  switch(dt)
984  {
985  case DataType::QSYMM8:
986  case DataType::QASYMM8:
989  case DataType::QSYMM16:
990  case DataType::QASYMM16:
991  return true;
992  default:
993  return false;
994  }
995 }
996 
997 /** Check if a given data type is of asymmetric quantized type
998  *
999  * @param[in] dt Input data type.
1000  *
1001  * @return True if data type is of asymmetric quantized type, else false.
1002  */
1004 {
1005  switch(dt)
1006  {
1007  case DataType::QASYMM8:
1009  case DataType::QASYMM16:
1010  return true;
1011  default:
1012  return false;
1013  }
1014 }
1015 
1016 /** Check if a given data type is of asymmetric quantized signed type
1017  *
1018  * @param[in] dt Input data type.
1019  *
1020  * @return True if data type is of asymmetric quantized signed type, else false.
1021  */
1023 {
1024  switch(dt)
1025  {
1027  return true;
1028  default:
1029  return false;
1030  }
1031 }
1032 
1033 /** Check if a given data type is of symmetric quantized type
1034  *
1035  * @param[in] dt Input data type.
1036  *
1037  * @return True if data type is of symmetric quantized type, else false.
1038  */
1040 {
1041  switch(dt)
1042  {
1043  case DataType::QSYMM8:
1045  case DataType::QSYMM16:
1046  return true;
1047  default:
1048  return false;
1049  }
1050 }
1051 
1052 /** Check if a given data type is of per channel type
1053  *
1054  * @param[in] dt Input data type.
1055  *
1056  * @return True if data type is of per channel type, else false.
1057  */
1059 {
1060  switch(dt)
1061  {
1063  return true;
1064  default:
1065  return false;
1066  }
1067 }
1068 
1069 /** Create a string with the float in full precision.
1070  *
1071  * @param val Floating point value
1072  *
1073  * @return String with the floating point value.
1074  */
1075 inline std::string float_to_string_with_full_precision(float val)
1076 {
1077  std::stringstream ss;
1078  ss.precision(std::numeric_limits<float>::max_digits10);
1079  ss << val;
1080 
1081  if(val != static_cast<int>(val))
1082  {
1083  ss << "f";
1084  }
1085 
1086  return ss.str();
1087 }
1088 
1089 /** Returns the number of elements required to go from start to end with the wanted step
1090  *
1091  * @param[in] start start value
1092  * @param[in] end end value
1093  * @param[in] step step value between each number in the wanted sequence
1094  *
1095  * @return number of elements to go from start value to end value using the wanted step
1096  */
1097 inline size_t num_of_elements_in_range(const float start, const float end, const float step)
1098 {
1099  ARM_COMPUTE_ERROR_ON_MSG(step == 0, "Range Step cannot be 0");
1100  return size_t(std::ceil((end - start) / step));
1101 }
1102 
1103 /** Returns true if the value can be represented by the given data type
1104  *
1105  * @param[in] val value to be checked
1106  * @param[in] dt data type that is checked
1107  * @param[in] qinfo (Optional) quantization info if the data type is QASYMM8
1108  *
1109  * @return true if the data type can hold the value.
1110  */
1111 template <typename T>
1113 {
1114  switch(dt)
1115  {
1116  case DataType::U8:
1117  {
1118  const auto val_u8 = static_cast<uint8_t>(val);
1119  return ((val_u8 == val) && val >= std::numeric_limits<uint8_t>::lowest() && val <= std::numeric_limits<uint8_t>::max());
1120  }
1121  case DataType::QASYMM8:
1122  {
1123  double min = static_cast<double>(dequantize_qasymm8(0, qinfo));
1124  double max = static_cast<double>(dequantize_qasymm8(std::numeric_limits<uint8_t>::max(), qinfo));
1125  return ((double)val >= min && (double)val <= max);
1126  }
1127  case DataType::S8:
1128  {
1129  const auto val_s8 = static_cast<int8_t>(val);
1130  return ((val_s8 == val) && val >= std::numeric_limits<int8_t>::lowest() && val <= std::numeric_limits<int8_t>::max());
1131  }
1132  case DataType::U16:
1133  {
1134  const auto val_u16 = static_cast<uint16_t>(val);
1135  return ((val_u16 == val) && val >= std::numeric_limits<uint16_t>::lowest() && val <= std::numeric_limits<uint16_t>::max());
1136  }
1137  case DataType::S16:
1138  {
1139  const auto val_s16 = static_cast<int16_t>(val);
1140  return ((val_s16 == val) && val >= std::numeric_limits<int16_t>::lowest() && val <= std::numeric_limits<int16_t>::max());
1141  }
1142  case DataType::U32:
1143  {
1144  const auto val_u32 = static_cast<uint32_t>(val);
1145  return ((val_u32 == val) && val >= std::numeric_limits<uint32_t>::lowest() && val <= std::numeric_limits<uint32_t>::max());
1146  }
1147  case DataType::S32:
1148  {
1149  const auto val_s32 = static_cast<int32_t>(val);
1150  return ((val_s32 == val) && val >= std::numeric_limits<int32_t>::lowest() && val <= std::numeric_limits<int32_t>::max());
1151  }
1152  case DataType::BFLOAT16:
1153  return (val >= bfloat16::lowest() && val <= bfloat16::max());
1154  case DataType::F16:
1155  return (val >= std::numeric_limits<half>::lowest() && val <= std::numeric_limits<half>::max());
1156  case DataType::F32:
1157  return (val >= std::numeric_limits<float>::lowest() && val <= std::numeric_limits<float>::max());
1158  default:
1159  ARM_COMPUTE_ERROR("Data type not supported");
1160  return false;
1161  }
1162 }
1163 
1164 /** Returns the adjusted vector size in case it is less than the input's first dimension, getting rounded down to its closest valid vector size
1165  *
1166  * @param[in] vec_size vector size to be adjusted
1167  * @param[in] dim0 size of the first dimension
1168  *
1169  * @return the number of element processed along the X axis per thread
1170  */
1171 inline unsigned int adjust_vec_size(unsigned int vec_size, size_t dim0)
1172 {
1173  ARM_COMPUTE_ERROR_ON(vec_size > 16);
1174 
1175  if((vec_size >= dim0) && (dim0 == 3))
1176  {
1177  return dim0;
1178  }
1179 
1180  while(vec_size > dim0)
1181  {
1182  vec_size >>= 1;
1183  }
1184 
1185  return vec_size;
1186 }
1187 
1188 #ifdef ARM_COMPUTE_ASSERTS_ENABLED
1189 /** Print consecutive elements to an output stream.
1190  *
1191  * @param[out] s Output stream to print the elements to.
1192  * @param[in] ptr Pointer to print the elements from.
1193  * @param[in] n Number of elements to print.
1194  * @param[in] stream_width (Optional) Width of the stream. If set to 0 the element's width is used. Defaults to 0.
1195  * @param[in] element_delim (Optional) Delimeter among the consecutive elements. Defaults to space delimeter
1196  */
1197 template <typename T>
1198 void print_consecutive_elements_impl(std::ostream &s, const T *ptr, unsigned int n, int stream_width = 0, const std::string &element_delim = " ")
1199 {
1200  using print_type = typename std::conditional<std::is_floating_point<T>::value, T, int>::type;
1201  std::ios stream_status(nullptr);
1202  stream_status.copyfmt(s);
1203 
1204  for(unsigned int i = 0; i < n; ++i)
1205  {
1206  // Set stream width as it is not a "sticky" stream manipulator
1207  if(stream_width != 0)
1208  {
1209  s.width(stream_width);
1210  }
1211 
1212  if(std::is_same<typename std::decay<T>::type, half>::value)
1213  {
1214  // We use T instead of print_type here is because the std::is_floating_point<half> returns false and then the print_type becomes int.
1215  s << std::right << static_cast<T>(ptr[i]) << element_delim;
1216  }
1217  else if(std::is_same<typename std::decay<T>::type, bfloat16>::value)
1218  {
1219  // We use T instead of print_type here is because the std::is_floating_point<bfloat16> returns false and then the print_type becomes int.
1220  s << std::right << float(ptr[i]) << element_delim;
1221  }
1222  else
1223  {
1224  s << std::right << static_cast<print_type>(ptr[i]) << element_delim;
1225  }
1226  }
1227 
1228  // Restore output stream flags
1229  s.copyfmt(stream_status);
1230 }
1231 
1232 /** Identify the maximum width of n consecutive elements.
1233  *
1234  * @param[in] s The output stream which will be used to print the elements. Used to extract the stream format.
1235  * @param[in] ptr Pointer to the elements.
1236  * @param[in] n Number of elements.
1237  *
1238  * @return The maximum width of the elements.
1239  */
1240 template <typename T>
1241 int max_consecutive_elements_display_width_impl(std::ostream &s, const T *ptr, unsigned int n)
1242 {
1243  using print_type = typename std::conditional<std::is_floating_point<T>::value, T, int>::type;
1244 
1245  int max_width = -1;
1246  for(unsigned int i = 0; i < n; ++i)
1247  {
1248  std::stringstream ss;
1249  ss.copyfmt(s);
1250 
1251  if(std::is_same<typename std::decay<T>::type, half>::value)
1252  {
1253  // We use T instead of print_type here is because the std::is_floating_point<half> returns false and then the print_type becomes int.
1254  ss << static_cast<T>(ptr[i]);
1255  }
1256  else if(std::is_same<typename std::decay<T>::type, bfloat16>::value)
1257  {
1258  // We use T instead of print_type here is because the std::is_floating_point<bfloat> returns false and then the print_type becomes int.
1259  ss << float(ptr[i]);
1260  }
1261  else
1262  {
1263  ss << static_cast<print_type>(ptr[i]);
1264  }
1265 
1266  max_width = std::max<int>(max_width, ss.str().size());
1267  }
1268  return max_width;
1269 }
1270 
1271 /** Print consecutive elements to an output stream.
1272  *
1273  * @param[out] s Output stream to print the elements to.
1274  * @param[in] dt Data type of the elements
1275  * @param[in] ptr Pointer to print the elements from.
1276  * @param[in] n Number of elements to print.
1277  * @param[in] stream_width (Optional) Width of the stream. If set to 0 the element's width is used. Defaults to 0.
1278  * @param[in] element_delim (Optional) Delimeter among the consecutive elements. Defaults to space delimeter
1279  */
1280 void print_consecutive_elements(std::ostream &s, DataType dt, const uint8_t *ptr, unsigned int n, int stream_width, const std::string &element_delim = " ");
1281 
1282 /** Identify the maximum width of n consecutive elements.
1283  *
1284  * @param[in] s Output stream to print the elements to.
1285  * @param[in] dt Data type of the elements
1286  * @param[in] ptr Pointer to print the elements from.
1287  * @param[in] n Number of elements to print.
1288  *
1289  * @return The maximum width of the elements.
1290  */
1291 int max_consecutive_elements_display_width(std::ostream &s, DataType dt, const uint8_t *ptr, unsigned int n);
1292 #endif /* ARM_COMPUTE_ASSERTS_ENABLED */
1293 }
1294 #endif /*ARM_COMPUTE_UTILS_H */
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
void set(size_t dimension, T value, bool increase_dim_unit=true)
Accessor to set the value of one of the dimensions.
Definition: Dimensions.h:76
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
bool has_format_vertical_subsampling(Format format)
Return true if the given format has vertical subsampling.
Definition: Utils.h:653
Shape of a tensor.
Definition: TensorShape.h:39
quantized, symmetric fixed-point 16-bit number
int plane_idx_from_channel(Format format, Channel channel)
Return the plane index of a given channel given an input format.
Definition: Utils.h:262
TensorShape calculate_subsampled_shape(const TensorShape &shape, Format format, Channel channel=Channel::UNKNOWN)
Calculate subsampled shape for a given format and channel.
Definition: Utils.h:698
float dequantize_qasymm8(uint8_t value, const INFO_TYPE &qinfo)
Dequantize a value given an unsigned 8-bit asymmetric quantization scheme.
ReductionOperation
Available reduction operations.
Definition: Types.h:454
void permute_strides(Dimensions< T > &dimensions, const PermutationVector &perm)
Permutes the given dimensions according the permutation vector.
Definition: Utils.h:728
size_t num_planes_from_format(Format format)
Return the number of planes for a given format.
Definition: Utils.h:451
const std::string & string_from_channel(Channel channel)
Convert a channel identity into a string.
Definition: Utils.cpp:102
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
size_t element_size_from_data_type(DataType dt)
The size in bytes of the data type.
Definition: Utils.h:185
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
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
size_t num_channels_from_format(Format format)
Return the number of channels for a given single-planar pixel format.
Definition: Utils.h:486
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:467
Quantization info when assuming per layer quantization.
quantized, asymmetric fixed-point 16-bit number
1 channel, 1 U16 per channel
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
bool is_data_type_quantized_symmetric(DataType dt)
Check if a given data type is of symmetric quantized type.
Definition: Utils.h:1039
Activation Layer Information class.
Definition: Types.h:1475
decltype(strategy::transforms) typedef type
auto floor_to_multiple(S value, T divisor) -> decltype((value/divisor) *divisor)
Computes the largest number smaller or equal to value that is a multiple of divisor.
Definition: Utils.h:85
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
constexpr auto DIV_CEIL(S val, T m) -> decltype((val+m - 1)/m)
Calculate the rounded up quotient of val / m.
Definition: Utils.h:58
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
static bfloat16 lowest()
Lowest representative value.
Definition: Bfloat16.h:120
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
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
DataType get_promoted_data_type(DataType dt)
Return the promoted data type of a given data type.
Definition: Utils.h:528
std::string read_file(const std::string &filename, bool binary)
Load an entire file in memory.
Definition: Utils.cpp:38
1 channel, 1 U32 per channel
bool is_data_type_quantized_per_channel(DataType dt)
Check if a given data type is of per channel type.
Definition: Utils.h:1058
std::string float_to_string_with_full_precision(float val)
Create a string with the float in full precision.
Definition: Utils.h:1075
bool check_value_range(T val, DataType dt, QuantizationInfo qinfo=QuantizationInfo())
Returns true if the value can be represented by the given data type.
Definition: Utils.h:1112
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
auto ceil_to_multiple(S value, T divisor) -> decltype(((value+divisor - 1)/divisor) *divisor)
Computes the smallest number larger or equal to value that is a multiple of divisor.
Definition: Utils.h:71
quantized, asymmetric fixed-point 8-bit number unsigned
#define ARM_COMPUTE_ERROR_ON_MSG(cond, msg)
Definition: Error.h:456
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
Dimensions with dimensionality.
Definition: Dimensions.h:42
A 3 plane of 8 bit 4:4:4 sampled Y, U, V planes.
size_t data_size_from_type(DataType data_type)
The size in bytes of the data type.
Definition: Utils.h:106
Padding and stride information class.
Definition: Types.h:647
void end(TokenStream &in, bool &valid)
Definition: MLGOParser.cpp:290
std::array< T, num_max_dimensions >::iterator begin()
Returns a read/write iterator that points to the first element in the dimension array.
Definition: Dimensions.h:215
GEMMLowpOutputStageType
GEMMLowp output stage type.
Definition: Types.h:1879
size_t num_of_elements_in_range(const float start, const float end, const float step)
Returns the number of elements required to go from start to end with the wanted step.
Definition: Utils.h:1097
1 channel, 1 S16 per channel
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.
const char * name
TensorShape adjust_odd_shape(const TensorShape &shape, Format format)
Adjust tensor shape size if width or height are odd for a given multi-planar format.
Definition: Utils.h:671
DataType data_type_from_format(Format format)
Return the data type used by a given single-planar pixel format.
Definition: Utils.h:219
bool is_data_type_quantized_asymmetric(DataType dt)
Check if a given data type is of asymmetric quantized type.
Definition: Utils.h:1003
Strides of an item in bytes.
Definition: Strides.h:37
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
std::array< T, num_max_dimensions >::iterator end()
Returns a read/write iterator that points one past the last element in the dimension array...
Definition: Dimensions.h:239
const std::string & string_from_data_layout(DataLayout dl)
Convert a data layout identity into a string.
Definition: Utils.cpp:123
size_t pixel_size_from_format(Format format)
The size in bytes of the pixel format.
Definition: Utils.h:146
constexpr int step
Definition: fp32.cpp:35
Class for specifying the size of an image or rectangle.
Definition: Size2D.h:34
const QuantizationInfo qinfo
Definition: Im2Col.cpp:155
unsigned int num_dimensions() const
Returns the effective dimensionality of the tensor.
Definition: Dimensions.h:143
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
bool has_format_horizontal_subsampling(Format format)
Return true if the given format has horizontal subsampling.
Definition: Utils.h:642
unsigned int adjust_vec_size(unsigned int vec_size, size_t dim0)
Returns the adjusted vector size in case it is less than the input&#39;s first dimension, getting rounded down to its closest valid vector size.
Definition: Utils.h:1171
quantized, asymmetric fixed-point 8-bit number signed
DataLayout dl
64-bit floating-point number
DataType data_type_from_name(const std::string &name)
Convert a string to DataType.
Definition: Utils.cpp:301
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
static bfloat16 max()
Largest representative value.
Definition: Bfloat16.h:130
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
std::tuple< PixelValue, PixelValue > get_min_max(DataType dt)
Compute the mininum and maximum values a data type can take.
Definition: Utils.h:564
TensorShape & set(size_t dimension, size_t value, bool apply_dim_correction=true, bool increase_dim_unit=true)
Accessor to set the value of one of the dimensions.
Definition: TensorShape.h:79
bool is_data_type_float(DataType dt)
Check if a given data type is of floating point type.
Definition: Utils.h:961
int channel_idx_from_format(Format format, Channel channel)
Return the channel index of a given channel given an input format.
Definition: Utils.h:327
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
inline ::std::istream & operator>>(::std::istream &stream, DataType &data_type)
Input Stream operator for DataType.
Definition: Utils.h:940
const std::string & string_from_format(Format format)
Convert a tensor format into a string.
Definition: Utils.cpp:76