blob: f2f60c150e3f7ffca8ea52bd6c2fffe9780a75ad [file] [log] [blame]
/*
* Copyright (c) 2016-2024 Arm Limited.
*
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef ACL_ARM_COMPUTE_CORE_TYPES_H
#define ACL_ARM_COMPUTE_CORE_TYPES_H
/** The following symbols have been moved to:
* half
* PermutationVector
* Format
* DataType
* DataLayout
* DataLayoutDimension
* PadStrideInfo
* WeightFormat
* Channel
* DimensionRoundingType
*/
#include "arm_compute/core/CoreTypes.h"
/** The following symbols have been moved to:
* ActivationFunction
* ActivationLayerInfo
*/
#include "arm_compute/function_info/ActivationLayerInfo.h"
/** The following symbols have been moved to:
* ConvolutionInfo
*/
#include "arm_compute/function_info/ConvolutionInfo.h"
/** The following symbols have been moved to:
* FullyConnectedLayerInfo
*/
#include "arm_compute/function_info/FullyConnectedLayerInfo.h"
/** The following symbols have been moved to:
* GEMMLowpOutputStageType
* GEMMLowpOutputStageInfo
* GEMMInfo
*/
#include "arm_compute/function_info/GEMMInfo.h"
/** The following symbols have been moved to:
* MatMulInfo
*/
#include "arm_compute/core/Coordinates.h"
#include "arm_compute/core/Size2D.h"
#include "arm_compute/core/Size3D.h"
#include "arm_compute/core/TensorShape.h"
#include "arm_compute/core/utils/misc/Macros.h"
#include "arm_compute/function_info/MatMulInfo.h"
#include "support/Bfloat16.h"
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <map>
#include <string>
#include <utility>
namespace arm_compute
{
/** Bidirectional strides */
using BiStrides = Coordinates;
/** Available Sampling Policies */
enum class SamplingPolicy
{
CENTER, /**< Samples are taken at pixel center */
TOP_LEFT /**< Samples are taken at pixel top left corner */
};
/** Available ConvolutionMethod*/
enum class ConvolutionMethod
{
GEMM, /**< Convolution using GEMM */
GEMM_CONV2D, /**< Direct 2D GEMM convolution */
DIRECT, /**< Direct convolution */
INDIRECT, /**< Indirect convolution */
WINOGRAD, /**< Convolution using Winograd */
FFT /**< Convolution using FFT */
};
/** Available DepthwiseConvolutionFunction*/
enum class DepthwiseConvolutionFunction
{
OPTIMIZED, /**< Optimized Depthwise Convolution */
GENERIC, /**< Generic Depthwise Convolution */
};
/** Available DeconvolutionMethod*/
enum class DeconvolutionMethod
{
GEMM, /**< Deconvolution using GEMM */
DIRECT, /**< Direct deconvolution */
UPSCALE_CONV2D /**< Deconvolution with Upscaling */
};
/** Available FuseBatchNormalizationType*/
enum class FuseBatchNormalizationType
{
CONVOLUTION, /**< For Convolution weights */
DEPTHWISECONVOLUTION /**< For Depthwise Convolution weights*/
};
/** Padding mode to use for PadLayer */
enum class PaddingMode
{
CONSTANT,
REFLECT,
SYMMETRIC
};
/** Supported comparison operations */
enum class ComparisonOperation
{
Equal, /**< Equal comparison ( \f$ x == y \f$ ) */
NotEqual, /**< NotEqual comparison ( \f$ x != y \f$ ) */
Greater, /**< Greater comparison ( \f$ x > y \f$ ) */
GreaterEqual, /**< Greater equal comparison ( \f$ x >= y \f$ ) */
Less, /**< Less comparison ( \f$ x < y \f$ ) */
LessEqual /**< Less equal comparison ( \f$ x <= y \f$ ) */
};
/** Container for valid region of a window */
struct ValidRegion
{
/** Default constructor */
ValidRegion() : anchor{}, shape{}
{
}
/** Allow instances of this class to be copy constructed */
ValidRegion(const ValidRegion &) = default;
/** Allow instances of this class to be move constructed */
ValidRegion(ValidRegion &&) = default;
/** Allow instances of this class to be copied */
ValidRegion &operator=(const ValidRegion &) = default;
/** Allow instances of this class to be moved */
ValidRegion &operator=(ValidRegion &&) = default;
/** Default destructor */
~ValidRegion() = default;
/** Constructor for a valid region with default number of dimensions
*
* @param[in] an_anchor Anchor for the start of the valid region.
* @param[in] a_shape Shape of the valid region.
*
*/
ValidRegion(const Coordinates &an_anchor, const TensorShape &a_shape) : anchor{an_anchor}, shape{a_shape}
{
anchor.set_num_dimensions(std::max(anchor.num_dimensions(), shape.num_dimensions()));
}
/** Constructor for a valid region with specified number of dimensions
*
* @param[in] an_anchor Anchor for the start of the valid region.
* @param[in] a_shape Shape of the valid region.
* @param[in] num_dimensions Number of dimensions (must be >= number of dimensions of anchor and shape).
*
*/
ValidRegion(const Coordinates &an_anchor, const TensorShape &a_shape, size_t num_dimensions)
: anchor{an_anchor}, shape{a_shape}
{
ARM_COMPUTE_ERROR_ON(num_dimensions < std::max(anchor.num_dimensions(), shape.num_dimensions()));
anchor.set_num_dimensions(num_dimensions);
}
/** Return the start of the valid region for the given dimension @p d */
int start(unsigned int d) const
{
return anchor[d];
}
/** Return the end of the valid region for the given dimension @p d */
int end(unsigned int d) const
{
return anchor[d] + shape[d];
}
/** Accessor to set the value of anchor and shape for one of the dimensions.
*
* @param[in] dimension Dimension for which the value is set.
* @param[in] start Value to be set in anchor for the dimension.
* @param[in] size Value to be set in shape for the dimension.
*
* @return *this.
*/
ValidRegion &set(size_t dimension, int start, size_t size)
{
anchor.set(dimension, start);
shape.set(dimension, size);
return *this;
}
/** Check whether two valid regions are equal.
*
* @param[in] lhs LHS valid region
* @param[in] rhs RHS valid region
*
* @return True if the valid regions are the same.
*/
inline friend bool operator==(const ValidRegion &lhs, const ValidRegion &rhs);
Coordinates anchor; /**< Anchor for the start of the valid region. */
TensorShape shape; /**< Shape of the valid region. */
};
inline bool operator==(const ValidRegion &lhs, const ValidRegion &rhs)
{
return (lhs.anchor == rhs.anchor) && (lhs.shape == rhs.shape);
}
/** Methods available to handle borders */
enum class BorderMode
{
UNDEFINED, /**< Borders are left undefined */
CONSTANT, /**< Pixels outside the image are assumed to have a constant value */
REPLICATE /**< Pixels outside the image are assumed to have the same value as the closest image pixel */
};
/** Container for 2D border size */
struct BorderSize
{
/** Empty border, i.e. no border */
constexpr BorderSize() noexcept : top{0}, right{0}, bottom{0}, left{0}
{
}
/** Border with equal size around the 2D plane */
explicit constexpr BorderSize(unsigned int size) noexcept : top{size}, right{size}, bottom{size}, left{size}
{
}
/** Border with same size for top/bottom and left/right */
constexpr BorderSize(unsigned int top_bottom, unsigned int left_right)
: top{top_bottom}, right{left_right}, bottom{top_bottom}, left{left_right}
{
}
/** Border with different sizes */
constexpr BorderSize(unsigned int top, unsigned int right, unsigned int bottom, unsigned int left)
: top{top}, right{right}, bottom{bottom}, left{left}
{
}
/** Check if the entire border is zero */
constexpr bool empty() const
{
return top == 0 && right == 0 && bottom == 0 && left == 0;
}
/** Check if the border is the same size on all sides */
constexpr bool uniform() const
{
return top == right && top == bottom && top == left;
}
/** Scale this border size.
*
* @param[in] scale Scale to multiply border size by.
*
* @return *this.
*/
BorderSize &operator*=(float scale)
{
top *= scale;
right *= scale;
bottom *= scale;
left *= scale;
return *this;
}
/** Scale a copy of this border size.
*
* @param[in] scale Scale to multiply border size by.
*
* @return a scaled copy of this.
*/
BorderSize operator*(float scale)
{
BorderSize size = *this;
size *= scale;
return size;
}
/** Check equality with another BorderSize struct
*
* @param[in] rhs other struct to check against
*
* @return true if they are equal
*/
bool operator==(const BorderSize &rhs) const
{
return (top == rhs.top) && (right == rhs.right) && (bottom == rhs.bottom) && (left == rhs.left);
}
/** Check non-equality with another BorderSize struct
*
* @param[in] rhs other struct to check against
*
* @return true if they are different
*/
bool operator!=(const BorderSize &rhs) const
{
return !(*this == rhs);
}
/** Limit this border size.
*
* @param[in] limit Border size to limit this border size to.
*/
void limit(const BorderSize &limit)
{
top = std::min(top, limit.top);
right = std::min(right, limit.right);
bottom = std::min(bottom, limit.bottom);
left = std::min(left, limit.left);
}
unsigned int top; /**< top of the border */
unsigned int right; /**< right of the border */
unsigned int bottom; /**< bottom of the border */
unsigned int left; /**< left of the border */
};
/** Container for 2D padding size */
using PaddingSize = BorderSize;
/** Policy to handle integer overflow
* @note: This is ignored by floating point operations where the overflow behavior adheres to the IEEE-754 standard
* which states that in case of overflow ±infinity is returned for the round-to-nearest modes (and follows the
* rounding rules for the directed rounding modes) by default.
*/
enum class ConvertPolicy
{
WRAP, /**< Wrap around */
SATURATE /**< Saturate */
};
/** Interpolation method */
enum class InterpolationPolicy
{
NEAREST_NEIGHBOR, /**< Output values are defined to match the source pixel whose center is nearest to the sample position */
BILINEAR, /**< Output values are defined by bilinear interpolation between the pixels */
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 */
};
/** Bilinear Interpolation method used by LKTracker */
enum class BilinearInterpolation
{
BILINEAR_OLD_NEW, /**< Old-new method */
BILINEAR_SCHARR /**< Scharr method */
};
/** Rectangle type */
struct Rectangle
{
uint16_t x; /**< Top-left x coordinate */
uint16_t y; /**< Top-left y coordinate */
uint16_t width; /**< Width of the rectangle */
uint16_t height; /**< Height of the rectangle */
};
/** Coordinate type */
struct Coordinates2D
{
int32_t x; /**< X coordinates */
int32_t y; /**< Y coordinates */
};
/** Coordinate type */
struct Coordinates3D
{
uint32_t x; /**< X coordinates */
uint32_t y; /**< Y coordinates */
uint32_t z; /**< Z coordinates */
};
/** Padding information as a pair of unsigned int start/end */
using PaddingInfo = std::pair<uint32_t, uint32_t>;
/** List of padding information */
using PaddingList = std::vector<PaddingInfo>;
/** Information to produce a tiled version of a Tensor */
using Multiples = std::vector<uint32_t>;
/** Available reduction operations */
enum class ReductionOperation
{
ARG_IDX_MAX, /**< Index of the max value */
ARG_IDX_MIN, /**< Index of the min value */
MEAN_SUM, /**< Mean of sum */
PROD, /**< Product */
SUM_SQUARE, /**< Sum of squares */
SUM, /**< Sum */
MIN, /**< Min */
MAX, /**< Max */
};
/** Available element-wise operations */
enum class ArithmeticOperation
{
ADD, /**< (x + y) */
SUB, /**< (x - y) */
DIV, /**< (x / y) */
MIN, /**< Min(x, y) */
MAX, /**< Max(x, y) */
SQUARED_DIFF, /**< (x - y)^2 */
POWER, /**< x ^ y */
PRELU, /**< y*x if x < 0, x otherwise */
};
/** Available element wise unary operations */
enum class ElementWiseUnary
{
RSQRT, /**< Reverse square root */
EXP, /**< Exponential */
NEG, /**< Negate */
LOG, /**< Natural Logarithm */
ABS, /**< Absolute value */
SIN, /**< Sine */
ROUND, /**< Round */
LOGICAL_NOT, /**< Logical Not */
};
/** Available bitwise operations */
enum class BitwiseOperation
{
AND, /**< Bitwise AND operation */
NOT, /**< Bitwise NOT operation */
OR, /**< Bitwise OR operation */
XOR, /**< Bitwise XOR operation */
};
/** The normalization type used for the normalization layer */
enum class NormType
{
IN_MAP_1D, /**< Normalization applied within the same map in 1D region */
IN_MAP_2D, /**< Normalization applied within the same map in 2D region */
CROSS_MAP /**< Normalization applied cross maps */
};
/** Detection window used for the object detection. The detection window keeps the following information:
*
* -# Geometry of the rectangular window (x/y of top-left corner and width/height)
* -# Index of the class used for evaluating which class the detection window belongs to
* -# Confidence value (score) obtained with the classifier
*/
struct DetectionWindow
{
uint16_t x{0}; /**< Top-left x coordinate */
uint16_t y{0}; /**< Top-left y coordinate */
uint16_t width{0}; /**< Width of the detection window */
uint16_t height{0}; /**< Height of the detection window */
uint16_t idx_class{0}; /**< Index of the class */
float score{0.f}; /**< Confidence value for the detection window */
};
/** Available pooling types */
enum class PoolingType
{
MAX, /**< Max Pooling */
AVG, /**< Average Pooling */
L2 /**< L2 Pooling */
};
/** Available non maxima suppression types */
enum class NMSType
{
LINEAR, /**< Linear NMS */
GAUSSIAN, /**< Gaussian NMS */
ORIGINAL /**< Original NMS */
};
/** BoxWithNonMaximaSuppressionLimit Information class */
class BoxNMSLimitInfo final
{
public:
/** Constructor
*
* @param[in] score_thresh (Optional) Score threshold.
* @param[in] nms (Optional) NMS value
* @param[in] detections (Optional) Number of detections
* @param[in] soft_nms_enabled (Optional) Enable SoftNMS
* @param[in] soft_nms_method (Optional) Soft NMS method
* @param[in] soft_nms_sigma (Optional) Soft NMS sigma value
* @param[in] soft_nms_min_score_thres (Optional) Soft NMS minimum score threshold
* @param[in] suppress_size (Optional) Filter out boxes based on their size. Defaults to false
* @param[in] min_size (Optional) Smaller boxes than min_size will be filtered out. Defaults to 1
* @param[in] im_width (Optional) Boxes whose centers (on the x axis) is beyond im_width will be filtered. Defaults to 1
* @param[in] im_height (Optional) Boxes whose centers (on the y axis) is beyond im_height will be filtered. Defaults to 1
*/
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)
: _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),
_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)
{
}
/** Get the score threshold */
float score_thresh() const
{
return _score_thresh;
}
/** Get the NMS */
float nms() const
{
return _nms;
}
/** Get the number of detections */
int detections_per_im() const
{
return _detections_per_im;
}
/** Check if soft NMS is enabled */
bool soft_nms_enabled() const
{
return _soft_nms_enabled;
}
/** Get soft NMS method */
NMSType soft_nms_method() const
{
return _soft_nms_method;
}
/** Get soft NMS sigma */
float soft_nms_sigma() const
{
return _soft_nms_sigma;
}
/** Get soft nms min score threshold */
float soft_nms_min_score_thres() const
{
return _soft_nms_min_score_thres;
}
/** Get if NMS will suppress boxes based on their size/position */
bool suppress_size() const
{
return _suppress_size;
}
/** Get size suppression threshold */
float min_size() const
{
return _min_size;
}
/** Get image width (NMS may suppress boxes whose center sits beyond the image width) */
float im_width() const
{
return _im_width;
}
/** Get image height (NMS may suppress boxes whose center sits beyond the image height) */
float im_height() const
{
return _im_height;
}
private:
float _score_thresh;
float _nms;
int _detections_per_im;
bool _soft_nms_enabled;
NMSType _soft_nms_method;
float _soft_nms_sigma;
float _soft_nms_min_score_thres;
bool _suppress_size;
float _min_size;
float _im_width;
float _im_height;
};
/** Padding and stride information class */
/** Padding information for 2D operations like Conv2d */
struct Padding2D
{
Padding2D() = default;
Padding2D(size_t left, size_t right, size_t top, size_t bottom) : left(left), right(right), top(top), bottom(bottom)
{
}
size_t left = {0}; /**< Padding across the width dimension on the left, in elements. */
size_t right = {0}; /**< Padding across the width dimension on the right, in elements. */
size_t top = {0}; /**< Padding across the height dimension on the top, in elements. */
size_t bottom = {0}; /**< Padding across the height dimension on the bottom, in elements. */
};
/** Padding information for 3D operations like Conv3d */
struct Padding3D
{
Padding3D() noexcept
{
}
Padding3D(size_t pad_x, size_t pad_y, size_t pad_z)
: left(pad_x), right(pad_x), top(pad_y), bottom(pad_y), front(pad_z), back(pad_z)
{
}
Padding3D(size_t left, size_t right, size_t top, size_t bottom, size_t front, size_t back)
: left(left), right(right), top(top), bottom(bottom), front(front), back(back)
{
}
size_t left = {0}; /**< Padding across the width dimenstion on the left, in elements. */
size_t right = {0}; /**< Padding across the width dimenstion on the right, in elements. */
size_t top = {0}; /**< Padding across the height dimenstion on the top, in elements. */
size_t bottom = {0}; /**< Padding across the height dimenstion on the bottom, in elements. */
size_t front = {0}; /**< Padding across the depth dimenstion on the front, in elements. */
size_t back = {0}; /**< Padding across the depth dimenstion on the back, in elements. */
};
/** PriorBox layer info */
class PriorBoxLayerInfo final
{
public:
/** Default Constructor */
PriorBoxLayerInfo()
: _min_sizes(),
_variances(),
_offset(),
_flip(true),
_clip(false),
_max_sizes(),
_aspect_ratios(),
_img_size(),
_steps()
{
}
/** Constructor
*
* @param[in] min_sizes Min sizes vector.
* @param[in] variances Variances vector.
* @param[in] offset Offset value.
* @param[in] flip (Optional) Flip the aspect ratios.
* @param[in] clip (Optional) Clip coordinates so that they're within [0,1].
* @param[in] max_sizes (Optional) Max sizes vector.
* @param[in] aspect_ratios (Optional) Aspect ratios of the boxes.
* @param[in] img_size (Optional) Image size.
* @param[in] steps (Optional) Step values.
*/
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}})
: _min_sizes(min_sizes),
_variances(variances),
_offset(offset),
_flip(flip),
_clip(clip),
_max_sizes(max_sizes),
_aspect_ratios(),
_img_size(img_size),
_steps(steps)
{
_aspect_ratios.push_back(1.);
for (unsigned int i = 0; i < aspect_ratios.size(); ++i)
{
float ar = aspect_ratios[i];
bool already_exist = false;
for (auto ar_new : _aspect_ratios)
{
if (fabs(ar - ar_new) < 1e-6)
{
already_exist = true;
break;
}
}
if (!already_exist)
{
_aspect_ratios.push_back(ar);
if (flip)
{
_aspect_ratios.push_back(1.f / ar);
}
}
}
}
/** Get min sizes. */
std::vector<float> min_sizes() const
{
return _min_sizes;
}
/** Get min variances. */
std::vector<float> variances() const
{
return _variances;
}
/** Get the step coordinates */
std::array<float, 2> steps() const
{
return _steps;
}
/** Get the image size coordinates */
Coordinates2D img_size() const
{
return _img_size;
}
/** Get the offset */
float offset() const
{
return _offset;
}
/** Get the flip value */
bool flip() const
{
return _flip;
}
/** Get the clip value */
bool clip() const
{
return _clip;
}
/** Get max sizes. */
std::vector<float> max_sizes() const
{
return _max_sizes;
}
/** Get aspect ratios. */
std::vector<float> aspect_ratios() const
{
return _aspect_ratios;
}
private:
std::vector<float> _min_sizes;
std::vector<float> _variances;
float _offset;
bool _flip;
bool _clip;
std::vector<float> _max_sizes;
std::vector<float> _aspect_ratios;
Coordinates2D _img_size;
std::array<float, 2> _steps;
};
// Bounding Box [xmin, ymin, xmax, ymax]
using BBox = std::array<float, 4>;
// LabelBBox used for map label and bounding box
using LabelBBox = std::map<int, std::vector<BBox>>;
/** Available Detection Output code types */
enum class DetectionOutputLayerCodeType
{
CORNER, /**< Use box corners */
CENTER_SIZE, /**< Use box centers and size */
CORNER_SIZE, /**< Use box centers and size */
TF_CENTER /**< Use box centers and size but flip x and y co-ordinates */
};
/** Detection Output layer info */
class DetectionOutputLayerInfo final
{
public:
/** Default Constructor */
DetectionOutputLayerInfo()
: _num_classes(),
_share_location(),
_code_type(DetectionOutputLayerCodeType::CORNER),
_keep_top_k(),
_nms_threshold(),
_top_k(),
_background_label_id(),
_confidence_threshold(),
_variance_encoded_in_target(false),
_eta(),
_num_loc_classes()
{
_num_loc_classes = _share_location ? 1 : _num_classes;
}
/** Constructor
*
* @param[in] num_classes Number of classes to be predicted.
* @param[in] share_location If true, bounding box are shared among different classes.
* @param[in] code_type Type of coding method for bbox.
* @param[in] keep_top_k Number of total bounding boxes to be kept per image after NMS step.
* @param[in] nms_threshold Threshold to be used in NMS.
* @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.
* @param[in] background_label_id (Optional) Background label ID. If there is no background class, set it as -1.
* @param[in] confidence_threshold (Optional) Only consider detections whose confidences are larger than a threshold. Default set to -FLT_MAX.
* @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.
* @param[in] eta (Optional) Eta.
*/
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)
: _num_classes(num_classes),
_share_location(share_location),
_code_type(code_type),
_keep_top_k(keep_top_k),
_nms_threshold(nms_threshold),
_top_k(top_k),
_background_label_id(background_label_id),
_confidence_threshold(confidence_threshold),
_variance_encoded_in_target(variance_encoded_in_target),
_eta(eta),
_num_loc_classes()
{
_num_loc_classes = _share_location ? 1 : _num_classes;
}
/** Get num classes. */
int num_classes() const
{
return _num_classes;
}
/** Get share location. */
bool share_location() const
{
return _share_location;
}
/** Get detection output code type. */
DetectionOutputLayerCodeType code_type() const
{
return _code_type;
}
/** Get if variance encoded in target. */
bool variance_encoded_in_target() const
{
return _variance_encoded_in_target;
}
/** Get the number of total bounding boxes to be kept per image. */
int keep_top_k() const
{
return _keep_top_k;
}
/** Get nms threshold. */
float nms_threshold() const
{
return _nms_threshold;
}
/** Get eta. */
float eta() const
{
return _eta;
}
/** Get background label ID. */
int background_label_id() const
{
return _background_label_id;
}
/** Get confidence threshold. */
float confidence_threshold() const
{
return _confidence_threshold;
}
/** Get top K. */
int top_k() const
{
return _top_k;
}
/** Get number of location classes. */
int num_loc_classes() const
{
return _num_loc_classes;
}
private:
int _num_classes;
bool _share_location;
DetectionOutputLayerCodeType _code_type;
int _keep_top_k;
float _nms_threshold;
int _top_k;
int _background_label_id;
float _confidence_threshold;
bool _variance_encoded_in_target;
float _eta;
int _num_loc_classes;
};
/** Detection Output layer info */
class DetectionPostProcessLayerInfo final
{
public:
/** Default Constructor */
DetectionPostProcessLayerInfo()
: _max_detections(),
_max_classes_per_detection(),
_nms_score_threshold(),
_iou_threshold(),
_num_classes(),
_scales_values(),
_use_regular_nms(),
_detection_per_class(),
_dequantize_scores()
{
}
/** Constructor
*
* @param[in] max_detections Number of total detection.
* @param[in] max_classes_per_detection Number of total classes to be kept after NMS step. Used in the Fast Non-Max-Suppression
* @param[in] nms_score_threshold Threshold to be used in NMS
* @param[in] iou_threshold Threshold to be used during the intersection over union.
* @param[in] num_classes Number of classes.
* @param[in] scales_values Scales values used for decode center size boxes.
* @param[in] use_regular_nms (Optional) Boolean to determinate if use regular or fast nms. Defaults to false.
* @param[in] detection_per_class (Optional) Number of detection per class. Used in the Regular Non-Max-Suppression. Defaults to 100.
* @param[in] dequantize_scores (Optional) If the scores need to be dequantized. Defaults to true.
*/
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)
: _max_detections(max_detections),
_max_classes_per_detection(max_classes_per_detection),
_nms_score_threshold(nms_score_threshold),
_iou_threshold(iou_threshold),
_num_classes(num_classes),
_scales_values(scales_values),
_use_regular_nms(use_regular_nms),
_detection_per_class(detection_per_class),
_dequantize_scores(dequantize_scores)
{
}
/** Get max detections. */
unsigned int max_detections() const
{
return _max_detections;
}
/** Get max_classes per detection. Used in the Fast Non-Max-Suppression.*/
unsigned int max_classes_per_detection() const
{
return _max_classes_per_detection;
}
/** Get detection per class. Used in the Regular Non-Max-Suppression */
unsigned int detection_per_class() const
{
return _detection_per_class;
}
/** Get nms threshold. */
float nms_score_threshold() const
{
return _nms_score_threshold;
}
/** Get intersection over union threshold. */
float iou_threshold() const
{
return _iou_threshold;
}
/** Get num classes. */
unsigned int num_classes() const
{
return _num_classes;
}
/** Get if use regular nms. */
bool use_regular_nms() const
{
return _use_regular_nms;
}
/** Get y scale value. */
float scale_value_y() const
{
// Saved as [y,x,h,w]
return _scales_values[0];
}
/** Get x scale value. */
float scale_value_x() const
{
// Saved as [y,x,h,w]
return _scales_values[1];
}
/** Get h scale value. */
float scale_value_h() const
{
// Saved as [y,x,h,w]
return _scales_values[2];
}
/** Get w scale value. */
float scale_value_w() const
{
// Saved as [y,x,h,w]
return _scales_values[3];
}
/** Get dequantize_scores value. */
bool dequantize_scores() const
{
return _dequantize_scores;
}
private:
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;
unsigned int _detection_per_class;
bool _dequantize_scores;
};
/** Pooling Layer Information struct*/
struct PoolingLayerInfo
{
/** Default Constructor */
PoolingLayerInfo()
: pool_type(PoolingType::MAX),
pool_size(Size2D()),
data_layout(DataLayout::UNKNOWN),
pad_stride_info(PadStrideInfo()),
exclude_padding(false),
is_global_pooling(false),
fp_mixed_precision(false),
use_inf_as_limit(true),
use_kernel_indices(false)
{
}
/** Constructor
*
* @param[in] pool_type Pooling type @ref PoolingType.
* @param[in] pool_size Pooling size, in elements, across x and y.
* @param[in] data_layout Data layout used by the layer @ref DataLayout
* @param[in] pad_stride_info (Optional) Padding and stride information @ref PadStrideInfo
* @param[in] exclude_padding (Optional) Strategy when accounting padding in calculations.
* True will exclude padding while false will not (Used in AVG/L2 pooling to determine the pooling area).
* Defaults to false;
* @param[in] fp_mixed_precision (Optional) Use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy.
* @param[in] use_inf_as_limit (Optional) Use inf to represent the limits of datatypes range, instead of using "lowest" property of the data type.
* @param[in] use_kernel_indices (Optional) Use kernel indices instead of using source indices while computing indices tensor.
*/
explicit 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,
bool use_inf_as_limit = true,
bool use_kernel_indices = false)
: pool_type(pool_type),
pool_size(Size2D(pool_size, pool_size)),
data_layout(data_layout),
pad_stride_info(pad_stride_info),
exclude_padding(exclude_padding),
is_global_pooling(false),
fp_mixed_precision(fp_mixed_precision),
use_inf_as_limit(use_inf_as_limit),
use_kernel_indices(use_kernel_indices)
{
}
/** Constructor
*
* @param[in] pool_type Pooling type @ref PoolingType.
* @param[in] pool_size Pooling size, in elements, across x and y.
* @param[in] data_layout Data layout used by the layer @ref DataLayout
* @param[in] pad_stride_info (Optional) Padding and stride information @ref PadStrideInfo
* @param[in] exclude_padding (Optional) Strategy when accounting padding in calculations.
* True will exclude padding while false will not (Used in AVG/L2 pooling to determine the pooling area).
* Defaults to false;
* @param[in] fp_mixed_precision (Optional) Use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy.
* @param[in] use_inf_as_limit (Optional) Use inf to represent the limits of datatypes range, instead of using "lowest" property of the data type.
* @param[in] use_kernel_indices (Optional) Use kernel indices instead of using source indices while computing indices tensor.
*/
explicit PoolingLayerInfo(PoolingType pool_type,
Size2D pool_size,
DataLayout data_layout,
PadStrideInfo pad_stride_info = PadStrideInfo(),
bool exclude_padding = false,
bool fp_mixed_precision = false,
bool use_inf_as_limit = true,
bool use_kernel_indices = false)
: pool_type(pool_type),
pool_size(pool_size),
data_layout(data_layout),
pad_stride_info(pad_stride_info),
exclude_padding(exclude_padding),
is_global_pooling(false),
fp_mixed_precision(fp_mixed_precision),
use_inf_as_limit(use_inf_as_limit),
use_kernel_indices(use_kernel_indices)
{
}
/** Constructor
*
* @note This constructor is used for global pooling
*
* @param[in] pool_type Pooling type @ref PoolingType.
* @param[in] data_layout Data layout used by the layer @ref DataLayout
*/
explicit PoolingLayerInfo(PoolingType pool_type, DataLayout data_layout)
: pool_type(pool_type),
pool_size(Size2D()),
data_layout(data_layout),
pad_stride_info(PadStrideInfo(1, 1, 0, 0)),
exclude_padding(false),
is_global_pooling(true),
fp_mixed_precision(false),
use_inf_as_limit(true),
use_kernel_indices(false)
{
}
PoolingType pool_type;
Size2D pool_size;
DataLayout data_layout;
PadStrideInfo pad_stride_info;
bool exclude_padding;
bool is_global_pooling;
bool fp_mixed_precision;
bool use_inf_as_limit;
bool use_kernel_indices;
};
/** Pooling Layer Information struct*/
struct Pooling3dLayerInfo
{
/** Default Constructor */
Pooling3dLayerInfo() noexcept
: pool_type(PoolingType::MAX),
pool_size(Size3D()),
stride(Size3D()),
padding(Padding3D()),
exclude_padding(false),
is_global_pooling(false),
fp_mixed_precision(false),
round_type(DimensionRoundingType::FLOOR)
{
}
/** Constructor
*
* @param[in] pool_type Pooling type @ref PoolingType.
* @param[in] pool_size Pooling size, in elements, across x, y and z.
* @param[in] stride (Optional) stride information @ref Size3D
* @param[in] padding (Optional) padding information @ref Padding3D
* @param[in] exclude_padding (Optional) Strategy when accounting padding in calculations.
* True will exclude padding while false will not (Used in AVG/L2 pooling to determine the pooling area).
* Defaults to false;
* @param[in] fp_mixed_precision (Optional) Use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy.
* @param[in] round_type (Optional) Dimensions rounding. Defaults to @ref DimensionRoundingType::FLOOR
*/
explicit Pooling3dLayerInfo(PoolingType pool_type,
unsigned int pool_size,
Size3D stride = Size3D(1U, 1U, 1U),
Padding3D padding = Padding3D(),
bool exclude_padding = false,
bool fp_mixed_precision = false,
DimensionRoundingType round_type = DimensionRoundingType::FLOOR)
: pool_type(pool_type),
pool_size(Size3D(pool_size, pool_size, pool_size)),
stride(stride),
padding(padding),
exclude_padding(exclude_padding),
is_global_pooling(false),
fp_mixed_precision(fp_mixed_precision),
round_type(round_type)
{
}
/** Constructor
*
* @param[in] pool_type Pooling type @ref PoolingType.
* @param[in] pool_size Pooling size, in elements, across x, y and z.
* @param[in] stride (Optional) stride information @ref Size3D
* @param[in] padding (Optional) padding information @ref Padding3D
* @param[in] exclude_padding (Optional) Strategy when accounting padding in calculations.
* True will exclude padding while false will not (Used in AVG/L2 pooling to determine the pooling area).
* Defaults to false;
* @param[in] fp_mixed_precision (Optional) Use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy.
* @param[in] round_type (Optional) Dimensions rounding. Defaults to @ref DimensionRoundingType::FLOOR
*/
explicit Pooling3dLayerInfo(PoolingType pool_type,
Size3D pool_size,
Size3D stride = Size3D(1U, 1U, 1U),
Padding3D padding = Padding3D(),
bool exclude_padding = false,
bool fp_mixed_precision = false,
DimensionRoundingType round_type = DimensionRoundingType::FLOOR)
: pool_type(pool_type),
pool_size(pool_size),
stride(stride),
padding(padding),
exclude_padding(exclude_padding),
is_global_pooling(false),
fp_mixed_precision(fp_mixed_precision),
round_type(round_type)
{
}
/** Constructor
*
* @note This constructor is used for global pooling
*
* @param[in] pool_type Pooling type @ref PoolingType.
*/
explicit Pooling3dLayerInfo(PoolingType pool_type)
: pool_type(pool_type),
pool_size(Size3D()),
stride(Size3D(1U, 1U, 1U)),
padding(Padding3D(0, 0, 0)),
exclude_padding(false),
is_global_pooling(true),
fp_mixed_precision(false),
round_type(DimensionRoundingType::FLOOR)
{
}
PoolingType pool_type;
Size3D pool_size;
Size3D stride;
Padding3D padding;
bool exclude_padding;
bool is_global_pooling;
bool fp_mixed_precision;
DimensionRoundingType round_type;
};
/** ROI Pooling Layer Information class */
class ROIPoolingLayerInfo final
{
public:
/** Constructor
*
* @param[in] pooled_width Pooled width of the layer.
* @param[in] pooled_height Pooled height of the layer.
* @param[in] spatial_scale Spatial scale to be applied to the ROI coordinates and dimensions.
* @param[in] sampling_ratio Number of samples to include in each pooling region (if set to zero, a ceil(roi_dims/pooling_dims))
*/
ROIPoolingLayerInfo(unsigned int pooled_width,
unsigned int pooled_height,
float spatial_scale,
unsigned int sampling_ratio = 0)
: _pooled_width(pooled_width),
_pooled_height(pooled_height),
_spatial_scale(spatial_scale),
_sampling_ratio(sampling_ratio)
{
}
/** Get the pooled width of the layer */
unsigned int pooled_width() const
{
return _pooled_width;
}
/** Get the pooled height of the layer */
unsigned int pooled_height() const
{
return _pooled_height;
}
/** Get the spatial scale */
float spatial_scale() const
{
return _spatial_scale;
}
/** Get sampling ratio */
unsigned int sampling_ratio() const
{
return _sampling_ratio;
}
private:
unsigned int _pooled_width;
unsigned int _pooled_height;
float _spatial_scale;
unsigned int _sampling_ratio;
};
/** Generate Proposals Information class */
class GenerateProposalsInfo
{
public:
/** Constructor
*
* @param[in] im_width Width of the original image
* @param[in] im_height Height of the original image
* @param[in] im_scale Scale applied to the original image
* @param[in] spatial_scale (Optional)Scale applied to the feature map. Defaults to 1.0
* @param[in] pre_nms_topN (Optional)Number of the best scores to be selected from the transformations. Defaults to 6000.
* @param[in] post_nms_topN (Optional)Number of the best scores to be selected from the NMS operation. Defaults to 300.
* @param[in] nms_thres (Optional)NMS overlap threshold. Defaults to 0.7.
* @param[in] min_size (Optional)Size used to validate the anchors produced. Defaults to 16.
* @param[in] values_per_roi (Optional)Values used to represent a ROI(Region of interest). Defaults to 4.
*/
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)
: _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),
_min_size(min_size),
_values_per_roi(values_per_roi)
{
}
/* Get the original height */
float im_height() const
{
return _im_height;
}
/* Get the original width */
float im_width() const
{
return _im_width;
}
/* Get the image scale */
float im_scale() const
{
return _im_scale;
}
/* Get the value of how many best scores to select (before NMS) */
int pre_nms_topN() const
{
return _pre_nms_topN;
}
/* Get the value of how many best scores to select (after NMS) */
int post_nms_topN() const
{
return _post_nms_topN;
}
/* Get the NMS overlap threshold */
float nms_thres() const
{
return _nms_thres;
}
/* Get the minimal size */
float min_size() const
{
return _min_size;
}
/* Get the spatial scale to be applied to the feature maps */
float spatial_scale() const
{
return _spatial_scale;
}
/* Get the values used to represent a ROI(Region of interest)*/
size_t values_per_roi() const
{
return _values_per_roi;
}
private:
float _im_height;
float _im_width;
float _im_scale;
float _spatial_scale;
int _pre_nms_topN;
int _post_nms_topN;
float _nms_thres;
float _min_size;
size_t _values_per_roi;
};
/** ComputeAnchors information class */
class ComputeAnchorsInfo
{
public:
/** Constructor
*
* @param[in] feat_width Feature map width
* @param[in] feat_height Feature map height
* @param[in] spatial_scale Feature map scale
* @param[in] values_per_roi (Optional)Values used to represent a ROI(Region Of Interest). Defaults to 4
*/
ComputeAnchorsInfo(float feat_width, float feat_height, float spatial_scale, size_t values_per_roi = 4)
: _feat_height(feat_height),
_feat_width(feat_width),
_spatial_scale(spatial_scale),
_values_per_roi(values_per_roi)
{
}
/* Get the height of the feature map */
float feat_height() const
{
return _feat_height;
}
/* Get the width of the feature map */
float feat_width() const
{
return _feat_width;
}
/* Get the scale of the feature map */
float spatial_scale() const
{
return _spatial_scale;
}
/* Get the values used to represent a ROI(Region Of Interest)*/
size_t values_per_roi() const
{
return _values_per_roi;
}
private:
float _feat_height;
float _feat_width;
float _spatial_scale;
size_t _values_per_roi;
};
/** Bounding Box Transform information class */
class BoundingBoxTransformInfo final
{
public:
/** Constructor
*
* @param[in] img_width Width of the original image
* @param[in] img_height Height, of the original image
* @param[in] scale Scale of the original image
* @param[in] apply_scale (Optional)Re-apply scaling after transforming the boxes. Defaults to false
* @param[in] weights (Optional)Weights [wx, wy, ww, wh] for the deltas. Defaults to all ones
* @param[in] correct_transform_coords (Optional)Correct bounding box transform coordinates. Defaults to false
* @param[in] bbox_xform_clip (Optional)Minimum bounding box width and height after bounding box transformation in log-space. Defaults to log(1000/16)
*/
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)
: _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)
{
}
std::array<float, 4> weights() const
{
return _weights;
}
float bbox_xform_clip() const
{
return _bbox_xform_clip;
}
float img_height() const
{
return _img_height;
}
float img_width() const
{
return _img_width;
}
float scale() const
{
return _scale;
}
bool apply_scale() const
{
return _apply_scale;
}
bool correct_transform_coords() const
{
return _correct_transform_coords;
}
private:
float _img_width;
float _img_height;
float _scale;
bool _apply_scale;
bool _correct_transform_coords;
std::array<float, 4> _weights;
float _bbox_xform_clip;
};
/** Normalization Layer Information class */
class NormalizationLayerInfo
{
public:
/** Default Constructor
*
* @param[in] type The normalization type. Can be @ref NormType::IN_MAP_1D, @ref NormType::IN_MAP_2D or @ref NormType::CROSS_MAP
* @param[in] norm_size The normalization size is the number of elements to normalize across. Defaults to 5.
* @param[in] alpha (Optional) Alpha parameter used by normalization equation. Defaults to 0.0001.
* @param[in] beta (Optional) Beta parameter used by normalization equation. Defaults to 0.5.
* @param[in] kappa (Optional) Kappa parameter used by [Krichevksy 2012] Across Channel Local Brightness Normalization equation.
* @param[in] is_scaled (Optional) Boolean that specifies if alpha will be scaled by the normalization size or not.
* Should be false to follow [Krichevksy 2012].
*/
NormalizationLayerInfo(NormType type,
uint32_t norm_size = 5,
float alpha = 0.0001f,
float beta = 0.5f,
float kappa = 1.f,
bool is_scaled = true)
: _type(type), _norm_size(norm_size), _alpha(alpha), _beta(beta), _kappa(kappa), _is_scaled(is_scaled)
{
}
/** Get the normalization type */
NormType type() const
{
return _type;
}
/** Get the normalization size */
uint32_t norm_size() const
{
return _norm_size;
}
/** Get the alpha value */
float alpha() const
{
return _alpha;
}
/** Get the beta value */
float beta() const
{
return _beta;
}
/** Get the kappa value */
float kappa() const
{
return _kappa;
}
/** Get the is_scaled value */
bool is_scaled() const
{
return _is_scaled;
}
/** Check if normalization is cross map */
bool is_cross_map() const
{
return _type == NormType::CROSS_MAP;
}
/** Check if normalization is not cross map */
bool is_in_map() const
{
return !is_cross_map();
}
/** Return the scaling factor of the normalization function.
*
* If is_scaled is set to false then [Krichevksy 2012] normalization scaling is performed,
* where alpha is returned plainly, else alpha is scaled by the total number of elements used for the normalization.
*
* @return The normalization scaling factor.
*/
float scale_coeff() const
{
const uint32_t size = (_type == NormType::IN_MAP_2D) ? _norm_size * _norm_size : _norm_size;
return (_is_scaled) ? (_alpha / size) : _alpha;
}
private:
NormType _type;
uint32_t _norm_size;
float _alpha;
float _beta;
float _kappa;
bool _is_scaled;
};
class StridedSliceLayerInfo
{
public:
/** Default Constructor
*
* @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.
* @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.
* @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.
*/
StridedSliceLayerInfo(int32_t begin_mask = 0, int32_t end_mask = 0, int32_t shrink_axis_mask = 0)
: _begin_mask(begin_mask), _end_mask(end_mask), _shrink_axis_mask(shrink_axis_mask)
{
}
/* Get the begin mask value */
int32_t begin_mask() const
{
return _begin_mask;
}
/* Get the end mask value */
int32_t end_mask() const
{
return _end_mask;
}
/* Get the shrink axis mask value */
int32_t shrink_axis_mask() const
{
return _shrink_axis_mask;
}
private:
int32_t _begin_mask;
int32_t _end_mask;
int32_t _shrink_axis_mask;
};
// OHWIo<interleave_by>i<block_by>
inline int interleave_by(const WeightFormat wf)
{
return (static_cast<int>(wf) >> 8) & 0xFFF;
}
inline int block_by(const WeightFormat wf)
{
return (static_cast<int>(wf) >> 20) & 0xF;
}
inline bool is_fixed_format(const WeightFormat &wf)
{
return wf != WeightFormat::UNSPECIFIED && wf != WeightFormat::ANY;
}
inline bool is_fixed_format_fast_math(const WeightFormat &wf)
{
return (static_cast<int>(wf) >> 4) & 0x1;
}
/** Convolution Layer Weights Information class. This class stores the necessary information to compute convolution layer when the weights are already reshaped */
class WeightsInfo
{
public:
/** Default constructor */
WeightsInfo()
: _are_reshaped(false),
_kernel_width(0),
_kernel_height(0),
_num_kernels(0),
_retain_internal_weights(false),
_weight_format(arm_compute::WeightFormat::UNSPECIFIED)
{
}
/** Constructor
*
* @param[in] are_reshaped True if the weights have been reshaped
* @param[in] kernel_width Kernel width.
* @param[in] kernel_height Kernel height.
* @param[in] num_kernels Number of convolution kernels.
* @param[in] retain_internal_weights (Optional) True if internal reshaped weights must be retained. Used for reconfiguration purposes. Default is false.
* @param[in] weight_format (Optional) arm_gemm:WeightFormat enumeration requested by the user. Default is arm_compute::WeightFormat::UNSPECIFIED.
*/
WeightsInfo(bool are_reshaped,
unsigned int kernel_width,
unsigned int kernel_height,
unsigned int num_kernels,
bool retain_internal_weights = false,
arm_compute::WeightFormat weight_format = arm_compute::WeightFormat::UNSPECIFIED)
: _are_reshaped(are_reshaped),
_kernel_width(kernel_width),
_kernel_height(kernel_height),
_num_kernels(num_kernels),
_retain_internal_weights(retain_internal_weights),
_weight_format(weight_format)
{
}
/** Flag which specifies if the weights tensor has been reshaped.
*
* @return True if the weights tensors has been reshaped
*/
bool are_reshaped() const
{
return _are_reshaped;
};
/** Return the number of convolution kernels
*
* @return The number of convolution kernels
*/
unsigned int num_kernels() const
{
return _num_kernels;
};
/** Return the width and height of the kernel
*
* @return The width and height of the kernel
*/
std::pair<unsigned int, unsigned int> kernel_size() const
{
return std::make_pair(_kernel_width, _kernel_height);
}
bool retain_internal_weights() const
{
return _retain_internal_weights;
}
arm_compute::WeightFormat weight_format() const
{
return _weight_format;
}
void set_weight_format(arm_compute::WeightFormat weight_format)
{
_weight_format = weight_format;
}
unsigned int kernel_width() const
{
return _kernel_width;
}
unsigned int kernel_height() const
{
return _kernel_height;
}
private:
bool _are_reshaped;
unsigned int _kernel_width;
unsigned int _kernel_height;
unsigned int _num_kernels;
bool _retain_internal_weights;
arm_compute::WeightFormat _weight_format;
};
/** GEMM reshape information class. This class stores the necessary information about matrix A and matrix B reshape.
*
* The matrix A can only be reshaped through @ref opencl::kernels::ClGemmReshapeLhsMatrixKernel or @ref cpu::kernels::CpuGemmInterleave4x4Kernel
* Note: Optionally just for @ref opencl::kernels::ClGemmReshapeLhsMatrixKernel is it possible to set mult_interleave4x4_height, the multiplication factor for the height of the 4x4 interleaved block
*
* The matrix B can only be reshaped through @ref opencl::kernels::ClGemmReshapeRhsMatrixKernel or @ref cpu::kernels::CpuGemmTranspose1xWKernel
* Note: Optionally just for @ref opencl::kernels::ClGemmReshapeRhsMatrixKernel is it possible to set mult_transpose1xW_width, the multiplication factor for the width of the 1xW transposed block
*
*/
class GEMMReshapeInfo final
{
public:
/** Default constructor */
GEMMReshapeInfo()
: _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)
{
}
/** Constructor
*
* @param[in] m Number of matrix A rows
* @param[in] n Number of matrix B columns
* @param[in] k Number of matrix A columns or matrix B rows
* @param[in] mult_transpose1xW_width (Optional) Multiplication factor for the width of the 1xW transposed block
* @param[in] mult_interleave4x4_height (Optional) Multiplication factor for the height of the 4x4 interleaved block
* @param[in] depth_output_gemm3d (Optional) Depth (third dimension) of the output tensor to be used with the GEMM3D kernel.
* If 0 the output will not be reinterpreted as 3D. Default 0
* @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
* to perform 1x1 convolutions with the NHWC data layout)
* @param[in] broadcast_bias (Optional) Broadcast the shape of the bias tensor from a vector to a matrix.
*/
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)
: _m(m),
_n(n),
_k(k),
_mult_transpose1xW_width(mult_transpose1xW_width),
_mult_interleave4x4_height(mult_interleave4x4_height),
_depth_output_gemm3d(depth_output_gemm3d),
_reinterpret_input_as_3d(reinterpret_input_as_3d),
_broadcast_bias(broadcast_bias)
{
}
/** Number of matrix A rows
*
* @return the number of matrix A rows
*/
int m() const
{
return _m;
}
/** Number of matrix B columns
*
* @return the number of matrix B columns
*/
int n() const
{
return _n;
}
/** Number of matrix A columns or matrix B rows
*
* @return the number of matrix A columns or matrix B rows
*/
int k() const
{
return _k;
}
/** Multiplication factor for the width of the 1xW transposed block
*
* @return the multiplication factor for the width of the 1xW transposed block
*/
int mult_transpose1xW_width() const
{
return _mult_transpose1xW_width;
}
/** Multiplication factor for the height of the 4x4 interleaved block
*
* @return the multiplication factor for the height of the 4x4 interleaved block
*/
int mult_interleave4x4_height() const
{
return _mult_interleave4x4_height;
}
/** Depth (third dimension) of the output tensor to be used with the GEMM3D kernel
*
* @note GEMM3D kernel is used when the output has to be reinterpret as 3D tensor. In that case:
* m = depth_output_gemm3d * output_height
*
* @return the depth of the output tensor to be used with the GEMM3D kernel
*/
int depth_output_gemm3d() const
{
return _depth_output_gemm3d;
}
/** Flag which specifies if the input tensor has to be reinterpreted as 3D
*
* @return True if the input tensor has to be reinterpreted as 3D tensor
*/
bool reinterpret_input_as_3d() const
{
return _reinterpret_input_as_3d;
};
/** Flag which specifies whether to broadcast the shape of the bias tensor.
*
* @return True if the shape of the bias tensor is to be broadcasted.
*/
bool broadcast_bias() const
{
return _broadcast_bias;
};
private:
int _m;
int _n;
int _k;
int _mult_transpose1xW_width;
int _mult_interleave4x4_height;
int _depth_output_gemm3d;
bool _reinterpret_input_as_3d;
bool _broadcast_bias;
};
/** GEMM LHS (Left Hand Side) matrix information */
struct GEMMLHSMatrixInfo
{
GEMMLHSMatrixInfo() = default;
GEMMLHSMatrixInfo(unsigned int m, unsigned int k, unsigned int v, bool trans, bool inter)
: m0(m), k0(k), v0(v), transpose(trans), interleave(inter)
{
}
unsigned int m0{1}; /**< Number of rows processed by the matrix multiplication */
unsigned int k0{1}; /**< Number of partial accumulations performed by the matrix multiplication */
unsigned int v0{1}; /**< Number of vertical blocks of size (m0xk0) stored on the same output row */
bool transpose{true}; /**< True if the (m0xk0) block has to be transposed before been stored */
bool interleave{true}; /**< True if the v0 (m0xk0) blocks have to be interleaved in the output row */
};
/** GEMM RHS (Right Hand Side) matrix information */
struct GEMMRHSMatrixInfo
{
GEMMRHSMatrixInfo() = default;
GEMMRHSMatrixInfo(unsigned int n, unsigned int k, unsigned int h, bool trans, bool inter, bool export_to_cl_img)
: n0(n), k0(k), h0(h), transpose(trans), interleave(inter), export_to_cl_image(export_to_cl_img)
{
}
unsigned int n0{1}; /**< Number of columns processed by the matrix multiplication */
unsigned int k0{1}; /**< Number of partial accumulations performed by the matrix multiplication */
unsigned int h0{1}; /**< Number of horizontal blocks of size (k0xn0) stored on the same output row */
bool transpose{true}; /**< True if the (k0xn0) block has to be transposed before been stored */
bool interleave{true}; /**< True if the h0 (k0xn0) blocks have to be interleaved in the output row */
bool export_to_cl_image{
false}; /**< True if the reshaped rhs has to be exported to cl_image. n0 must be equal to 4 */
};
class ITensorInfo;
/** Winograd information */
struct WinogradInfo
{
/** Default constructor
*
* @param[in] output_tile_sz Width and height of the output tile
* @param[in] kernel_sz Width and height of the kernel
* @param[in] input_dims Width and height of the input tensor before the convolution is applied
* @param[in] conv_info Convolution info (Pads, strides)
* @param[in] data_layout Data layout to use for the output tensor once the convolution has been applied
*/
WinogradInfo(
Size2D output_tile_sz, Size2D kernel_sz, Size2D input_dims, PadStrideInfo conv_info, DataLayout data_layout)
: output_tile_size(output_tile_sz),
kernel_size(kernel_sz),
input_dimensions(input_dims),
convolution_info(conv_info),
output_data_layout(data_layout)
{
}
Size2D output_tile_size{}; /**< Width and height of the output tile */
Size2D kernel_size{}; /**< Width and height of the kernel*/
Size2D input_dimensions{}; /**< Width and height of the input tensor before the convolution is applied */
PadStrideInfo convolution_info{}; /**< Convolution info (Pads, strides,...) */
DataLayout output_data_layout{
DataLayout::
NCHW}; /**< Data layout to use for the output tensor once the convolution has been applied (NCHW or NHWC) */
};
/** IO formatting information class*/
struct IOFormatInfo
{
/** Precision type used when printing floating point numbers */
enum class PrecisionType
{
Default, /**< Default precision to the one that the current stream has */
Custom, /**< Custom precision specified by the user using the precision parameter */
Full /**< The maximum precision of the floating point representation */
};
/** Specifies the area to be printed, used by Tensor objects */
enum class PrintRegion
{
ValidRegion, /**< Prints the valid region of the Tensor object */
NoPadding, /**< Prints the Tensor object without the padding */
Full /**< Print the tensor object including padding */
};
/** Construct a set of IO formatting information.
*
* @param[in] print_region Area to be printed. Used by Tensor objects. Default: ValidRegion.
* @param[in] precision_type Precision type for floating point numbers. Default: stream default.
* @param[in] precision Precision value for float point numbers. Default: 10.
* @param[in] align_columns Whether to align columns when printed. Default: true.
* @param[in] element_delim Delimeter between elements. Default: " ".
* @param[in] row_delim Delimenter between rows. Default: "\n".
*/
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 = "\n")
: print_region(print_region),
precision_type(precision_type),
precision(precision),
element_delim(element_delim),
row_delim(row_delim),
align_columns(align_columns)
{
}
/** Area to be printed by Tensor objects */
PrintRegion print_region;
/** Floating point precision type */
PrecisionType precision_type;
/** Floating point precision */
unsigned int precision;
/** Element delimeter */
std::string element_delim;
/** Row delimeter */
std::string row_delim;
/** Align columns */
bool align_columns;
};
/** Class for holding information related to cropping */
using CropInfo = Padding2D;
} // namespace arm_compute
#endif // ACL_ARM_COMPUTE_CORE_TYPES_H