Compute Library
 21.02
Types.h
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 #ifndef ARM_COMPUTE_TYPES_H
25 #define ARM_COMPUTE_TYPES_H
26 
33 #include "support/Bfloat16.h"
34 #include "support/Half.h"
35 
36 #include <cmath>
37 #include <cstddef>
38 #include <cstdint>
39 #include <map>
40 #include <string>
41 #include <utility>
42 
43 namespace arm_compute
44 {
45 /** 16-bit floating point type */
47 
48 /** Permutation vector */
50 /** Bidirectional strides */
52 
53 /** Image colour formats */
54 enum class Format
55 {
56  UNKNOWN, /**< Unknown image format */
57  U8, /**< 1 channel, 1 U8 per channel */
58  S16, /**< 1 channel, 1 S16 per channel */
59  U16, /**< 1 channel, 1 U16 per channel */
60  S32, /**< 1 channel, 1 S32 per channel */
61  U32, /**< 1 channel, 1 U32 per channel */
62  BFLOAT16, /**< 16-bit brain floating-point number */
63  F16, /**< 1 channel, 1 F16 per channel */
64  F32, /**< 1 channel, 1 F32 per channel */
65  UV88, /**< 2 channel, 1 U8 per channel */
66  RGB888, /**< 3 channels, 1 U8 per channel */
67  RGBA8888, /**< 4 channels, 1 U8 per channel */
68  YUV444, /**< A 3 plane of 8 bit 4:4:4 sampled Y, U, V planes */
69  YUYV422, /**< A single plane of 32-bit macro pixel of Y0, U0, Y1, V0 bytes */
70  NV12, /**< A 2 plane YUV format of Luma (Y) and interleaved UV data at 4:2:0 sampling */
71  NV21, /**< A 2 plane YUV format of Luma (Y) and interleaved VU data at 4:2:0 sampling */
72  IYUV, /**< A 3 plane of 8-bit 4:2:0 sampled Y, U, V planes */
73  UYVY422 /**< A single plane of 32-bit macro pixel of U0, Y0, V0, Y1 byte */
74 };
75 
76 /** Available data types */
77 enum class DataType
78 {
79  UNKNOWN, /**< Unknown data type */
80  U8, /**< unsigned 8-bit number */
81  S8, /**< signed 8-bit number */
82  QSYMM8, /**< quantized, symmetric fixed-point 8-bit number */
83  QASYMM8, /**< quantized, asymmetric fixed-point 8-bit number unsigned */
84  QASYMM8_SIGNED, /**< quantized, asymmetric fixed-point 8-bit number signed */
85  QSYMM8_PER_CHANNEL, /**< quantized, symmetric per channel fixed-point 8-bit number */
86  U16, /**< unsigned 16-bit number */
87  S16, /**< signed 16-bit number */
88  QSYMM16, /**< quantized, symmetric fixed-point 16-bit number */
89  QASYMM16, /**< quantized, asymmetric fixed-point 16-bit number */
90  U32, /**< unsigned 32-bit number */
91  S32, /**< signed 32-bit number */
92  U64, /**< unsigned 64-bit number */
93  S64, /**< signed 64-bit number */
94  BFLOAT16, /**< 16-bit brain floating-point number */
95  F16, /**< 16-bit floating-point number */
96  F32, /**< 32-bit floating-point number */
97  F64, /**< 64-bit floating-point number */
98  SIZET /**< size_t */
99 };
100 
101 /** Available Sampling Policies */
102 enum class SamplingPolicy
103 {
104  CENTER, /**< Samples are taken at pixel center */
105  TOP_LEFT /**< Samples are taken at pixel top left corner */
106 };
107 
108 /** Constant value of the border pixels when using BorderMode::CONSTANT */
109 constexpr uint8_t CONSTANT_BORDER_VALUE = 199;
110 
111 /** Constant value used to indicate a half-scale pyramid */
112 constexpr float SCALE_PYRAMID_HALF = 0.5f;
113 
114 /** Constant value used to indicate a ORB scaled pyramid */
115 constexpr float SCALE_PYRAMID_ORB = 8.408964152537146130583778358414e-01;
116 
117 /** [DataLayout enum definition] **/
118 
119 /** Supported tensor data layouts */
120 enum class DataLayout
121 {
122  UNKNOWN, /**< Unknown data layout */
123  NCHW, /**< Num samples, channels, height, width */
124  NHWC /**< Num samples, height, width, channels */
125 };
126 /** [DataLayout enum definition] **/
127 
128 /** Supported tensor data layout dimensions */
130 {
131  CHANNEL, /**< channel */
132  HEIGHT, /**< height */
133  WIDTH, /**< width */
134  BATCHES /**< batches */
135 };
136 
137 /** Available ConvolutionMethod*/
139 {
140  GEMM, /**< Convolution using GEMM */
141  GEMM_CONV2D, /**< Direct 2D GEMM convolution */
142  DIRECT, /**< Direct convolution */
143  WINOGRAD, /**< Convolution using Winograd */
144  FFT /**< Convolution using FFT */
145 };
146 
147 /** Available DepthwiseConvolutionFunction*/
149 {
150  OPTIMIZED, /**< Optimized Depthwise Convolution */
151  GENERIC, /**< Generic Depthwise Convolution */
152 };
153 
154 /** Available DeconvolutionMethod*/
156 {
157  GEMM, /**< Deconvolution using GEMM */
158  DIRECT, /**< Direct deconvolution */
159 };
160 
161 /** Available FuseBatchNormalizationType*/
163 {
164  CONVOLUTION, /**< For Convolution weights */
165  DEPTHWISECONVOLUTION /**< For Depthwise Convolution weights*/
166 };
167 
168 /** Padding mode to use for PadLayer */
169 enum class PaddingMode
170 {
171  CONSTANT,
172  REFLECT,
173  SYMMETRIC
174 };
175 
176 /** Supported comparison operations */
178 {
179  Equal, /**< Equal comparison ( \f$ x == y \f$ ) */
180  NotEqual, /**< NotEqual comparison ( \f$ x != y \f$ ) */
181  Greater, /**< Greater comparison ( \f$ x > y \f$ ) */
182  GreaterEqual, /**< Greater equal comparison ( \f$ x >= y \f$ ) */
183  Less, /**< Less comparison ( \f$ x < y \f$ ) */
184  LessEqual /**< Less equal comparison ( \f$ x <= y \f$ ) */
185 };
186 
187 /** Container for valid region of a window */
189 {
190  /** Default constructor */
192  : anchor{}, shape{}
193  {
194  }
195 
196  /** Allow instances of this class to be copy constructed */
197  ValidRegion(const ValidRegion &) = default;
198  /** Allow instances of this class to be move constructed */
199  ValidRegion(ValidRegion &&) = default;
200  /** Allow instances of this class to be copied */
201  ValidRegion &operator=(const ValidRegion &) = default;
202  /** Allow instances of this class to be moved */
203  ValidRegion &operator=(ValidRegion &&) = default;
204  /** Default destructor */
205  ~ValidRegion() = default;
206 
207  /** Constructor for a valid region with default number of dimensions
208  *
209  * @param[in] an_anchor Anchor for the start of the valid region.
210  * @param[in] a_shape Shape of the valid region.
211  *
212  */
213  ValidRegion(const Coordinates &an_anchor, const TensorShape &a_shape)
214  : anchor{ an_anchor }, shape{ a_shape }
215  {
216  anchor.set_num_dimensions(std::max(anchor.num_dimensions(), shape.num_dimensions()));
217  }
218 
219  /** Constructor for a valid region with specified number of dimensions
220  *
221  * @param[in] an_anchor Anchor for the start of the valid region.
222  * @param[in] a_shape Shape of the valid region.
223  * @param[in] num_dimensions Number of dimensions (must be >= number of dimensions of anchor and shape).
224  *
225  */
226  ValidRegion(const Coordinates &an_anchor, const TensorShape &a_shape, size_t num_dimensions)
227  : anchor{ an_anchor }, shape{ a_shape }
228  {
229  ARM_COMPUTE_ERROR_ON(num_dimensions < std::max(anchor.num_dimensions(), shape.num_dimensions()));
230  anchor.set_num_dimensions(num_dimensions);
231  }
232 
233  /** Return the start of the valid region for the given dimension @p d */
234  int start(unsigned int d) const
235  {
236  return anchor[d];
237  }
238 
239  /** Return the end of the valid region for the given dimension @p d */
240  int end(unsigned int d) const
241  {
242  return anchor[d] + shape[d];
243  }
244 
245  /** Accessor to set the value of anchor and shape for one of the dimensions.
246  *
247  * @param[in] dimension Dimension for which the value is set.
248  * @param[in] start Value to be set in anchor for the dimension.
249  * @param[in] size Value to be set in shape for the dimension.
250  *
251  * @return *this.
252  */
253  ValidRegion &set(size_t dimension, int start, size_t size)
254  {
255  anchor.set(dimension, start);
256  shape.set(dimension, size);
257  return *this;
258  }
259 
260  Coordinates anchor; /**< Anchor for the start of the valid region. */
261  TensorShape shape; /**< Shape of the valid region. */
262 };
263 
264 /** Methods available to handle borders */
265 enum class BorderMode
266 {
267  UNDEFINED, /**< Borders are left undefined */
268  CONSTANT, /**< Pixels outside the image are assumed to have a constant value */
269  REPLICATE /**< Pixels outside the image are assumed to have the same value as the closest image pixel */
270 };
271 
272 /** Container for 2D border size */
274 {
275  /** Empty border, i.e. no border */
276  constexpr BorderSize()
277  : top{ 0 }, right{ 0 }, bottom{ 0 }, left{ 0 }
278  {
279  }
280 
281  /** Border with equal size around the 2D plane */
282  explicit constexpr BorderSize(unsigned int size)
283  : top{ size }, right{ size }, bottom{ size }, left{ size }
284  {
285  }
286 
287  /** Border with same size for top/bottom and left/right */
288  constexpr BorderSize(unsigned int top_bottom, unsigned int left_right)
289  : top{ top_bottom }, right{ left_right }, bottom{ top_bottom }, left{ left_right }
290  {
291  }
292 
293  /** Border with different sizes */
294  constexpr BorderSize(unsigned int top, unsigned int right, unsigned int bottom, unsigned int left)
295  : top{ top }, right{ right }, bottom{ bottom }, left{ left }
296  {
297  }
298 
299  /** Check if the entire border is zero */
300  constexpr bool empty() const
301  {
302  return top == 0 && right == 0 && bottom == 0 && left == 0;
303  }
304 
305  /** Check if the border is the same size on all sides */
306  constexpr bool uniform() const
307  {
308  return top == right && top == bottom && top == left;
309  }
310 
311  /** Scale this border size.
312  *
313  * @param[in] scale Scale to multiply border size by.
314  *
315  * @return *this.
316  */
318  {
319  top *= scale;
320  right *= scale;
321  bottom *= scale;
322  left *= scale;
323 
324  return *this;
325  }
326 
327  /** Scale a copy of this border size.
328  *
329  * @param[in] scale Scale to multiply border size by.
330  *
331  * @return a scaled copy of this.
332  */
334  {
335  BorderSize size = *this;
336  size *= scale;
337 
338  return size;
339  }
340 
341  /** Check equality with another BorderSize struct
342  *
343  * @param[in] rhs other struct to check against
344  *
345  * @return true if they are equal
346  */
347  bool operator==(const BorderSize &rhs)
348  {
349  return (top == rhs.top) && (right == rhs.right) && (bottom == rhs.bottom) && (left == rhs.left);
350  }
351 
352  /** Check non-equality with another BorderSize struct
353  *
354  * @param[in] rhs other struct to check against
355  *
356  * @return true if they are different
357  */
358  bool operator!=(const BorderSize &rhs)
359  {
360  return !(*this == rhs);
361  }
362 
363  /** Limit this border size.
364  *
365  * @param[in] limit Border size to limit this border size to.
366  */
367  void limit(const BorderSize &limit)
368  {
369  top = std::min(top, limit.top);
370  right = std::min(right, limit.right);
371  bottom = std::min(bottom, limit.bottom);
372  left = std::min(left, limit.left);
373  }
374 
375  unsigned int top; /**< top of the border */
376  unsigned int right; /**< right of the border */
377  unsigned int bottom; /**< bottom of the border */
378  unsigned int left; /**< left of the border */
379 };
380 
381 /** Container for 2D padding size */
383 
384 /** Policy to handle overflow */
385 enum class ConvertPolicy
386 {
387  WRAP, /**< Wrap around */
388  SATURATE /**< Saturate */
389 };
390 
391 /** Interpolation method */
393 {
394  NEAREST_NEIGHBOR, /**< Output values are defined to match the source pixel whose center is nearest to the sample position */
395  BILINEAR, /**< Output values are defined by bilinear interpolation between the pixels */
396  AREA, /**< Output values are determined by averaging the source pixels whose areas fall under the area of the destination pixel, projected onto the source image */
397 };
398 
399 /** Bilinear Interpolation method used by LKTracker */
401 {
402  BILINEAR_OLD_NEW, /**< Old-new method */
403  BILINEAR_SCHARR /**< Scharr method */
404 };
405 
406 /** Threshold mode */
407 enum class ThresholdType
408 {
409  BINARY, /**< Threshold with one value */
410  RANGE /**< Threshold with two values*/
411 };
412 
413 /** Termination criteria */
414 enum class Termination
415 {
416  TERM_CRITERIA_EPSILON, /**< Terminate when within epsilon of a threshold */
417  TERM_CRITERIA_ITERATIONS, /**< Terminate after a maximum number of iterations */
418  TERM_CRITERIA_BOTH /**< Terminate on whichever of the other conditions occurs first */
419 };
420 
421 /** Magnitude calculation type. */
422 enum class MagnitudeType
423 {
424  L1NORM, /**< L1 normalization type */
425  L2NORM /**< L2 normalization type */
426 };
427 
428 /** Phase calculation type.
429  *
430  * @note When PhaseType == SIGNED, each angle is mapped to the range 0 to 255 inclusive otherwise angles between 0 and 180
431  */
432 enum class PhaseType
433 {
434  SIGNED, /**< Angle range: [0, 360] */
435  UNSIGNED /**< Angle range: [0, 180] */
436 };
437 
438 /** Keypoint type */
439 struct KeyPoint
440 {
441  int32_t x{ 0 }; /**< X coordinates */
442  int32_t y{ 0 }; /**< Y coordinates */
443  float strength{ 0.f }; /**< Strength of the point */
444  float scale{ 0.f }; /**< Scale initialized to 0 by the corner detector */
445  float orientation{ 0.f }; /**< Orientation initialized to 0 by the corner detector */
446  int32_t tracking_status{ 0 }; /**< Status initialized to 1 by the corner detector, set to 0 when the point is lost */
447  float error{ 0.f }; /**< Tracking error initialized to 0 by the corner detector */
448 };
449 
450 /** Internal key point */
451 using InternalKeypoint = std::tuple<float, float, float>; /* x,y,strength */
452 
453 /** Rectangle type */
454 struct Rectangle
455 {
456  uint16_t x; /**< Top-left x coordinate */
457  uint16_t y; /**< Top-left y coordinate */
458  uint16_t width; /**< Width of the rectangle */
459  uint16_t height; /**< Height of the rectangle */
460 };
461 
462 /** Coordinate type */
464 {
465  int32_t x; /**< X coordinates */
466  int32_t y; /**< Y coordinates */
467 };
468 
469 /** Coordinate type */
471 {
472  uint32_t x; /**< X coordinates */
473  uint32_t y; /**< Y coordinates */
474  uint32_t z; /**< Z coordinates */
475 };
476 
477 /** Padding information as a pair of unsigned int start/end */
478 using PaddingInfo = std::pair<uint32_t, uint32_t>;
479 
480 /** List of padding information */
481 using PaddingList = std::vector<PaddingInfo>;
482 
483 /** Information to produce a tiled version of a Tensor */
484 using Multiples = std::vector<uint32_t>;
485 
486 /** Available channels */
487 enum class Channel
488 {
489  UNKNOWN, /** Unknown channel format */
490  C0, /**< First channel (used by formats with unknown channel types). */
491  C1, /**< Second channel (used by formats with unknown channel types). */
492  C2, /**< Third channel (used by formats with unknown channel types). */
493  C3, /**< Fourth channel (used by formats with unknown channel types). */
494  R, /**< Red channel. */
495  G, /**< Green channel. */
496  B, /**< Blue channel. */
497  A, /**< Alpha channel. */
498  Y, /**< Luma channel. */
499  U, /**< Cb/U channel. */
500  V /**< Cr/V/Value channel. */
501 };
502 
503 /** Available matrix patterns */
504 enum class MatrixPattern
505 {
506  BOX, /**< Box pattern matrix. */
507  CROSS, /**< Cross pattern matrix. */
508  DISK, /**< Disk pattern matrix. */
509  OTHER /**< Any other matrix pattern. */
510 };
511 
512 /** Available non linear functions. */
513 enum class NonLinearFilterFunction : unsigned
514 {
515  MEDIAN = 0, /**< Non linear median filter. */
516  MIN = 1, /**< Non linear erode. */
517  MAX = 2, /**< Non linear dilate. */
518 };
519 
520 /** Available reduction operations */
522 {
523  ARG_IDX_MAX, /**< Index of the max value */
524  ARG_IDX_MIN, /**< Index of the min value */
525  MEAN_SUM, /**< Mean of sum */
526  PROD, /**< Product */
527  SUM_SQUARE, /**< Sum of squares */
528  SUM, /**< Sum */
529  MIN, /**< Min */
530  MAX, /**< Max */
531 };
532 
533 /** Available element-wise operations */
535 {
536  ADD, /**< (x + y) */
537  SUB, /**< (x - y) */
538  DIV, /**< (x / y) */
539  MIN, /**< Min(x, y) */
540  MAX, /**< Max(x, y) */
541  SQUARED_DIFF, /**< (x - y)^2 */
542  POWER, /**< x ^ y */
543  PRELU, /**< y*x if x < 0, x otherwise */
544 };
545 
546 /** Available element wise unary operations */
548 {
549  RSQRT, /**< Reverse square root */
550  EXP, /**< Exponential */
551  NEG, /**< Negate */
552  LOG, /**< Natural Logarithm */
553  ABS, /**< Absolute value */
554  SIN, /**< Sine */
555  ROUND, /**< Round */
556  LOGICAL_NOT, /**< Logical Not */
557 };
558 
559 /** Available bitwise operations */
561 {
562  AND, /**< Bitwise AND operation */
563  NOT, /**< Bitwise NOT operation */
564  OR, /**< Bitwise OR operation */
565  XOR, /**< Bitwise XOR operation */
566 };
567 
568 /** The normalization type used for the normalization layer */
569 enum class NormType
570 {
571  IN_MAP_1D, /**< Normalization applied within the same map in 1D region */
572  IN_MAP_2D, /**< Normalization applied within the same map in 2D region */
573  CROSS_MAP /**< Normalization applied cross maps */
574 };
575 
576 /** Normalization type for Histogram of Oriented Gradients (HOG) */
577 enum class HOGNormType
578 {
579  L2_NORM = 1, /**< L2-norm */
580  L2HYS_NORM = 2, /**< L2-norm followed by clipping */
581  L1_NORM = 3 /**< L1 norm */
582 };
583 
584 /** Detection window used for the object detection. The detection window keeps the following information:
585  *
586  * -# Geometry of the rectangular window (x/y of top-left corner and width/height)
587  * -# Index of the class used for evaluating which class the detection window belongs to
588  * -# Confidence value (score) obtained with the classifier
589  */
591 {
592  uint16_t x{ 0 }; /**< Top-left x coordinate */
593  uint16_t y{ 0 }; /**< Top-left y coordinate */
594  uint16_t width{ 0 }; /**< Width of the detection window */
595  uint16_t height{ 0 }; /**< Height of the detection window */
596  uint16_t idx_class{ 0 }; /**< Index of the class */
597  float score{ 0.f }; /**< Confidence value for the detection window */
598 };
599 
600 /** Dimension rounding type when down-scaling on CNNs
601  * @note Used in pooling and convolution layer
602  */
604 {
605  FLOOR, /**< Floor rounding */
606  CEIL /**< Ceil rounding */
607 };
608 
609 /** Available pooling types */
610 enum class PoolingType
611 {
612  MAX, /**< Max Pooling */
613  AVG, /**< Average Pooling */
614  L2 /**< L2 Pooling */
615 };
616 
617 /** Available non maxima suppression types */
618 enum class NMSType
619 {
620  LINEAR, /**< Linear NMS */
621  GAUSSIAN, /**< Gaussian NMS */
622  ORIGINAL /**< Original NMS */
623 };
624 
625 /** BoxWithNonMaximaSuppressionLimit Information class */
626 class BoxNMSLimitInfo final
627 {
628 public:
629  /** Constructor
630  *
631  * @param[in] score_thresh (Optional) Score threshold.
632  * @param[in] nms (Optional) NMS value
633  * @param[in] detections (Optional) Number of detections
634  * @param[in] soft_nms_enabled (Optional) Enable SoftNMS
635  * @param[in] soft_nms_method (Optional) Soft NMS method
636  * @param[in] soft_nms_sigma (Optional) Soft NMS sigma value
637  * @param[in] soft_nms_min_score_thres (Optional) Soft NMS minimum score threshold
638  * @param[in] suppress_size (Optional) Filter out boxes based on their size. Defaults to false
639  * @param[in] min_size (Optional) Smaller boxes than min_size will be filtered out. Defaults to 1
640  * @param[in] im_width (Optional) Boxes whose centers (on the x axis) is beyond im_width will be filtered. Defaults to 1
641  * @param[in] im_height (Optional) Boxes whose centers (on the y axis) is beyond im_height will be filtered. Defaults to 1
642  */
643  BoxNMSLimitInfo(float score_thresh = 0.05f, float nms = 0.3f,
644  int detections = 100, bool soft_nms_enabled = false,
645  NMSType soft_nms_method = NMSType::LINEAR,
646  float soft_nms_sigma = 0.5f, float soft_nms_min_score_thres = 0.001f, bool suppress_size = false, float min_size = 1.0f, float im_width = 1.0f, float im_height = 1.0f)
647  : _score_thresh(score_thresh), _nms(nms), _detections_per_im(detections), _soft_nms_enabled(soft_nms_enabled), _soft_nms_method(soft_nms_method), _soft_nms_sigma(soft_nms_sigma),
648  _soft_nms_min_score_thres(soft_nms_min_score_thres), _suppress_size(suppress_size), _min_size(min_size), _im_width(im_width), _im_height(im_height)
649  {
650  }
651  /** Get the score threshold */
652  float score_thresh() const
653  {
654  return _score_thresh;
655  }
656  /** Get the NMS */
657  float nms() const
658  {
659  return _nms;
660  }
661  /** Get the number of detections */
662  int detections_per_im() const
663  {
664  return _detections_per_im;
665  }
666  /** Check if soft NMS is enabled */
667  bool soft_nms_enabled() const
668  {
669  return _soft_nms_enabled;
670  }
671  /** Get soft NMS method */
673  {
674  return _soft_nms_method;
675  }
676  /** Get soft NMS sigma */
677  float soft_nms_sigma() const
678  {
679  return _soft_nms_sigma;
680  }
681  /** Get soft nms min score threshold */
683  {
684  return _soft_nms_min_score_thres;
685  }
686  /** Get if NMS will suppress boxes based on their size/position */
687  bool suppress_size() const
688  {
689  return _suppress_size;
690  }
691  /** Get size suppression threshold */
692  float min_size() const
693  {
694  return _min_size;
695  }
696  /** Get image width (NMS may suppress boxes whose center sits beyond the image width) */
697  float im_width() const
698  {
699  return _im_width;
700  }
701  /** Get image height (NMS may suppress boxes whose center sits beyond the image height) */
702  float im_height() const
703  {
704  return _im_height;
705  }
706 
707 private:
708  float _score_thresh;
709  float _nms;
710  int _detections_per_im;
711  bool _soft_nms_enabled;
712  NMSType _soft_nms_method;
713  float _soft_nms_sigma;
714  float _soft_nms_min_score_thres;
715  bool _suppress_size;
716  float _min_size;
717  float _im_width;
718  float _im_height;
719 };
720 
721 /** Padding and stride information class */
723 {
724 public:
725  /** Constructor
726  *
727  * @param[in] stride_x (Optional) Stride, in elements, across x. Defaults to 1.
728  * @param[in] stride_y (Optional) Stride, in elements, across y. Defaults to 1.
729  * @param[in] pad_x (Optional) Padding, in elements, across x. Defaults to 0.
730  * @param[in] pad_y (Optional) Padding, in elements, across y. Defaults to 0.
731  * @param[in] round (Optional) Dimensions rounding. Defaults to @ref FLOOR.
732  */
733  PadStrideInfo(unsigned int stride_x = 1, unsigned int stride_y = 1,
734  unsigned int pad_x = 0, unsigned int pad_y = 0,
736  : _stride(std::make_pair(stride_x, stride_y)),
737  _pad_left(pad_x),
738  _pad_top(pad_y),
739  _pad_right(pad_x),
740  _pad_bottom(pad_y),
741  _round_type(round)
742  {
743  }
744  /** Constructor
745  *
746  * @param[in] stride_x Stride, in elements, across x.
747  * @param[in] stride_y Stride, in elements, across y.
748  * @param[in] pad_left Padding across x on the left, in elements.
749  * @param[in] pad_top Padding across y on the top, in elements.
750  * @param[in] pad_right Padding across x on the right, in elements.
751  * @param[in] pad_bottom Padding across y on the bottom, in elements.
752  * @param[in] round Dimensions rounding.
753  */
754  PadStrideInfo(unsigned int stride_x, unsigned int stride_y,
755  unsigned int pad_left, unsigned int pad_right,
756  unsigned int pad_top, unsigned int pad_bottom,
758  : _stride(std::make_pair(stride_x, stride_y)),
759  _pad_left(pad_left),
760  _pad_top(pad_top),
761  _pad_right(pad_right),
762  _pad_bottom(pad_bottom),
763  _round_type(round)
764  {
765  }
766  /** Get the stride.
767  *
768  * @return a pair: stride x, stride y.
769  */
770  std::pair<unsigned int, unsigned int> stride() const
771  {
772  return _stride;
773  }
774  /** Check whether the padding is symmetric.
775  *
776  * @return True if the padding is symmetric.
777  */
778  bool padding_is_symmetric() const
779  {
780  return (_pad_left == _pad_right) && (_pad_top == _pad_bottom);
781  }
782  /** Get the padding.
783  *
784  * @note This should only be used when the padding is symmetric.
785  *
786  * @return a pair: padding left/right, padding top/bottom
787  */
788  std::pair<unsigned int, unsigned int> pad() const
789  {
790  //this accessor should be used only when padding is symmetric
791  ARM_COMPUTE_ERROR_ON(!padding_is_symmetric());
792  return std::make_pair(_pad_left, _pad_top);
793  }
794 
795  /** Get the left padding */
796  unsigned int pad_left() const
797  {
798  return _pad_left;
799  }
800  /** Get the right padding */
801  unsigned int pad_right() const
802  {
803  return _pad_right;
804  }
805  /** Get the top padding */
806  unsigned int pad_top() const
807  {
808  return _pad_top;
809  }
810  /** Get the bottom padding */
811  unsigned int pad_bottom() const
812  {
813  return _pad_bottom;
814  }
815 
816  /** Get the rounding type */
818  {
819  return _round_type;
820  }
821 
822  /** Check whether this has any padding */
823  bool has_padding() const
824  {
825  return (_pad_left != 0 || _pad_top != 0 || _pad_right != 0 || _pad_bottom != 0);
826  }
827 
828 private:
829  std::pair<unsigned int, unsigned int> _stride;
830  unsigned int _pad_left;
831  unsigned int _pad_top;
832  unsigned int _pad_right;
833  unsigned int _pad_bottom;
834 
835  DimensionRoundingType _round_type;
836 };
837 
838 /** PriorBox layer info */
839 class PriorBoxLayerInfo final
840 {
841 public:
842  /** Default Constructor */
844  : _min_sizes(),
845  _variances(),
846  _offset(),
847  _flip(true),
848  _clip(false),
849  _max_sizes(),
850  _aspect_ratios(),
851  _img_size(),
852  _steps()
853  {
854  }
855  /** Constructor
856  *
857  * @param[in] min_sizes Min sizes vector.
858  * @param[in] variances Variances vector.
859  * @param[in] offset Offset value.
860  * @param[in] flip (Optional) Flip the aspect ratios.
861  * @param[in] clip (Optional) Clip coordinates so that they're within [0,1].
862  * @param[in] max_sizes (Optional) Max sizes vector.
863  * @param[in] aspect_ratios (Optional) Aspect ratios of the boxes.
864  * @param[in] img_size (Optional) Image size.
865  * @param[in] steps (Optional) Step values.
866  */
867  PriorBoxLayerInfo(const std::vector<float> &min_sizes, const std::vector<float> &variances, float offset, bool flip = true, bool clip = false,
868  const std::vector<float> &max_sizes = {}, const std::vector<float> &aspect_ratios = {},
869  const Coordinates2D &img_size = Coordinates2D{ 0, 0 }, const std::array<float, 2> &steps = { { 0.f, 0.f } })
870  : _min_sizes(min_sizes),
871  _variances(variances),
872  _offset(offset),
873  _flip(flip),
874  _clip(clip),
875  _max_sizes(max_sizes),
876  _aspect_ratios(),
877  _img_size(img_size),
878  _steps(steps)
879  {
880  _aspect_ratios.push_back(1.);
881  for(unsigned int i = 0; i < aspect_ratios.size(); ++i)
882  {
883  float ar = aspect_ratios[i];
884  bool already_exist = false;
885  for(auto ar_new : _aspect_ratios)
886  {
887  if(fabs(ar - ar_new) < 1e-6)
888  {
889  already_exist = true;
890  break;
891  }
892  }
893  if(!already_exist)
894  {
895  _aspect_ratios.push_back(ar);
896  if(flip)
897  {
898  _aspect_ratios.push_back(1.f / ar);
899  }
900  }
901  }
902  }
903  /** Get min sizes. */
904  std::vector<float> min_sizes() const
905  {
906  return _min_sizes;
907  }
908  /** Get min variances. */
909  std::vector<float> variances() const
910  {
911  return _variances;
912  }
913  /** Get the step coordinates */
914  std::array<float, 2> steps() const
915  {
916  return _steps;
917  }
918  /** Get the image size coordinates */
920  {
921  return _img_size;
922  }
923  /** Get the offset */
924  float offset() const
925  {
926  return _offset;
927  }
928  /** Get the flip value */
929  bool flip() const
930  {
931  return _flip;
932  }
933  /** Get the clip value */
934  bool clip() const
935  {
936  return _clip;
937  }
938  /** Get max sizes. */
939  std::vector<float> max_sizes() const
940  {
941  return _max_sizes;
942  }
943  /** Get aspect ratios. */
944  std::vector<float> aspect_ratios() const
945  {
946  return _aspect_ratios;
947  }
948 
949 private:
950  std::vector<float> _min_sizes;
951  std::vector<float> _variances;
952  float _offset;
953  bool _flip;
954  bool _clip;
955  std::vector<float> _max_sizes;
956  std::vector<float> _aspect_ratios;
957  Coordinates2D _img_size;
958  std::array<float, 2> _steps;
959 };
960 
961 // Bounding Box [xmin, ymin, xmax, ymax]
962 using BBox = std::array<float, 4>;
963 // LabelBBox used for map label and bounding box
964 using LabelBBox = std::map<int, std::vector<BBox>>;
965 
966 /** Available Detection Output code types */
968 {
969  CORNER, /**< Use box corners */
970  CENTER_SIZE, /**< Use box centers and size */
971  CORNER_SIZE, /**< Use box centers and size */
972  TF_CENTER /**< Use box centers and size but flip x and y co-ordinates */
973 };
974 
975 /** Detection Output layer info */
977 {
978 public:
979  /** Default Constructor */
981  : _num_classes(),
982  _share_location(),
984  _keep_top_k(),
985  _nms_threshold(),
986  _top_k(),
987  _background_label_id(),
988  _confidence_threshold(),
989  _variance_encoded_in_target(false),
990  _eta(),
991  _num_loc_classes()
992  {
993  _num_loc_classes = _share_location ? 1 : _num_classes;
994  }
995  /** Constructor
996  *
997  * @param[in] num_classes Number of classes to be predicted.
998  * @param[in] share_location If true, bounding box are shared among different classes.
999  * @param[in] code_type Type of coding method for bbox.
1000  * @param[in] keep_top_k Number of total bounding boxes to be kept per image after NMS step.
1001  * @param[in] nms_threshold Threshold to be used in NMS.
1002  * @param[in] top_k (Optional) Number of boxes per image with top confidence scores that are fed into the NMS algorithm. Default set to -1.
1003  * @param[in] background_label_id (Optional) Background label ID. If there is no background class, set it as -1.
1004  * @param[in] confidence_threshold (Optional) Only consider detections whose confidences are larger than a threshold. Default set to -FLT_MAX.
1005  * @param[in] variance_encoded_in_target (Optional) If true, variance is encoded in target. Otherwise we need to adjust the predicted offset accordingly.Default set to false.
1006  * @param[in] eta (Optional) Eta.
1007  */
1008  DetectionOutputLayerInfo(int num_classes, bool share_location, DetectionOutputLayerCodeType code_type, int keep_top_k, float nms_threshold, int top_k = -1, int background_label_id = -1,
1009  float confidence_threshold = std::numeric_limits<float>::lowest(), bool variance_encoded_in_target = false, float eta = 1)
1010  : _num_classes(num_classes),
1011  _share_location(share_location),
1012  _code_type(code_type),
1013  _keep_top_k(keep_top_k),
1014  _nms_threshold(nms_threshold),
1015  _top_k(top_k),
1016  _background_label_id(background_label_id),
1017  _confidence_threshold(confidence_threshold),
1018  _variance_encoded_in_target(variance_encoded_in_target),
1019  _eta(eta),
1020  _num_loc_classes()
1021  {
1022  _num_loc_classes = _share_location ? 1 : _num_classes;
1023  }
1024  /** Get num classes. */
1025  int num_classes() const
1026  {
1027  return _num_classes;
1028  }
1029  /** Get share location. */
1030  bool share_location() const
1031  {
1032  return _share_location;
1033  }
1034  /** Get detection output code type. */
1036  {
1037  return _code_type;
1038  }
1039  /** Get if variance encoded in target. */
1041  {
1042  return _variance_encoded_in_target;
1043  }
1044  /** Get the number of total bounding boxes to be kept per image. */
1045  int keep_top_k() const
1046  {
1047  return _keep_top_k;
1048  }
1049  /** Get nms threshold. */
1050  float nms_threshold() const
1051  {
1052  return _nms_threshold;
1053  }
1054  /** Get eta. */
1055  float eta() const
1056  {
1057  return _eta;
1058  }
1059  /** Get background label ID. */
1061  {
1062  return _background_label_id;
1063  }
1064  /** Get confidence threshold. */
1065  float confidence_threshold() const
1066  {
1067  return _confidence_threshold;
1068  }
1069  /** Get top K. */
1070  int top_k() const
1071  {
1072  return _top_k;
1073  }
1074  /** Get number of location classes. */
1075  int num_loc_classes() const
1076  {
1077  return _num_loc_classes;
1078  }
1079 
1080 private:
1081  int _num_classes;
1082  bool _share_location;
1083  DetectionOutputLayerCodeType _code_type;
1084  int _keep_top_k;
1085  float _nms_threshold;
1086  int _top_k;
1087  int _background_label_id;
1088  float _confidence_threshold;
1089  bool _variance_encoded_in_target;
1090  float _eta;
1091  int _num_loc_classes;
1092 };
1093 
1094 /** Detection Output layer info */
1096 {
1097 public:
1098  /** Default Constructor */
1100  : _max_detections(),
1101  _max_classes_per_detection(),
1102  _nms_score_threshold(),
1103  _iou_threshold(),
1104  _num_classes(),
1105  _scales_values(),
1106  _use_regular_nms(),
1107  _detection_per_class(),
1108  _dequantize_scores()
1109  {
1110  }
1111  /** Constructor
1112  *
1113  * @param[in] max_detections Number of total detection.
1114  * @param[in] max_classes_per_detection Number of total classes to be kept after NMS step. Used in the Fast Non-Max-Suppression
1115  * @param[in] nms_score_threshold Threshold to be used in NMS
1116  * @param[in] iou_threshold Threshold to be used during the intersection over union.
1117  * @param[in] num_classes Number of classes.
1118  * @param[in] scales_values Scales values used for decode center size boxes.
1119  * @param[in] use_regular_nms (Optional) Boolean to determinate if use regular or fast nms. Defaults to false.
1120  * @param[in] detection_per_class (Optional) Number of detection per class. Used in the Regular Non-Max-Suppression. Defaults to 100.
1121  * @param[in] dequantize_scores (Optional) If the scores need to be dequantized. Defaults to true.
1122  */
1123  DetectionPostProcessLayerInfo(unsigned int max_detections, unsigned int max_classes_per_detection, float nms_score_threshold, float iou_threshold, unsigned int num_classes,
1124  std::array<float, 4> scales_values, bool use_regular_nms = false, unsigned int detection_per_class = 100, bool dequantize_scores = true)
1125  : _max_detections(max_detections),
1126  _max_classes_per_detection(max_classes_per_detection),
1127  _nms_score_threshold(nms_score_threshold),
1128  _iou_threshold(iou_threshold),
1129  _num_classes(num_classes),
1130  _scales_values(scales_values),
1131  _use_regular_nms(use_regular_nms),
1132  _detection_per_class(detection_per_class),
1133  _dequantize_scores(dequantize_scores)
1134  {
1135  }
1136  /** Get max detections. */
1137  unsigned int max_detections() const
1138  {
1139  return _max_detections;
1140  }
1141  /** Get max_classes per detection. Used in the Fast Non-Max-Suppression.*/
1142  unsigned int max_classes_per_detection() const
1143  {
1144  return _max_classes_per_detection;
1145  }
1146  /** Get detection per class. Used in the Regular Non-Max-Suppression */
1147  unsigned int detection_per_class() const
1148  {
1149  return _detection_per_class;
1150  }
1151  /** Get nms threshold. */
1152  float nms_score_threshold() const
1153  {
1154  return _nms_score_threshold;
1155  }
1156  /** Get intersection over union threshold. */
1157  float iou_threshold() const
1158  {
1159  return _iou_threshold;
1160  }
1161  /** Get num classes. */
1162  unsigned int num_classes() const
1163  {
1164  return _num_classes;
1165  }
1166  /** Get if use regular nms. */
1167  bool use_regular_nms() const
1168  {
1169  return _use_regular_nms;
1170  }
1171  /** Get y scale value. */
1172  float scale_value_y() const
1173  {
1174  // Saved as [y,x,h,w]
1175  return _scales_values[0];
1176  }
1177  /** Get x scale value. */
1178  float scale_value_x() const
1179  {
1180  // Saved as [y,x,h,w]
1181  return _scales_values[1];
1182  }
1183  /** Get h scale value. */
1184  float scale_value_h() const
1185  {
1186  // Saved as [y,x,h,w]
1187  return _scales_values[2];
1188  }
1189  /** Get w scale value. */
1190  float scale_value_w() const
1191  {
1192  // Saved as [y,x,h,w]
1193  return _scales_values[3];
1194  }
1195  /** Get dequantize_scores value. */
1196  bool dequantize_scores() const
1197  {
1198  return _dequantize_scores;
1199  }
1200 
1201 private:
1202  unsigned int _max_detections;
1203  unsigned int _max_classes_per_detection;
1204  float _nms_score_threshold;
1205  float _iou_threshold;
1206  unsigned int _num_classes;
1207  std::array<float, 4> _scales_values;
1208  bool _use_regular_nms;
1209  unsigned int _detection_per_class;
1210  bool _dequantize_scores;
1211 };
1212 
1213 /** Pooling Layer Information struct*/
1215 {
1216  /** Default Constructor */
1218  : pool_type(PoolingType::MAX),
1219  pool_size(Size2D()),
1221  pad_stride_info(PadStrideInfo()),
1222  exclude_padding(false),
1223  is_global_pooling(false),
1224  fp_mixed_precision(false)
1225  {
1226  }
1227  /** Constructor
1228  *
1229  * @param[in] pool_type Pooling type @ref PoolingType.
1230  * @param[in] pool_size Pooling size, in elements, across x and y.
1231  * @param[in] data_layout Data layout used by the layer @ref DataLayout
1232  * @param[in] pad_stride_info (Optional) Padding and stride information @ref PadStrideInfo
1233  * @param[in] exclude_padding (Optional) Strategy when accounting padding in calculations.
1234  * True will exclude padding while false will not (Used in AVG/L2 pooling to determine the pooling area).
1235  * Defaults to false;
1236  * @param[in] fp_mixed_precision (Optional) Use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy.
1237  */
1238  explicit PoolingLayerInfo(PoolingType pool_type,
1239  unsigned int pool_size,
1241  PadStrideInfo pad_stride_info = PadStrideInfo(),
1242  bool exclude_padding = false,
1243  bool fp_mixed_precision = false)
1244  : pool_type(pool_type),
1245  pool_size(Size2D(pool_size, pool_size)),
1246  data_layout(data_layout),
1247  pad_stride_info(pad_stride_info),
1248  exclude_padding(exclude_padding),
1249  is_global_pooling(false),
1250  fp_mixed_precision(fp_mixed_precision)
1251  {
1252  }
1253 
1254  /** Constructor
1255  *
1256  * @param[in] pool_type Pooling type @ref PoolingType.
1257  * @param[in] pool_size Pooling size, in elements, across x and y.
1258  * @param[in] data_layout Data layout used by the layer @ref DataLayout
1259  * @param[in] pad_stride_info (Optional) Padding and stride information @ref PadStrideInfo
1260  * @param[in] exclude_padding (Optional) Strategy when accounting padding in calculations.
1261  * True will exclude padding while false will not (Used in AVG/L2 pooling to determine the pooling area).
1262  * Defaults to false;
1263  * @param[in] fp_mixed_precision (Optional) Use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy.
1264  */
1265  explicit PoolingLayerInfo(PoolingType pool_type,
1266  Size2D pool_size,
1267  DataLayout data_layout,
1268  PadStrideInfo pad_stride_info = PadStrideInfo(),
1269  bool exclude_padding = false,
1270  bool fp_mixed_precision = false)
1271  : pool_type(pool_type),
1272  pool_size(pool_size),
1273  data_layout(data_layout),
1274  pad_stride_info(pad_stride_info),
1275  exclude_padding(exclude_padding),
1276  is_global_pooling(false),
1277  fp_mixed_precision(fp_mixed_precision)
1278  {
1279  }
1280 
1281  /** Constructor
1282  *
1283  * @note This constructor is used for global pooling
1284  *
1285  * @param[in] pool_type Pooling type @ref PoolingType.
1286  * @param[in] data_layout Data layout used by the layer @ref DataLayout
1287  */
1288  explicit PoolingLayerInfo(PoolingType pool_type, DataLayout data_layout)
1289  : pool_type(pool_type),
1290  pool_size(Size2D()),
1291  data_layout(data_layout),
1292  pad_stride_info(PadStrideInfo(1, 1, 0, 0)),
1293  exclude_padding(false),
1294  is_global_pooling(true),
1295  fp_mixed_precision(false)
1296  {
1297  }
1298 
1306 };
1307 
1308 /** ROI Pooling Layer Information class */
1310 {
1311 public:
1312  /** Constructor
1313  *
1314  * @param[in] pooled_width Pooled width of the layer.
1315  * @param[in] pooled_height Pooled height of the layer.
1316  * @param[in] spatial_scale Spatial scale to be applied to the ROI coordinates and dimensions.
1317  * @param[in] sampling_ratio Number of samples to include in each pooling region (if set to zero, a ceil(roi_dims/pooling_dims))
1318  */
1319  ROIPoolingLayerInfo(unsigned int pooled_width, unsigned int pooled_height, float spatial_scale, unsigned int sampling_ratio = 0)
1320  : _pooled_width(pooled_width), _pooled_height(pooled_height), _spatial_scale(spatial_scale), _sampling_ratio(sampling_ratio)
1321  {
1322  }
1323  /** Get the pooled width of the layer */
1324  unsigned int pooled_width() const
1325  {
1326  return _pooled_width;
1327  }
1328  /** Get the pooled height of the layer */
1329  unsigned int pooled_height() const
1330  {
1331  return _pooled_height;
1332  }
1333  /** Get the spatial scale */
1334  float spatial_scale() const
1335  {
1336  return _spatial_scale;
1337  }
1338  /** Get sampling ratio */
1339  unsigned int sampling_ratio() const
1340  {
1341  return _sampling_ratio;
1342  }
1343 
1344 private:
1345  unsigned int _pooled_width;
1346  unsigned int _pooled_height;
1347  float _spatial_scale;
1348  unsigned int _sampling_ratio;
1349 };
1350 
1351 /** Generate Proposals Information class */
1353 {
1354 public:
1355  /** Constructor
1356  *
1357  * @param[in] im_width Width of the original image
1358  * @param[in] im_height Height of the original image
1359  * @param[in] im_scale Scale applied to the original image
1360  * @param[in] spatial_scale (Optional)Scale applied to the feature map. Defaults to 1.0
1361  * @param[in] pre_nms_topN (Optional)Number of the best scores to be selected from the transformations. Defaults to 6000.
1362  * @param[in] post_nms_topN (Optional)Number of the best scores to be selected from the NMS operation. Defaults to 300.
1363  * @param[in] nms_thres (Optional)NMS overlap threshold. Defaults to 0.7.
1364  * @param[in] min_size (Optional)Size used to validate the anchors produced. Defaults to 16.
1365  * @param[in] values_per_roi (Optional)Values used to represent a ROI(Region of interest). Defaults to 4.
1366  */
1367  GenerateProposalsInfo(float im_width, float im_height, float im_scale, float spatial_scale = 1.0, int pre_nms_topN = 6000, int post_nms_topN = 300, float nms_thres = 0.7, float min_size = 16.0,
1368  size_t values_per_roi = 4)
1369  : _im_height(im_height), _im_width(im_width), _im_scale(im_scale), _spatial_scale(spatial_scale), _pre_nms_topN(pre_nms_topN), _post_nms_topN(post_nms_topN), _nms_thres(nms_thres),
1370  _min_size(min_size), _values_per_roi(values_per_roi)
1371  {
1372  }
1373 
1374  /* Get the original height */
1375  float im_height() const
1376  {
1377  return _im_height;
1378  }
1379  /* Get the original width */
1380  float im_width() const
1381  {
1382  return _im_width;
1383  }
1384  /* Get the image scale */
1385  float im_scale() const
1386  {
1387  return _im_scale;
1388  }
1389  /* Get the value of how many best scores to select (before NMS) */
1390  int pre_nms_topN() const
1391  {
1392  return _pre_nms_topN;
1393  }
1394  /* Get the value of how many best scores to select (after NMS) */
1395  int post_nms_topN() const
1396  {
1397  return _post_nms_topN;
1398  }
1399  /* Get the NMS overlap threshold */
1400  float nms_thres() const
1401  {
1402  return _nms_thres;
1403  }
1404  /* Get the minimal size */
1405  float min_size() const
1406  {
1407  return _min_size;
1408  }
1409  /* Get the spatial scale to be applied to the feature maps */
1410  float spatial_scale() const
1411  {
1412  return _spatial_scale;
1413  }
1414  /* Get the values used to represent a ROI(Region of interest)*/
1415  size_t values_per_roi() const
1416  {
1417  return _values_per_roi;
1418  }
1419 
1420 private:
1421  float _im_height;
1422  float _im_width;
1423  float _im_scale;
1424  float _spatial_scale;
1425  int _pre_nms_topN;
1426  int _post_nms_topN;
1427  float _nms_thres;
1428  float _min_size;
1429  size_t _values_per_roi;
1430 };
1431 
1432 /** ComputeAnchors information class */
1434 {
1435 public:
1436  /** Constructor
1437  *
1438  * @param[in] feat_width Feature map width
1439  * @param[in] feat_height Feature map height
1440  * @param[in] spatial_scale Feature map scale
1441  * @param[in] values_per_roi (Optional)Values used to represent a ROI(Region Of Interest). Defaults to 4
1442  */
1443  ComputeAnchorsInfo(float feat_width, float feat_height, float spatial_scale, size_t values_per_roi = 4)
1444  : _feat_height(feat_height),
1445  _feat_width(feat_width),
1446  _spatial_scale(spatial_scale),
1447  _values_per_roi(values_per_roi)
1448  {
1449  }
1450 
1451  /* Get the height of the feature map */
1452  float feat_height() const
1453  {
1454  return _feat_height;
1455  }
1456 
1457  /* Get the width of the feature map */
1458  float feat_width() const
1459  {
1460  return _feat_width;
1461  }
1462 
1463  /* Get the scale of the feature map */
1464  float spatial_scale() const
1465  {
1466  return _spatial_scale;
1467  }
1468 
1469  /* Get the values used to represent a ROI(Region Of Interest)*/
1470  size_t values_per_roi() const
1471  {
1472  return _values_per_roi;
1473  }
1474 
1475 private:
1476  float _feat_height;
1477  float _feat_width;
1478  float _spatial_scale;
1479  size_t _values_per_roi;
1480 };
1481 
1482 /** Bounding Box Transform information class */
1484 {
1485 public:
1486  /** Constructor
1487  *
1488  * @param[in] img_width Width of the original image
1489  * @param[in] img_height Height, of the original image
1490  * @param[in] scale Scale of the original image
1491  * @param[in] apply_scale (Optional)Re-apply scaling after transforming the boxes. Defaults to false
1492  * @param[in] weights (Optional)Weights [wx, wy, ww, wh] for the deltas. Defaults to all ones
1493  * @param[in] correct_transform_coords (Optional)Correct bounding box transform coordinates. Defaults to false
1494  * @param[in] bbox_xform_clip (Optional)Minimum bounding box width and height after bounding box transformation in log-space. Defaults to log(1000/16)
1495  */
1496  BoundingBoxTransformInfo(float img_width, float img_height, float scale, bool apply_scale = false, const std::array<float, 4> weights = { { 1.f, 1.f, 1.f, 1.f } }, bool correct_transform_coords =
1497  false,
1498  float bbox_xform_clip =
1499  4.135166556742356f)
1500  : _img_width(img_width), _img_height(img_height), _scale(scale), _apply_scale(apply_scale), _correct_transform_coords(correct_transform_coords), _weights(weights), _bbox_xform_clip(bbox_xform_clip)
1501  {
1502  }
1503 
1504  std::array<float, 4> weights() const
1505  {
1506  return _weights;
1507  }
1508 
1509  float bbox_xform_clip() const
1510  {
1511  return _bbox_xform_clip;
1512  }
1513 
1514  float img_height() const
1515  {
1516  return _img_height;
1517  }
1518 
1519  float img_width() const
1520  {
1521  return _img_width;
1522  }
1523 
1524  float scale() const
1525  {
1526  return _scale;
1527  }
1528 
1529  bool apply_scale() const
1530  {
1531  return _apply_scale;
1532  }
1533 
1535  {
1536  return _correct_transform_coords;
1537  }
1538 
1539 private:
1540  float _img_width;
1541  float _img_height;
1542  float _scale;
1543  bool _apply_scale;
1544  bool _correct_transform_coords;
1545  std::array<float, 4> _weights;
1546  float _bbox_xform_clip;
1547 };
1548 
1549 /** Activation Layer Information class */
1551 {
1552 public:
1553  /** Available activation functions */
1555  {
1556  LOGISTIC, /**< Logistic ( \f$ f(x) = \frac{1}{1 + e^{-x}} \f$ ) */
1557  TANH, /**< Hyperbolic tangent ( \f$ f(x) = a \cdot tanh(b \cdot x) \f$ ) */
1558  RELU, /**< Rectifier ( \f$ f(x) = max(0,x) \f$ ) */
1559  BOUNDED_RELU, /**< Upper Bounded Rectifier ( \f$ f(x) = min(a, max(0,x)) \f$ ) */
1560  LU_BOUNDED_RELU, /**< Lower and Upper Bounded Rectifier ( \f$ f(x) = min(a, max(b,x)) \f$ ) */
1561  LEAKY_RELU, /**< Leaky Rectifier ( \f$ f(x) = \begin{cases} \alpha x & \quad \text{if } x \text{ < 0}\\ x & \quad \text{if } x \geq \text{ 0 } \end{cases} \f$ ) */
1562  SOFT_RELU, /**< Soft Rectifier ( \f$ f(x)= log(1+e^x) \f$ ) */
1563  ELU, /**< Exponential Linear Unit ( \f$ f(x) = \begin{cases} \alpha (exp(x) - 1) & \quad \text{if } x \text{ < 0}\\ x & \quad \text{if } x \geq \text{ 0 } \end{cases} \f$ ) */
1564  ABS, /**< Absolute ( \f$ f(x)= |x| \f$ ) */
1565  SQUARE, /**< Square ( \f$ f(x)= x^2 \f$ )*/
1566  SQRT, /**< Square root ( \f$ f(x) = \sqrt{x} \f$ )*/
1567  LINEAR, /**< Linear ( \f$ f(x)= ax + b \f$ ) */
1568  IDENTITY, /**< Identity ( \f$ f(x)= x \f$ ) */
1569  HARD_SWISH /**< Hard-swish ( \f$ f(x) = (x * relu6(x+3))/6 \f$ ) */
1570  };
1571 
1572  ActivationLayerInfo() = default;
1573  /** Default Constructor
1574  *
1575  * @param[in] f The activation function to use.
1576  * @param[in] a (Optional) The alpha parameter used by some activation functions
1577  * (@ref ActivationFunction::BOUNDED_RELU, @ref ActivationFunction::LU_BOUNDED_RELU, @ref ActivationFunction::LINEAR, @ref ActivationFunction::TANH).
1578  * @param[in] b (Optional) The beta parameter used by some activation functions (@ref ActivationFunction::LINEAR, @ref ActivationFunction::LU_BOUNDED_RELU, @ref ActivationFunction::TANH).
1579  */
1580  ActivationLayerInfo(ActivationFunction f, float a = 0.0f, float b = 0.0f)
1581  : _act(f), _a(a), _b(b), _enabled(true)
1582  {
1583  }
1584  /** Get the type of activation function */
1586  {
1587  return _act;
1588  }
1589  /** Get the alpha value */
1590  float a() const
1591  {
1592  return _a;
1593  }
1594  /** Get the beta value */
1595  float b() const
1596  {
1597  return _b;
1598  }
1599  /** Check if initialised */
1600  bool enabled() const
1601  {
1602  return _enabled;
1603  }
1604 
1605 private:
1607  float _a = {};
1608  float _b = {};
1609  bool _enabled = { false };
1610 };
1611 
1612 /** Fully connected layer info */
1614 {
1615  DataLayout weights_trained_layout{ DataLayout::NCHW }; /**< Layout that the weights have been trained with. */
1616  bool transpose_weights{ true }; /**< Transpose weights if true. */
1617  bool are_weights_reshaped{ false }; /**< Reshape the weights tensor if false. */
1618  bool retain_internal_weights{ false }; /**< Retain internal reshaped weights. */
1619  bool fp_mixed_precision{ false }; /**< Use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy. */
1620  ActivationLayerInfo activation_info{}; /**< Fused activation to apply after the matrix multiplication. */
1621 
1622  /** Sets the weights trained data layout
1623  *
1624  * @param[in] layout Data layout that the weights were trained with
1625  *
1626  * @return Updated object
1627  */
1629  {
1630  weights_trained_layout = layout;
1631  return *this;
1632  }
1633  /** Sets the transpose weights flag
1634  *
1635  * @param[in] should_transpose_weights Boolean flag indicating if weights should be transposed
1636  *
1637  * @return Updated object
1638  */
1639  FullyConnectedLayerInfo &set_transpose_weights(bool should_transpose_weights)
1640  {
1641  transpose_weights = should_transpose_weights;
1642  return *this;
1643  }
1644 };
1645 
1646 /** Normalization Layer Information class */
1648 {
1649 public:
1650  /** Default Constructor
1651  *
1652  * @param[in] type The normalization type. Can be @ref NormType::IN_MAP_1D, @ref NormType::IN_MAP_2D or @ref NormType::CROSS_MAP
1653  * @param[in] norm_size The normalization size is the number of elements to normalize across. Defaults to 5.
1654  * @param[in] alpha (Optional) Alpha parameter used by normalization equation. Defaults to 0.0001.
1655  * @param[in] beta (Optional) Beta parameter used by normalization equation. Defaults to 0.5.
1656  * @param[in] kappa (Optional) Kappa parameter used by [Krichevksy 2012] Across Channel Local Brightness Normalization equation.
1657  * @param[in] is_scaled (Optional) Boolean that specifies if alpha will be scaled by the normalization size or not.
1658  * Should be false to follow [Krichevksy 2012].
1659  */
1660  NormalizationLayerInfo(NormType type, uint32_t norm_size = 5, float alpha = 0.0001f, float beta = 0.5f, float kappa = 1.f, bool is_scaled = true)
1661  : _type(type), _norm_size(norm_size), _alpha(alpha), _beta(beta), _kappa(kappa), _is_scaled(is_scaled)
1662  {
1663  }
1664  /** Get the normalization type */
1665  NormType type() const
1666  {
1667  return _type;
1668  }
1669  /** Get the normalization size */
1670  uint32_t norm_size() const
1671  {
1672  return _norm_size;
1673  }
1674  /** Get the alpha value */
1675  float alpha() const
1676  {
1677  return _alpha;
1678  }
1679  /** Get the beta value */
1680  float beta() const
1681  {
1682  return _beta;
1683  }
1684  /** Get the kappa value */
1685  float kappa() const
1686  {
1687  return _kappa;
1688  }
1689  /** Get the is_scaled value */
1690  bool is_scaled() const
1691  {
1692  return _is_scaled;
1693  }
1694  /** Check if normalization is cross map */
1695  bool is_cross_map() const
1696  {
1697  return _type == NormType::CROSS_MAP;
1698  }
1699  /** Check if normalization is not cross map */
1700  bool is_in_map() const
1701  {
1702  return !is_cross_map();
1703  }
1704  /** Return the scaling factor of the normalization function.
1705  *
1706  * If is_scaled is set to false then [Krichevksy 2012] normalization scaling is performed,
1707  * where alpha is returned plainly, else alpha is scaled by the total number of elements used for the normalization.
1708  *
1709  * @return The normalization scaling factor.
1710  */
1711  float scale_coeff() const
1712  {
1713  const uint32_t size = (_type == NormType::IN_MAP_2D) ? _norm_size * _norm_size : _norm_size;
1714  return (_is_scaled) ? (_alpha / size) : _alpha;
1715  }
1716 
1717 private:
1718  NormType _type;
1719  uint32_t _norm_size;
1720  float _alpha;
1721  float _beta;
1722  float _kappa;
1723  bool _is_scaled;
1724 };
1725 
1727 {
1728 public:
1729  /** Default Constructor
1730  *
1731  * @param[in] begin_mask (Optional) If the ith bit of begin_mask is set, starts[i] is ignored and the fullest possible range in that dimension is used instead.
1732  * @param[in] end_mask (Optional) If the ith bit of end_mask is set, ends[i] is ignored and the fullest possible range in that dimension is used instead.
1733  * @param[in] shrink_axis_mask (Optional) If the ith bit of shrink_axis_mask is set, it implies that the ith specification shrinks the dimensionality by 1.
1734  */
1735  StridedSliceLayerInfo(int32_t begin_mask = 0, int32_t end_mask = 0, int32_t shrink_axis_mask = 0)
1736  : _begin_mask(begin_mask), _end_mask(end_mask), _shrink_axis_mask(shrink_axis_mask)
1737  {
1738  }
1739 
1740  /* Get the begin mask value */
1741  int32_t begin_mask() const
1742  {
1743  return _begin_mask;
1744  }
1745 
1746  /* Get the end mask value */
1747  int32_t end_mask() const
1748  {
1749  return _end_mask;
1750  }
1751 
1752  /* Get the shrink axis mask value */
1753  int32_t shrink_axis_mask() const
1754  {
1755  return _shrink_axis_mask;
1756  }
1757 
1758 private:
1759  int32_t _begin_mask;
1760  int32_t _end_mask;
1761  int32_t _shrink_axis_mask;
1762 };
1763 
1764 /** Convolution Layer Weights Information class. This class stores the necessary information to compute convolution layer when the weights are already reshaped */
1766 {
1767 public:
1768  /** Default constructor */
1770  : _are_reshaped(false), _kernel_width(0), _kernel_height(0), _num_kernels(0), _retain_internal_weights(false)
1771  {
1772  }
1773  /** Constructor
1774  *
1775  * @param[in] are_reshaped True if the weights have been reshaped
1776  * @param[in] kernel_width Kernel width.
1777  * @param[in] kernel_height Kernel height.
1778  * @param[in] num_kernels Number of convolution kernels.
1779  * @param[in] retain_internal_weights (Optional) True if internal reshaped weights must be retained. Used for reconfiguration purposes. Default is false.
1780  */
1781  WeightsInfo(bool are_reshaped, unsigned int kernel_width, unsigned int kernel_height, unsigned int num_kernels, bool retain_internal_weights = false)
1782  : _are_reshaped(are_reshaped), _kernel_width(kernel_width), _kernel_height(kernel_height), _num_kernels(num_kernels), _retain_internal_weights(retain_internal_weights)
1783  {
1784  }
1785  /** Flag which specifies if the weights tensor has been reshaped.
1786  *
1787  * @return True if the weights tensors has been reshaped
1788  */
1789  bool are_reshaped() const
1790  {
1791  return _are_reshaped;
1792  };
1793  /** Return the number of convolution kernels
1794  *
1795  * @return The number of convolution kernels
1796  */
1797  unsigned int num_kernels() const
1798  {
1799  return _num_kernels;
1800  };
1801  /** Return the width and height of the kernel
1802  *
1803  * @return The width and height of the kernel
1804  */
1805  std::pair<unsigned int, unsigned int> kernel_size() const
1806  {
1807  return std::make_pair(_kernel_width, _kernel_height);
1808  }
1810  {
1811  return _retain_internal_weights;
1812  }
1813 
1814 private:
1815  bool _are_reshaped;
1816  unsigned int _kernel_width;
1817  unsigned int _kernel_height;
1818  unsigned int _num_kernels;
1819  bool _retain_internal_weights;
1820 };
1821 
1822 /** GEMM reshape information class. This class stores the necessary information about matrix A and matrix B reshape.
1823  *
1824  * The matrix A can only be reshaped through @ref CLGEMMReshapeLHSMatrixKernel or @ref NEGEMMInterleave4x4Kernel or @ref GCGEMMInterleave4x4Kernel
1825  * Note: Optionally just for @ref CLGEMMReshapeLHSMatrixKernel is it possible to set mult_interleave4x4_height, the multiplication factor for the height of the 4x4 interleaved block
1826  *
1827  * The matrix B can only be reshaped through @ref CLGEMMReshapeRHSMatrixKernel or @ref NEGEMMTranspose1xWKernel or @ref GCGEMMTranspose1xWKernel
1828  * Note: Optionally just for @ref CLGEMMReshapeRHSMatrixKernel is it possible to set mult_transpose1xW_width, the multiplication factor for the width of the 1xW transposed block
1829  *
1830  */
1831 class GEMMReshapeInfo final
1832 {
1833 public:
1834  /** Default constructor */
1836  : _m(1), _n(1), _k(1), _mult_transpose1xW_width(1), _mult_interleave4x4_height(1), _depth_output_gemm3d(0), _reinterpret_input_as_3d(false), _broadcast_bias(false)
1837  {
1838  }
1839  /** Constructor
1840  *
1841  * @param[in] m Number of matrix A rows
1842  * @param[in] n Number of matrix B columns
1843  * @param[in] k Number of matrix A columns or matrix B rows
1844  * @param[in] mult_transpose1xW_width (Optional) Multiplication factor for the width of the 1xW transposed block
1845  * @param[in] mult_interleave4x4_height (Optional) Multiplication factor for the height of the 4x4 interleaved block
1846  * @param[in] depth_output_gemm3d (Optional) Depth (third dimension) of the output tensor to be used with the GEMM3D kernel.
1847  * If 0 the output will not be reinterpreted as 3D. Default 0
1848  * @param[in] reinterpret_input_as_3d (Optional) Reinterpret the input as 3D tensor. (i.e. this flag should be set to true when GEMM is used
1849  * to perform 1x1 convolutions with the NHWC data layout)
1850  * @param[in] broadcast_bias (Optional) Broadcast the shape of the bias tensor from a vector to a matrix.
1851  */
1852  GEMMReshapeInfo(int m, int n, int k, int mult_transpose1xW_width = 1, int mult_interleave4x4_height = 1, int depth_output_gemm3d = 0, bool reinterpret_input_as_3d = false, bool broadcast_bias = false)
1853  : _m(m), _n(n), _k(k), _mult_transpose1xW_width(mult_transpose1xW_width), _mult_interleave4x4_height(mult_interleave4x4_height), _depth_output_gemm3d(depth_output_gemm3d),
1854  _reinterpret_input_as_3d(reinterpret_input_as_3d), _broadcast_bias(broadcast_bias)
1855  {
1856  }
1857  /** Number of matrix A rows
1858  *
1859  * @return the number of matrix A rows
1860  */
1861  int m() const
1862  {
1863  return _m;
1864  }
1865  /** Number of matrix B columns
1866  *
1867  * @return the number of matrix B columns
1868  */
1869  int n() const
1870  {
1871  return _n;
1872  }
1873  /** Number of matrix A columns or matrix B rows
1874  *
1875  * @return the number of matrix A columns or matrix B rows
1876  */
1877  int k() const
1878  {
1879  return _k;
1880  }
1881  /** Multiplication factor for the width of the 1xW transposed block
1882  *
1883  * @return the multiplication factor for the width of the 1xW transposed block
1884  */
1886  {
1887  return _mult_transpose1xW_width;
1888  }
1889  /** Multiplication factor for the height of the 4x4 interleaved block
1890  *
1891  * @return the multiplication factor for the height of the 4x4 interleaved block
1892  */
1894  {
1895  return _mult_interleave4x4_height;
1896  }
1897  /** Depth (third dimension) of the output tensor to be used with the GEMM3D kernel
1898  *
1899  * @note GEMM3D kernel is used when the output has to be reinterpret as 3D tensor. In that case:
1900  * m = depth_output_gemm3d * output_height
1901  *
1902  * @return the depth of the output tensor to be used with the GEMM3D kernel
1903  */
1905  {
1906  return _depth_output_gemm3d;
1907  }
1908  /** Flag which specifies if the input tensor has to be reinterpreted as 3D
1909  *
1910  * @return True if the input tensor has to be reinterpreted as 3D tensor
1911  */
1913  {
1914  return _reinterpret_input_as_3d;
1915  };
1916  /** Flag which specifies whether to broadcast the shape of the bias tensor.
1917  *
1918  * @return True if the shape of the bias tensor is to be broadcasted.
1919  */
1920  bool broadcast_bias() const
1921  {
1922  return _broadcast_bias;
1923  };
1924 
1925 private:
1926  int _m;
1927  int _n;
1928  int _k;
1929  int _mult_transpose1xW_width;
1930  int _mult_interleave4x4_height;
1931  int _depth_output_gemm3d;
1932  bool _reinterpret_input_as_3d;
1933  bool _broadcast_bias;
1934 };
1935 
1937 {
1938  unsigned int c0{ 1 }; /**< Number of channels processed by the depth-wise convolution */
1939  bool transpose{ false }; /**< True if the block MxC0 (where M is the area of the filter i.e. KwxKh) has to be transposed */
1940 };
1941 
1942 /** GEMMLowp output stage type */
1944 {
1945  NONE, /**< No quantization */
1946  QUANTIZE_DOWN, /**< Quantize using an integer multiplication */
1947  QUANTIZE_DOWN_FIXEDPOINT, /**< Quantize using a fixed point multiplication */
1948  QUANTIZE_DOWN_FLOAT /**< Quantize using a floating point multiplication */
1949 };
1950 
1951 /** GEMMLowp output stage info */
1953 {
1954  GEMMLowpOutputStageType type{ GEMMLowpOutputStageType::NONE }; /**< GEMMLowp output stage type */
1955  int32_t gemmlowp_offset{ 0 }; /**< GEMMLowp output stage offset used for quantizing to QASYMM8 */
1956  int32_t gemmlowp_multiplier{ 0 }; /**< GEMMLowp output stage multiplier used for quantizing to QASYMM8 */
1957  int32_t gemmlowp_shift{ 0 }; /**< GEMMLowp output stage shift used for quantizing to uint8 */
1958  int32_t gemmlowp_min_bound{ std::numeric_limits<int32_t>::lowest() }; /**< GEMMLowp min value used to saturate down the output result before converting back to QASYMM8 */
1959  int32_t gemmlowp_max_bound{ std::numeric_limits<int32_t>::max() }; /**< GEMMLowp max value used to saturate down the output result before converting back to QASYMM8 */
1960  std::vector<int32_t> gemmlowp_multipliers{}; /**< GEMMLowp output stage multiplier used for quantizing to QASYMM8 */
1961  std::vector<int32_t> gemmlowp_shifts{}; /**< GEMMLowp output stage multiplier used for quantizing to QASYMM8 */
1962  float gemmlowp_real_multiplier{ 0 }; /**< GEMMLowp output stage real multiplier used for quantizing to QASYMM8 */
1963  bool is_quantized_per_channel{ false }; /**< GEMMLowp quantized per-channel flag */
1964  DataType output_data_type{ DataType::UNKNOWN }; /**< Output tensor data type to use if the output is not initialized */
1965 };
1966 
1967 /** GEMM LHS (Left Hand Side) matrix information */
1969 {
1970  GEMMLHSMatrixInfo() = default;
1971  GEMMLHSMatrixInfo(unsigned int m, unsigned int k, unsigned int v, bool trans, bool inter)
1972  : m0(m), k0(k), v0(v), transpose(trans), interleave(inter)
1973  {
1974  }
1975  unsigned int m0{ 1 }; /**< Number of rows processed by the matrix multiplication */
1976  unsigned int k0{ 1 }; /**< Number of partial accumulations performed by the matrix multiplication */
1977  unsigned int v0{ 1 }; /**< Number of vertical blocks of size (m0xk0) stored on the same output row */
1978  bool transpose{ true }; /**< True if the (m0xk0) block has to be transposed before been stored */
1979  bool interleave{ true }; /**< True if the v0 (m0xk0) blocks have to be interleaved in the output row */
1980 };
1981 
1982 /** GEMM RHS (Right Hand Side) matrix information */
1984 {
1985  GEMMRHSMatrixInfo() = default;
1986  GEMMRHSMatrixInfo(unsigned int n, unsigned int k, unsigned int h, bool trans, bool inter, bool export_to_cl_img)
1987  : n0(n), k0(k), h0(h), transpose(trans), interleave(inter), export_to_cl_image(export_to_cl_img)
1988  {
1989  }
1990  unsigned int n0{ 1 }; /**< Number of columns processed by the matrix multiplication */
1991  unsigned int k0{ 1 }; /**< Number of partial accumulations performed by the matrix multiplication */
1992  unsigned int h0{ 1 }; /**< Number of horizontal blocks of size (k0xn0) stored on the same output row */
1993  bool transpose{ true }; /**< True if the (k0xn0) block has to be transposed before been stored */
1994  bool interleave{ true }; /**< True if the h0 (k0xn0) blocks have to be interleaved in the output row */
1995  bool export_to_cl_image{ false }; /**< True if the reshaped rhs has to be exported to cl_image. n0 must be equal to 4 */
1996 };
1997 
1998 /** GEMM information class. This class stores the necessary information to compute GEMM functions
1999  *
2000  * This object also contains the information about how matrix A and matrix B have been reshaped
2001  *
2002  */
2004 {
2005 public:
2006  /** Default constructor */
2007  GEMMInfo() noexcept
2008  : _is_a_reshaped(false),
2009  _is_b_reshaped(false),
2010  _reshape_b_only_on_first_run(true),
2011  _depth_output_gemm3d(0),
2012  _reinterpret_input_as_3d(false),
2013  _retain_internal_weights(false),
2014  _gemmlowp_output_stage(),
2015  _fp_mixed_precision(false),
2016  _broadcast_bias(false),
2017  _pretranpose_B(true),
2018  _activation_info()
2019  {
2020  }
2021  /** Constructor
2022  *
2023  * @param[in] is_a_reshaped True if the matrix A has been reshaped
2024  * @param[in] is_b_reshaped True if the matrix B has been reshaped
2025  * @param[in] reshape_b_only_on_first_run Reshape matrix B only for the first run
2026  * @param[in] depth_output_gemm3d (Optional) Depth (third dimension) of the output tensor to be used with the GEMM3D kernel
2027  * If 0 the output will not be reinterpreted as 3D. Default 0
2028  * @param[in] reinterpret_input_as_3d (Optional) Reinterpret the input as 3D tensor. (i.e. this flag should be set to true when GEMM is used
2029  * to perform 1x1 convolutions with the NHWC data layout)
2030  * @param[in] retain_internal_weights (Optional) Retain the weights tensor from previous run
2031  * @param[in] gemmlowp_output_stage (Optional) GEMMLowp Output stage info
2032  * @param[in] fp_mixed_precision (Optional) Use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy.
2033  * @param[in] broadcast_bias (Optional) Broadcast the shape of the bias tensor from a vector to a matrix.
2034  * @param[in] activation_info (Optional) Activation to apply after the matrix multiplication
2035  */
2036  GEMMInfo(bool is_a_reshaped, bool is_b_reshaped, bool reshape_b_only_on_first_run, int depth_output_gemm3d = 0, bool reinterpret_input_as_3d = false, bool retain_internal_weights = false,
2037  GEMMLowpOutputStageInfo gemmlowp_output_stage = GEMMLowpOutputStageInfo(), bool fp_mixed_precision = false, bool broadcast_bias = false,
2038  const ActivationLayerInfo &activation_info = ActivationLayerInfo()) noexcept
2039  : _is_a_reshaped(is_a_reshaped),
2040  _is_b_reshaped(is_b_reshaped),
2041  _reshape_b_only_on_first_run(reshape_b_only_on_first_run),
2042  _depth_output_gemm3d(depth_output_gemm3d),
2043  _reinterpret_input_as_3d(reinterpret_input_as_3d),
2044  _retain_internal_weights(retain_internal_weights),
2045  _gemmlowp_output_stage(gemmlowp_output_stage),
2046  _fp_mixed_precision(fp_mixed_precision),
2047  _broadcast_bias(broadcast_bias),
2048  _pretranpose_B(reshape_b_only_on_first_run),
2049  _activation_info(activation_info)
2050  {
2051  }
2052  /** Flag which specifies if the matrix A has been reshaped
2053  *
2054  * @return True if the matrix A has been reshaped
2055  */
2056  bool is_a_reshaped() const
2057  {
2058  return _is_a_reshaped;
2059  };
2060  /** Flag which specifies if the matrix B has been reshaped
2061  *
2062  * @return True if the matrix B has been reshaped
2063  */
2064  bool is_b_reshaped() const
2065  {
2066  return _is_b_reshaped;
2067  };
2068  /** Flag which specifies if the reshape of matrix B should executed only for the first
2069  *
2070  * @note This flag could be set to TRUE when GEMM is used to accelerate convolution layer
2071  *
2072  * @return True if the reshaped of matrix B happens only for the first run
2073  */
2075  {
2076  return _reshape_b_only_on_first_run;
2077  };
2078  /** Depth of the output when GEMM output is reinterpreted as 3D tensor
2079  *
2080  * @return the depth of the output tensor
2081  */
2083  {
2084  return _depth_output_gemm3d;
2085  };
2086  /** Flag which specifies if the input tensor has to be reinterpreted as 3D
2087  *
2088  * @return True if the input tensor has to be reinterpreted as 3D tensor
2089  */
2091  {
2092  return _reinterpret_input_as_3d;
2093  };
2094  /** Flag which specifies if the weights tensor has to be retained from previous run
2095  *
2096  * @return True if the weights tensor has to be retained
2097  */
2099  {
2100  return _retain_internal_weights;
2101  };
2102  /** GEMMLowp output stage
2103  *
2104  * @return the GEMMLowp output stage info
2105  */
2107  {
2108  return _gemmlowp_output_stage;
2109  };
2110  /** Sets GEMMLowp output stage
2111  *
2112  * @param[in] output_stage Output stage to set
2113  */
2115  {
2116  _gemmlowp_output_stage = output_stage;
2117  };
2118  /** Flag which specifies if a wider accumulator should be used.
2119  *
2120  * @return True if a wider accumulator has to be used
2121  */
2122  bool fp_mixed_precision() const
2123  {
2124  return _fp_mixed_precision;
2125  };
2126  /** Flag which specifies whether to broadcast the shape of the bias tensor.
2127  *
2128  * @return True if the shape of the bias tensor is to be broadcasted.
2129  */
2130  bool broadcast_bias() const
2131  {
2132  return _broadcast_bias;
2133  };
2134  /** Flag which specifies whether b should be pre-transposed if supported.
2135  *
2136  * @return True if b should be pre-transposed else false.
2137  */
2138  bool pretranpose_B() const
2139  {
2140  return _pretranpose_B;
2141  };
2142  /** Set pre-transpose b flag
2143  *
2144  * @param[in] flag Flag to set
2145  */
2146  void set_pretranpose_B(bool flag)
2147  {
2148  _pretranpose_B = flag;
2149  }
2150  /** Activation layer to apply after the matrix multiplication
2151  *
2152  * @return ActivationLayerInfo object
2153  */
2155  {
2156  return _activation_info;
2157  }
2158  /** Set activation layer info
2159  *
2160  * @param[in] activation_info ActivationLayerInfo object to set
2161  */
2162  void set_activation_info(const ActivationLayerInfo &activation_info)
2163  {
2164  _activation_info = activation_info;
2165  }
2166 
2167 private:
2168  bool _is_a_reshaped;
2169  bool _is_b_reshaped;
2170  bool _reshape_b_only_on_first_run;
2171  int _depth_output_gemm3d;
2172  bool _reinterpret_input_as_3d;
2173  bool _retain_internal_weights;
2174  GEMMLowpOutputStageInfo _gemmlowp_output_stage;
2175  bool _fp_mixed_precision;
2176  bool _broadcast_bias;
2177  bool _pretranpose_B;
2178  ActivationLayerInfo _activation_info;
2179 };
2180 
2181 /** Winograd information */
2183 {
2184  /** Default constructor
2185  *
2186  * @param[in] output_tile_sz Width and height of the output tile
2187  * @param[in] kernel_sz Width and height of the kernel
2188  * @param[in] input_dims Width and height of the input tensor before the convolution is applied
2189  * @param[in] conv_info Convolution info (Pads, strides)
2190  * @param[in] data_layout Data layout to use for the output tensor once the convolution has been applied
2191  */
2192  WinogradInfo(Size2D output_tile_sz, Size2D kernel_sz, Size2D input_dims, PadStrideInfo conv_info, DataLayout data_layout)
2193  : output_tile_size(output_tile_sz), kernel_size(kernel_sz), input_dimensions(input_dims), convolution_info(conv_info), output_data_layout(data_layout)
2194  {
2195  }
2196 
2197  Size2D output_tile_size{}; /**< Width and height of the output tile */
2198  Size2D kernel_size{}; /**< Width and height of the kernel*/
2199  Size2D input_dimensions{}; /**< Width and height of the input tensor before the convolution is applied */
2200  PadStrideInfo convolution_info{}; /**< Convolution info (Pads, strides,...) */
2201  DataLayout output_data_layout{ DataLayout::NCHW }; /**< Data layout to use for the output tensor once the convolution has been applied (NCHW or NHWC) */
2202 };
2203 
2204 /** IO formatting information class*/
2206 {
2207  /** Precision type used when printing floating point numbers */
2208  enum class PrecisionType
2209  {
2210  Default, /**< Default precision to the one that the current stream has */
2211  Custom, /**< Custom precision specified by the user using the precision parameter */
2212  Full /**< The maximum precision of the floating point representation */
2213  };
2214 
2215  /** Specifies the area to be printed, used by Tensor objects */
2216  enum class PrintRegion
2217  {
2218  ValidRegion, /**< Prints the valid region of the Tensor object */
2219  NoPadding, /**< Prints the Tensor object without the padding */
2220  Full /**< Print the tensor object including padding */
2221  };
2222 
2223  /** Construct a set of IO formatting information.
2224  *
2225  * @param[in] print_region Area to be printed. Used by Tensor objects. Default: ValidRegion.
2226  * @param[in] precision_type Precision type for floating point numbers. Default: stream default.
2227  * @param[in] precision Precision value for float point numbers. Default: 10.
2228  * @param[in] align_columns Whether to align columns when printed. Default: true.
2229  * @param[in] element_delim Delimeter between elements. Default: " ".
2230  * @param[in] row_delim Delimenter between rows. Default: "\n".
2231  */
2232  IOFormatInfo(PrintRegion print_region = PrintRegion::ValidRegion,
2233  PrecisionType precision_type = PrecisionType::Default,
2234  unsigned int precision = 10,
2235  bool align_columns = true,
2236  std::string element_delim = " ",
2237  std::string row_delim = "\n")
2238  : print_region(print_region),
2239  precision_type(precision_type),
2240  precision(precision),
2241  element_delim(element_delim),
2242  row_delim(row_delim),
2243  align_columns(align_columns)
2244  {
2245  }
2246 
2247  /** Area to be printed by Tensor objects */
2249  /** Floating point precision type */
2251  /** Floating point precision */
2252  unsigned int precision;
2253  /** Element delimeter */
2254  std::string element_delim;
2255  /** Row delimeter */
2256  std::string row_delim;
2257  /** Align columns */
2259 };
2260 
2261 /** Internal keypoint class for Lucas-Kanade Optical Flow */
2263 {
2264  float x{ 0.f }; /**< x coordinate of the keypoint */
2265  float y{ 0.f }; /**< y coordinate of the keypoint */
2266  bool tracking_status{ false }; /**< the tracking status of the keypoint */
2267 };
2268 
2269 } // namespace arm_compute
2270 #endif /* ARM_COMPUTE_TYPES_H */
float scale_coeff() const
Return the scaling factor of the normalization function.
Definition: Types.h:1711
BorderMode
Methods available to handle borders.
Definition: Types.h:265
ValidRegion(const Coordinates &an_anchor, const TensorShape &a_shape, size_t num_dimensions)
Constructor for a valid region with specified number of dimensions.
Definition: Types.h:226
Rectangle type.
Definition: Types.h:454
PrecisionType precision_type
Floating point precision type.
Definition: Types.h:2250
void set_pretranpose_B(bool flag)
Set pre-transpose b flag.
Definition: Types.h:2146
constexpr float SCALE_PYRAMID_ORB
Constant value used to indicate a ORB scaled pyramid.
Definition: Types.h:115
Coordinate type.
Definition: Types.h:470
Internal keypoint class for Lucas-Kanade Optical Flow.
Definition: Types.h:2262
DeconvolutionMethod
Available DeconvolutionMethod.
Definition: Types.h:155
__global uchar * offset(const Image *img, int x, int y)
Get the pointer position of a Image.
Definition: helpers.h:846
ValidRegion & set(size_t dimension, int start, size_t size)
Accessor to set the value of anchor and shape for one of the dimensions.
Definition: Types.h:253
GEMMLHSMatrixInfo(unsigned int m, unsigned int k, unsigned int v, bool trans, bool inter)
Definition: Types.h:1971
constexpr float SCALE_PYRAMID_HALF
Constant value used to indicate a half-scale pyramid.
Definition: Types.h:112
unsigned int top
top of the border
Definition: Types.h:375
L2-norm followed by clipping.
A single plane of 32-bit macro pixel of U0, Y0, V0, Y1 byte.
ArithmeticOperation
Available element-wise operations.
Definition: Types.h:534
InterpolationPolicy
Interpolation method.
Definition: Types.h:392
int num_classes() const
Get num classes.
Definition: Types.h:1025
int mult_interleave4x4_height() const
Multiplication factor for the height of the 4x4 interleaved block.
Definition: Types.h:1893
Generate Proposals Information class.
Definition: Types.h:1352
Second channel (used by formats with unknown channel types).
DepthwiseConvolutionFunction
Available DepthwiseConvolutionFunction.
Definition: Types.h:148
Shape of a tensor.
Definition: TensorShape.h:39
float kappa() const
Get the kappa value.
Definition: Types.h:1685
Quantize using a fixed point multiplication.
uint32_t x
X coordinates.
Definition: Types.h:472
bool share_location() const
Get share location.
Definition: Types.h:1030
float im_width() const
Get image width (NMS may suppress boxes whose center sits beyond the image width) ...
Definition: Types.h:697
FullyConnectedLayerInfo & set_weights_trained_layout(DataLayout layout)
Sets the weights trained data layout.
Definition: Types.h:1628
DetectionPostProcessLayerInfo(unsigned int max_detections, unsigned int max_classes_per_detection, float nms_score_threshold, float iou_threshold, unsigned int num_classes, std::array< float, 4 > scales_values, bool use_regular_nms=false, unsigned int detection_per_class=100, bool dequantize_scores=true)
Constructor.
Definition: Types.h:1123
float scale_value_x() const
Get x scale value.
Definition: Types.h:1178
float score_thresh() const
Get the score threshold.
Definition: Types.h:652
DimensionRoundingType round() const
Get the rounding type.
Definition: Types.h:817
quantized, symmetric fixed-point 16-bit number
void set_activation_info(const ActivationLayerInfo &activation_info)
Set activation layer info.
Definition: Types.h:2162
L1 normalization type.
ROIPoolingLayerInfo(unsigned int pooled_width, unsigned int pooled_height, float spatial_scale, unsigned int sampling_ratio=0)
Constructor.
Definition: Types.h:1319
TensorShape shape
Shape of the valid region.
Definition: Types.h:261
WinogradInfo(Size2D output_tile_sz, Size2D kernel_sz, Size2D input_dims, PadStrideInfo conv_info, DataLayout data_layout)
Default constructor.
Definition: Types.h:2192
Angle range: [0, 180].
bool is_in_map() const
Check if normalization is not cross map.
Definition: Types.h:1700
bool enabled() const
Check if initialised.
Definition: Types.h:1600
GEMMRHSMatrixInfo(unsigned int n, unsigned int k, unsigned int h, bool trans, bool inter, bool export_to_cl_img)
Definition: Types.h:1986
std::vector< PaddingInfo > PaddingList
List of padding information.
Definition: Types.h:481
ReductionOperation
Available reduction operations.
Definition: Types.h:521
SimpleTensor< float > b
Definition: DFT.cpp:157
Container for 2D border size.
Definition: Types.h:273
size_t values_per_roi() const
Definition: Types.h:1470
ActivationLayerInfo(ActivationFunction f, float a=0.0f, float b=0.0f)
Default Constructor.
Definition: Types.h:1580
Angle range: [0, 360].
std::map< int, std::vector< BBox > > LabelBBox
Definition: Types.h:964
PhaseType
Phase calculation type.
Definition: Types.h:432
unsigned int max_detections() const
Get max detections.
Definition: Types.h:1137
Cr/V/Value channel.
DataLayoutDimension
[DataLayout enum definition]
Definition: Types.h:129
BoxWithNonMaximaSuppressionLimit Information class.
Definition: Types.h:626
PoolingLayerInfo(PoolingType pool_type, DataLayout data_layout)
Constructor.
Definition: Types.h:1288
Winograd information.
Definition: Types.h:2182
uint32_t norm_size() const
Get the normalization size.
Definition: Types.h:1670
1 channel, 1 U8 per channel
NormType type() const
Get the normalization type.
Definition: Types.h:1665
int mult_transpose1xW_width() const
Multiplication factor for the width of the 1xW transposed block.
Definition: Types.h:1885
Terminate when within epsilon of a threshold.
float a() const
Get the alpha value.
Definition: Types.h:1590
GEMM reshape information class.
Definition: Types.h:1831
std::vector< float > aspect_ratios() const
Get aspect ratios.
Definition: Types.h:944
PriorBoxLayerInfo(const std::vector< float > &min_sizes, const std::vector< float > &variances, float offset, bool flip=true, bool clip=false, const std::vector< float > &max_sizes={}, const std::vector< float > &aspect_ratios={}, const Coordinates2D &img_size=Coordinates2D{ 0, 0 }, const std::array< float, 2 > &steps={ { 0.f, 0.f } })
Constructor.
Definition: Types.h:867
FullyConnectedLayerInfo & set_transpose_weights(bool should_transpose_weights)
Sets the transpose weights flag.
Definition: Types.h:1639
GEMMLowpOutputStageInfo gemmlowp_output_stage() const
GEMMLowp output stage.
Definition: Types.h:2106
bool are_reshaped() const
Flag which specifies if the weights tensor has been reshaped.
Definition: Types.h:1789
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:603
Normalization Layer Information class.
Definition: Types.h:1647
Unknown channel format.
Output values are defined by bilinear interpolation between the pixels.
unsigned int precision
Floating point precision.
Definition: Types.h:2252
bool is_cross_map() const
Check if normalization is cross map.
Definition: Types.h:1695
#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
Fully connected layer info.
Definition: Types.h:1613
bool fp_mixed_precision() const
Flag which specifies if a wider accumulator should be used.
Definition: Types.h:2122
BilinearInterpolation
Bilinear Interpolation method used by LKTracker.
Definition: Types.h:400
GEMM LHS (Left Hand Side) matrix information.
Definition: Types.h:1968
bool pretranpose_B() const
Flag which specifies whether b should be pre-transposed if supported.
Definition: Types.h:2138
A 2 plane YUV format of Luma (Y) and interleaved UV data at 4:2:0 sampling.
Terminate after a maximum number of iterations.
constexpr uint8_t CONSTANT_BORDER_VALUE
Constant value of the border pixels when using BorderMode::CONSTANT.
Definition: Types.h:109
PoolingLayerInfo()
Default Constructor.
Definition: Types.h:1217
GEMMReshapeInfo(int m, int n, int k, int mult_transpose1xW_width=1, int mult_interleave4x4_height=1, int depth_output_gemm3d=0, bool reinterpret_input_as_3d=false, bool broadcast_bias=false)
Constructor.
Definition: Types.h:1852
quantized, asymmetric fixed-point 16-bit number
ThresholdType
Threshold mode.
Definition: Types.h:407
1 channel, 1 U16 per channel
unsigned int bottom
bottom of the border
Definition: Types.h:377
float eta() const
Get eta.
Definition: Types.h:1055
int depth_output_gemm3d() const
Depth of the output when GEMM output is reinterpreted as 3D tensor.
Definition: Types.h:2082
PrintRegion print_region
Area to be printed by Tensor objects.
Definition: Types.h:2248
unsigned int pooled_width() const
Get the pooled width of the layer.
Definition: Types.h:1324
unsigned int pad_top() const
Get the top padding.
Definition: Types.h:806
Output values are defined to match the source pixel whose center is nearest to the sample position...
Bitwise NOT operation.
DetectionPostProcessLayerInfo()
Default Constructor.
Definition: Types.h:1099
bool retain_internal_weights() const
Flag which specifies if the weights tensor has to be retained from previous run.
Definition: Types.h:2098
DetectionOutputLayerCodeType
Available Detection Output code types.
Definition: Types.h:967
ConvolutionMethod
Available ConvolutionMethod.
Definition: Types.h:138
Activation Layer Information class.
Definition: Types.h:1550
decltype(strategy::transforms) typedef type
float spatial_scale() const
Definition: Types.h:1464
Terminate on whichever of the other conditions occurs first.
A 2 plane YUV format of Luma (Y) and interleaved VU data at 4:2:0 sampling.
bool use_regular_nms() const
Get if use regular nms.
Definition: Types.h:1167
int top_k() const
Get top K.
Definition: Types.h:1070
constexpr BorderSize(unsigned int top_bottom, unsigned int left_right)
Border with same size for top/bottom and left/right.
Definition: Types.h:288
Copyright (c) 2017-2021 Arm Limited.
WeightsInfo()
Default constructor.
Definition: Types.h:1769
bool suppress_size() const
Get if NMS will suppress boxes based on their size/position.
Definition: Types.h:687
bool is_b_reshaped() const
Flag which specifies if the matrix B has been reshaped.
Definition: Types.h:2064
int32_t x
X coordinates.
Definition: Types.h:465
ActivationFunction
Available activation functions.
Definition: Types.h:1554
1 channel, 1 F16 per channel
Samples are taken at pixel center.
float iou_threshold() const
Get intersection over union threshold.
Definition: Types.h:1157
BoxNMSLimitInfo(float score_thresh=0.05f, float nms=0.3f, int detections=100, bool soft_nms_enabled=false, NMSType soft_nms_method=NMSType::LINEAR, float soft_nms_sigma=0.5f, float soft_nms_min_score_thres=0.001f, bool suppress_size=false, float min_size=1.0f, float im_width=1.0f, float im_height=1.0f)
Constructor.
Definition: Types.h:643
Keypoint type.
Definition: Types.h:439
uint32_t z
Z coordinates.
Definition: Types.h:474
GenerateProposalsInfo(float im_width, float im_height, float im_scale, float spatial_scale=1.0, int pre_nms_topN=6000, int post_nms_topN=300, float nms_thres=0.7, float min_size=16.0, size_t values_per_roi=4)
Constructor.
Definition: Types.h:1367
NMSType
Available non maxima suppression types.
Definition: Types.h:618
Convolution Layer Weights Information class.
Definition: Types.h:1765
DetectionOutputLayerInfo()
Default Constructor.
Definition: Types.h:980
1 channel, 1 S32 per channel
bool variance_encoded_in_target() const
Get if variance encoded in target.
Definition: Types.h:1040
16-bit brain floating-point number
signed 64-bit number
int n() const
Number of matrix B columns.
Definition: Types.h:1869
3 channels, 1 U8 per channel
NormalizationLayerInfo(NormType type, uint32_t norm_size=5, float alpha=0.0001f, float beta=0.5f, float kappa=1.f, bool is_scaled=true)
Default Constructor.
Definition: Types.h:1660
FuseBatchNormalizationType
Available FuseBatchNormalizationType.
Definition: Types.h:162
int32_t y
Y coordinates.
Definition: Types.h:466
PoolingLayerInfo(PoolingType pool_type, Size2D pool_size, DataLayout data_layout, PadStrideInfo pad_stride_info=PadStrideInfo(), bool exclude_padding=false, bool fp_mixed_precision=false)
Constructor.
Definition: Types.h:1265
std::array< float, 2 > steps() const
Get the step coordinates.
Definition: Types.h:914
float nms() const
Get the NMS.
Definition: Types.h:657
float nms_threshold() const
Get nms threshold.
Definition: Types.h:1050
Third channel (used by formats with unknown channel types).
bool padding_is_symmetric() const
Check whether the padding is symmetric.
Definition: Types.h:778
bool is_scaled() const
Get the is_scaled value.
Definition: Types.h:1690
1 channel, 1 U32 per channel
GEMM RHS (Right Hand Side) matrix information.
Definition: Types.h:1983
Normalization applied within the same map in 1D region.
Channel
Available channels.
Definition: Types.h:487
Format
Image colour formats.
Definition: Types.h:54
std::string row_delim
Row delimeter.
Definition: Types.h:2256
PaddingMode
Padding mode to use for PadLayer.
Definition: Types.h:169
IO formatting information class.
Definition: Types.h:2205
quantized, asymmetric fixed-point 8-bit number unsigned
int start(unsigned int d) const
Return the start of the valid region for the given dimension d.
Definition: Types.h:234
Coordinates of an item.
Definition: Coordinates.h:37
float scale_value_h() const
Get h scale value.
Definition: Types.h:1184
std::pair< unsigned int, unsigned int > stride() const
Get the stride.
Definition: Types.h:770
float scale_value_w() const
Get w scale value.
Definition: Types.h:1190
Pooling Layer Information struct.
Definition: Types.h:1214
float nms_score_threshold() const
Get nms threshold.
Definition: Types.h:1152
float soft_nms_min_score_thres() const
Get soft nms min score threshold.
Definition: Types.h:682
BitwiseOperation
Available bitwise operations.
Definition: Types.h:560
WeightsInfo(bool are_reshaped, unsigned int kernel_width, unsigned int kernel_height, unsigned int num_kernels, bool retain_internal_weights=false)
Constructor.
Definition: Types.h:1781
std::array< float, 4 > BBox
Definition: Types.h:962
bool dequantize_scores() const
Get dequantize_scores value.
Definition: Types.h:1196
GEMMLowp output stage info.
Definition: Types.h:1952
A 3 plane of 8 bit 4:4:4 sampled Y, U, V planes.
Samples are taken at pixel top left corner.
PriorBox layer info.
Definition: Types.h:839
float offset() const
Get the offset.
Definition: Types.h:924
Fourth channel (used by formats with unknown channel types).
DetectionOutputLayerCodeType code_type() const
Get detection output code type.
Definition: Types.h:1035
unsigned int pad_right() const
Get the right padding.
Definition: Types.h:801
float beta() const
Get the beta value.
Definition: Types.h:1680
int k() const
Number of matrix A columns or matrix B rows.
Definition: Types.h:1877
Quantize using a floating point multiplication.
Padding and stride information class.
Definition: Types.h:722
ComparisonOperation
Supported comparison operations.
Definition: Types.h:177
PoolingLayerInfo(PoolingType pool_type, unsigned int pool_size, DataLayout data_layout, PadStrideInfo pad_stride_info=PadStrideInfo(), bool exclude_padding=false, bool fp_mixed_precision=false)
Constructor.
Definition: Types.h:1238
GEMMLowpOutputStageType
GEMMLowp output stage type.
Definition: Types.h:1943
Termination
Termination criteria.
Definition: Types.h:414
Coordinates2D img_size() const
Get the image size coordinates.
Definition: Types.h:919
constexpr BorderSize(unsigned int size)
Border with equal size around the 2D plane.
Definition: Types.h:282
bool align_columns
Align columns.
Definition: Types.h:2258
unsigned int num_kernels() const
Return the number of convolution kernels.
Definition: Types.h:1797
bool reinterpret_input_as_3d() const
Flag which specifies if the input tensor has to be reinterpreted as 3D.
Definition: Types.h:2090
Bounding Box Transform information class.
Definition: Types.h:1483
unsigned int left
left of the border
Definition: Types.h:378
GEMMInfo() noexcept
Default constructor.
Definition: Types.h:2007
bool operator!=(const BorderSize &rhs)
Check non-equality with another BorderSize struct.
Definition: Types.h:358
PriorBoxLayerInfo()
Default Constructor.
Definition: Types.h:843
unsigned int right
right of the border
Definition: Types.h:376
y*x if x < 0, x otherwise
Quantize using an integer multiplication.
BoundingBoxTransformInfo(float img_width, float img_height, float scale, bool apply_scale=false, const std::array< float, 4 > weights={ { 1.f, 1.f, 1.f, 1.f } }, bool correct_transform_coords=false, float bbox_xform_clip=4.135166556742356f)
Constructor.
Definition: Types.h:1496
1 channel, 1 S16 per channel
L2 normalization type.
bool broadcast_bias() const
Flag which specifies whether to broadcast the shape of the bias tensor.
Definition: Types.h:2130
int keep_top_k() const
Get the number of total bounding boxes to be kept per image.
Definition: Types.h:1045
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
unsigned int sampling_ratio() const
Get sampling ratio.
Definition: Types.h:1339
Num samples, channels, height, width.
PrecisionType
Precision type used when printing floating point numbers.
Definition: Types.h:2208
unsigned int max_classes_per_detection() const
Get max_classes per detection.
Definition: Types.h:1142
bool broadcast_bias() const
Flag which specifies whether to broadcast the shape of the bias tensor.
Definition: Types.h:1920
bool is_a_reshaped() const
Flag which specifies if the matrix A has been reshaped.
Definition: Types.h:2056
int round(float x, RoundingPolicy rounding_policy)
Return a rounded value of x.
Definition: Rounding.cpp:35
float scale_value_y() const
Get y scale value.
Definition: Types.h:1172
PadStrideInfo(unsigned int stride_x, unsigned int stride_y, unsigned int pad_left, unsigned int pad_right, unsigned int pad_top, unsigned int pad_bottom, DimensionRoundingType round)
Constructor.
Definition: Types.h:754
Strides of an item in bytes.
Definition: Strides.h:37
quantized, symmetric per channel fixed-point 8-bit number
Convolution using Winograd.
A 3 plane of 8-bit 4:2:0 sampled Y, U, V planes.
float min_size() const
Get size suppression threshold.
Definition: Types.h:692
PadStrideInfo(unsigned int stride_x=1, unsigned int stride_y=1, unsigned int pad_x=0, unsigned int pad_y=0, DimensionRoundingType round=DimensionRoundingType::FLOOR)
Constructor.
Definition: Types.h:733
Detection Output layer info.
Definition: Types.h:976
4 channels, 1 U8 per channel
uint32_t y
Y coordinates.
Definition: Types.h:473
ValidRegion(const Coordinates &an_anchor, const TensorShape &a_shape)
Constructor for a valid region with default number of dimensions.
Definition: Types.h:213
PoolingType
Available pooling types.
Definition: Types.h:610
Bitwise XOR operation.
PadStrideInfo pad_stride_info
Definition: Types.h:1302
GEMMReshapeInfo()
Default constructor.
Definition: Types.h:1835
void set_gemmlowp_output_stage(GEMMLowpOutputStageInfo &output_stage)
Sets GEMMLowp output stage.
Definition: Types.h:2114
constexpr bool empty() const
Check if the entire border is zero.
Definition: Types.h:300
int32_t shrink_axis_mask() const
Definition: Types.h:1753
HOGNormType
Normalization type for Histogram of Oriented Gradients (HOG)
Definition: Types.h:577
std::pair< uint32_t, uint32_t > PaddingInfo
Padding information as a pair of unsigned int start/end.
Definition: Types.h:478
Coordinate type.
Definition: Types.h:463
int end(unsigned int d) const
Return the end of the valid region for the given dimension d.
Definition: Types.h:240
Bitwise AND operation.
unsigned int pooled_height() const
Get the pooled height of the layer.
Definition: Types.h:1329
int m() const
Number of matrix A rows.
Definition: Types.h:1861
Borders are left undefined.
ROI Pooling Layer Information class.
Definition: Types.h:1309
Pixels outside the image are assumed to have the same value as the closest image pixel.
Bitwise OR operation.
constexpr BorderSize()
Empty border, i.e.
Definition: Types.h:276
Class for specifying the size of an image or rectangle.
Definition: Size2D.h:34
Detection window used for the object detection.
Definition: Types.h:590
std::vector< float > max_sizes() const
Get max sizes.
Definition: Types.h:939
ComputeAnchors information class.
Definition: Types.h:1433
uint16_t width
Width of the rectangle.
Definition: Types.h:458
Num samples, height, width, channels.
unsigned int detection_per_class() const
Get detection per class.
Definition: Types.h:1147
bool flip() const
Get the flip value.
Definition: Types.h:929
2 channel, 1 U8 per channel
float spatial_scale() const
Get the spatial scale.
Definition: Types.h:1334
Threshold with two values.
uint16_t y
Top-left y coordinate.
Definition: Types.h:457
Detection Output layer info.
Definition: Types.h:1095
int depth_output_gemm3d() const
Depth (third dimension) of the output tensor to be used with the GEMM3D kernel.
Definition: Types.h:1904
constexpr bool uniform() const
Check if the border is the same size on all sides.
Definition: Types.h:306
Size2D pool_size
unsigned int num_classes() const
Get num classes.
Definition: Types.h:1162
Use box centers and size but flip x and y co-ordinates.
IOFormatInfo(PrintRegion print_region=PrintRegion::ValidRegion, PrecisionType precision_type=PrecisionType::Default, unsigned int precision=10, bool align_columns=true, std::string element_delim=" ", std::string row_delim="\)
Construct a set of IO formatting information.
Definition: Types.h:2232
PrintRegion
Specifies the area to be printed, used by Tensor objects.
Definition: Types.h:2216
std::vector< float > variances() const
Get min variances.
Definition: Types.h:909
bool operator==(const BorderSize &rhs)
Check equality with another BorderSize struct.
Definition: Types.h:347
std::array< float, 4 > weights() const
Definition: Types.h:1504
bool reshape_b_only_on_first_run() const
Flag which specifies if the reshape of matrix B should executed only for the first.
Definition: Types.h:2074
constexpr BorderSize(unsigned int top, unsigned int right, unsigned int bottom, unsigned int left)
Border with different sizes.
Definition: Types.h:294
uint16_t x
Top-left x coordinate.
Definition: Types.h:456
float alpha() const
Get the alpha value.
Definition: Types.h:1675
GEMM information class.
Definition: Types.h:2003
SimpleTensor< T > transpose(const SimpleTensor< T > &src)
Definition: Transpose.cpp:38
BorderSize operator*(float scale)
Scale a copy of this border size.
Definition: Types.h:333
std::pair< unsigned int, unsigned int > pad() const
Get the padding.
Definition: Types.h:788
DetectionOutputLayerInfo(int num_classes, bool share_location, DetectionOutputLayerCodeType code_type, int keep_top_k, float nms_threshold, int top_k=-1, int background_label_id=-1, float confidence_threshold=std::numeric_limits< float >::lowest(), bool variance_encoded_in_target=false, float eta=1)
Constructor.
Definition: Types.h:1008
ActivationFunction activation() const
Get the type of activation function.
Definition: Types.h:1585
float b() const
Get the beta value.
Definition: Types.h:1595
quantized, asymmetric fixed-point 8-bit number signed
64-bit floating-point number
Container for valid region of a window.
Definition: Types.h:188
Threshold with one value.
MagnitudeType
Magnitude calculation type.
Definition: Types.h:422
uint16_t height
Height of the rectangle.
Definition: Types.h:459
unsigned int pad_bottom() const
Get the bottom padding.
Definition: Types.h:811
A single plane of 32-bit macro pixel of Y0, U0, Y1, V0 bytes.
bool clip() const
Get the clip value.
Definition: Types.h:934
GEMMInfo(bool is_a_reshaped, bool is_b_reshaped, bool reshape_b_only_on_first_run, int depth_output_gemm3d=0, bool reinterpret_input_as_3d=false, bool retain_internal_weights=false, GEMMLowpOutputStageInfo gemmlowp_output_stage=GEMMLowpOutputStageInfo(), bool fp_mixed_precision=false, bool broadcast_bias=false, const ActivationLayerInfo &activation_info=ActivationLayerInfo()) noexcept
Constructor.
Definition: Types.h:2036
unsigned 64-bit number
Cross pattern matrix.
DataType
Available data types.
Definition: Types.h:77
bool reinterpret_input_as_3d() const
Flag which specifies if the input tensor has to be reinterpreted as 3D.
Definition: Types.h:1912
ActivationLayerInfo activation_info() const
Activation layer to apply after the matrix multiplication.
Definition: Types.h:2154
unsigned int pad_left() const
Get the left padding.
Definition: Types.h:796
ElementWiseUnary
Available element wise unary operations.
Definition: Types.h:547
DataLayout
[DataLayout enum definition]
Definition: Types.h:120
std::vector< uint32_t > Multiples
Information to produce a tiled version of a Tensor.
Definition: Types.h:484
NormType
The normalization type used for the normalization layer.
Definition: Types.h:569
signed 8-bit number
MatrixPattern
Available matrix patterns.
Definition: Types.h:504
Normalization applied cross maps.
BorderSize & operator*=(float scale)
Scale this border size.
Definition: Types.h:317
Any other matrix pattern.
Convolution using GEMM.
ConvertPolicy
Policy to handle overflow.
Definition: Types.h:385
NMSType soft_nms_method() const
Get soft NMS method.
Definition: Types.h:672
void limit(const BorderSize &limit)
Limit this border size.
Definition: Types.h:367
int background_label_id() const
Get background label ID.
Definition: Types.h:1060
float im_height() const
Get image height (NMS may suppress boxes whose center sits beyond the image height) ...
Definition: Types.h:702
NonLinearFilterFunction
Available non linear functions.
Definition: Types.h:513
Coordinates anchor
Anchor for the start of the valid region.
Definition: Types.h:260
ValidRegion()
Default constructor.
Definition: Types.h:191
float confidence_threshold() const
Get confidence threshold.
Definition: Types.h:1065
Normalization applied within the same map in 2D region.
bool retain_internal_weights() const
Definition: Types.h:1809
StridedSliceLayerInfo(int32_t begin_mask=0, int32_t end_mask=0, int32_t shrink_axis_mask=0)
Default Constructor.
Definition: Types.h:1735
SamplingPolicy
Available Sampling Policies.
Definition: Types.h:102
float soft_nms_sigma() const
Get soft NMS sigma.
Definition: Types.h:677
std::pair< unsigned int, unsigned int > kernel_size() const
Return the width and height of the kernel.
Definition: Types.h:1805
int num_loc_classes() const
Get number of location classes.
Definition: Types.h:1075
bool soft_nms_enabled() const
Check if soft NMS is enabled.
Definition: Types.h:667
int detections_per_im() const
Get the number of detections.
Definition: Types.h:662
std::string element_delim
Element delimeter.
Definition: Types.h:2254
std::vector< float > min_sizes() const
Get min sizes.
Definition: Types.h:904
bool has_padding() const
Check whether this has any padding.
Definition: Types.h:823
ComputeAnchorsInfo(float feat_width, float feat_height, float spatial_scale, size_t values_per_roi=4)
Constructor.
Definition: Types.h:1443