diff options
Diffstat (limited to 'arm_compute/function_info')
| -rw-r--r-- | arm_compute/function_info/ActivationLayerInfo.h | 136 | ||||
| -rw-r--r-- | arm_compute/function_info/ConvolutionInfo.h | 50 | ||||
| -rw-r--r-- | arm_compute/function_info/FullyConnectedLayerInfo.h | 71 | ||||
| -rw-r--r-- | arm_compute/function_info/GEMMInfo.h | 358 | ||||
| -rw-r--r-- | arm_compute/function_info/MatMulInfo.h | 62 | ||||
| -rw-r--r-- | arm_compute/function_info/ScatterInfo.h | 54 |
6 files changed, 731 insertions, 0 deletions
diff --git a/arm_compute/function_info/ActivationLayerInfo.h b/arm_compute/function_info/ActivationLayerInfo.h new file mode 100644 index 0000000000..9390d0c54f --- /dev/null +++ b/arm_compute/function_info/ActivationLayerInfo.h @@ -0,0 +1,136 @@ +/* + * 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_FUNCTION_INFO_ACTIVATIONLAYERINFO_H +#define ACL_ARM_COMPUTE_FUNCTION_INFO_ACTIVATIONLAYERINFO_H + +#include "arm_compute/core/CoreTypes.h" +#include "arm_compute/core/Error.h" +#include "arm_compute/core/QuantizationInfo.h" + +#include <array> +#include <memory> + +#ifdef __aarch64__ +#include <arm_neon.h> +#endif // __arch64__ + +namespace arm_compute +{ +/** Available activation functions */ +enum class ActivationFunction +{ + LOGISTIC, /**< Logistic ( \f$ f(x) = \frac{1}{1 + e^{-x}} \f$ ) */ + TANH, /**< Hyperbolic tangent ( \f$ f(x) = a \cdot tanh(b \cdot x) \f$ ) */ + RELU, /**< Rectifier ( \f$ f(x) = max(0,x) \f$ ) */ + BOUNDED_RELU, /**< Upper Bounded Rectifier ( \f$ f(x) = min(a, max(0,x)) \f$ ) */ + LU_BOUNDED_RELU, /**< Lower and Upper Bounded Rectifier ( \f$ f(x) = min(a, max(b,x)) \f$ ) */ + 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$ ) */ + SOFT_RELU, /**< Soft Rectifier ( \f$ f(x)= log(1+e^x) \f$ ) */ + 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$ ) */ + ABS, /**< Absolute ( \f$ f(x)= |x| \f$ ) */ + SQUARE, /**< Square ( \f$ f(x)= x^2 \f$ )*/ + SQRT, /**< Square root ( \f$ f(x) = \sqrt{x} \f$ )*/ + LINEAR, /**< Linear ( \f$ f(x)= ax + b \f$ ) */ + IDENTITY, /**< Identity ( \f$ f(x)= x \f$ ) */ + HARD_SWISH, /**< Hard-swish ( \f$ f(x) = (x \text{ReLU6}(x+3))/6 = x \min(\max(0,x+3),6)/6 \f$ ) */ + SWISH, /**< Swish ( \f$ f(x) = \frac{x}{1 + e^{-ax}} = x \text{logistic}(ax) \f$ ) */ + GELU /**< GELU ( \f$ f(x) = x * 1/2 * 1 + erf(x / \sqrt{2}) \f$ ) */ +}; +/** Activation Layer Information class */ +class ActivationLayerInfo +{ +public: + typedef arm_compute::ActivationFunction ActivationFunction; + + /** Lookup table */ +#ifdef __aarch64__ + using LookupTable256 = std::array<qasymm8_t, 256>; + using LookupTable65536 = std::array<float16_t, 65536>; +#endif // __aarch64__ + + ActivationLayerInfo() = default; + /** Default Constructor + * + * @param[in] f The activation function to use. + * @param[in] a (Optional) The alpha parameter used by some activation functions + * (@ref ActivationFunction::BOUNDED_RELU, @ref ActivationFunction::LU_BOUNDED_RELU, @ref ActivationFunction::LINEAR, @ref ActivationFunction::TANH). + * @param[in] b (Optional) The beta parameter used by some activation functions (@ref ActivationFunction::LINEAR, @ref ActivationFunction::LU_BOUNDED_RELU, @ref ActivationFunction::TANH). + */ + ActivationLayerInfo(ActivationFunction f, float a = 0.0f, float b = 0.0f) : _act(f), _a(a), _b(b), _enabled(true) + { + } + /** Get the type of activation function */ + ActivationFunction activation() const + { + return _act; + } + /** Get the alpha value */ + float a() const + { + return _a; + } + /** Get the beta value */ + float b() const + { + return _b; + } + /** Check if initialised */ + bool enabled() const + { + return _enabled; + } + +#ifdef __aarch64__ + const LookupTable256 &lut() const + { + return _lut; + } + void setLookupTable256(LookupTable256 &lut) + { + _lut = std::move(lut); + } + + const LookupTable65536 &lut_fp16() const + { + ARM_COMPUTE_ERROR_ON(_lut_fp16 == nullptr); + return *_lut_fp16; + } + void setLookupTable65536(std::shared_ptr<LookupTable65536> lut) + { + _lut_fp16 = lut; + } +#endif // __aarch64__ +private: + ActivationFunction _act = {ActivationLayerInfo::ActivationFunction::IDENTITY}; + float _a = {}; + float _b = {}; + bool _enabled = {false}; + +#ifdef __aarch64__ + LookupTable256 _lut = {}; + std::shared_ptr<LookupTable65536> _lut_fp16{nullptr}; +#endif // __aarch64__ +}; +} // namespace arm_compute +#endif // ACL_ARM_COMPUTE_FUNCTION_INFO_ACTIVATIONLAYERINFO_H diff --git a/arm_compute/function_info/ConvolutionInfo.h b/arm_compute/function_info/ConvolutionInfo.h new file mode 100644 index 0000000000..4830cae137 --- /dev/null +++ b/arm_compute/function_info/ConvolutionInfo.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2016-2023 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_FUNCTION_INFO_CONVOLUTIONINFO +#define ACL_ARM_COMPUTE_FUNCTION_INFO_CONVOLUTIONINFO + +#include "arm_compute/core/CoreTypes.h" +#include "arm_compute/core/Size2D.h" +#include "arm_compute/function_info/ActivationLayerInfo.h" + +namespace arm_compute +{ +struct ConvolutionInfo +{ + ConvolutionInfo() = default; + ConvolutionInfo(const PadStrideInfo &pad_stride_info, + unsigned int depth_multiplier, + const ActivationLayerInfo &act_info, + const Size2D &dilation) + : pad_stride_info(pad_stride_info), depth_multiplier(depth_multiplier), act_info(act_info), dilation(dilation) + { + } + PadStrideInfo pad_stride_info{}; /**< Convolution info (Pads, strides,...) */ + unsigned int depth_multiplier{ + 1}; /**< Multiplier to apply to input's depth to retrieve the output depth. Defaults to 1 */ + ActivationLayerInfo act_info{}; /**< Fused activation to apply after convolution. */ + Size2D dilation{Size2D(1, 1)}; /**< Dilation, in elements, across x and y. Defaults to (1, 1). */ +}; +} // namespace arm_compute +#endif /* ACL_ARM_COMPUTE_FUNCTION_INFO_CONVOLUTIONINFO */ diff --git a/arm_compute/function_info/FullyConnectedLayerInfo.h b/arm_compute/function_info/FullyConnectedLayerInfo.h new file mode 100644 index 0000000000..e65daeb2d4 --- /dev/null +++ b/arm_compute/function_info/FullyConnectedLayerInfo.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2016-2023 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_FUNCTION_INFO_FULLYCONNECTEDLAYERINFO +#define ACL_ARM_COMPUTE_FUNCTION_INFO_FULLYCONNECTEDLAYERINFO + +#include "arm_compute/core/CoreTypes.h" +#include "arm_compute/function_info/ActivationLayerInfo.h" + +namespace arm_compute +{ +/** Fully connected layer info */ +struct FullyConnectedLayerInfo +{ + /* Fused-activation parameters */ + ActivationLayerInfo activation_info{}; /**< Fused activation to apply after the matrix multiplication. */ + /* Information about weights */ + DataLayout weights_trained_layout{DataLayout::NCHW}; /**< Layout that the weights have been trained with. */ + bool transpose_weights{true}; /**< Transpose weights if true. */ + bool are_weights_reshaped{false}; /**< @deprecated Reshape the weights tensor if false. */ + bool retain_internal_weights{false}; /**< Retain internal reshaped weights. */ + bool enable_fast_math{false}; /**< Enable fast math computation. */ + /* Other parameters */ + bool fp_mixed_precision{false}; /**< Use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy. */ + + /** Sets the weights trained data layout + * + * @param[in] layout Data layout that the weights were trained with + * + * @return Updated object + */ + FullyConnectedLayerInfo &set_weights_trained_layout(DataLayout layout) + { + weights_trained_layout = layout; + return *this; + } + /** Sets the transpose weights flag + * + * @param[in] should_transpose_weights Boolean flag indicating if weights should be transposed + * + * @return Updated object + */ + FullyConnectedLayerInfo &set_transpose_weights(bool should_transpose_weights) + { + transpose_weights = should_transpose_weights; + return *this; + } +}; + +} // namespace arm_compute +#endif /* ACL_ARM_COMPUTE_FUNCTION_INFO_FULLYCONNECTEDLAYERINFO */ diff --git a/arm_compute/function_info/GEMMInfo.h b/arm_compute/function_info/GEMMInfo.h new file mode 100644 index 0000000000..74fe30454e --- /dev/null +++ b/arm_compute/function_info/GEMMInfo.h @@ -0,0 +1,358 @@ +/* + * 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_FUNCTION_INFO_GEMMINFO_H +#define ACL_ARM_COMPUTE_FUNCTION_INFO_GEMMINFO_H + +#include "arm_compute/core/CoreTypes.h" +#include "arm_compute/function_info/ActivationLayerInfo.h" + +#include <vector> + +namespace arm_compute +{ +class ITensorInfo; +/** GEMMLowp output stage type */ +enum class GEMMLowpOutputStageType +{ + NONE, /**< No quantization */ + QUANTIZE_DOWN, /**< Quantize using an integer multiplication */ + QUANTIZE_DOWN_FIXEDPOINT, /**< Quantize using a fixed point multiplication */ + QUANTIZE_DOWN_FLOAT /**< Quantize using a floating point multiplication */ +}; + +/** GEMMLowp output stage info */ +struct GEMMLowpOutputStageInfo +{ + GEMMLowpOutputStageType type{GEMMLowpOutputStageType::NONE}; /**< GEMMLowp output stage type */ + int32_t gemmlowp_offset{0}; /**< GEMMLowp output stage offset used for quantizing to QASYMM8 */ + int32_t gemmlowp_multiplier{0}; /**< GEMMLowp output stage multiplier used for quantizing to QASYMM8 */ + int32_t gemmlowp_shift{0}; /**< GEMMLowp output stage shift used for quantizing to uint8 */ + 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 */ + 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 */ + std::vector<int32_t> gemmlowp_multipliers{}; /**< GEMMLowp output stage multiplier used for quantizing to QASYMM8 */ + std::vector<int32_t> gemmlowp_shifts{}; /**< GEMMLowp output stage multiplier used for quantizing to QASYMM8 */ + float gemmlowp_real_multiplier{0}; /**< GEMMLowp output stage real multiplier used for quantizing to QASYMM8 */ + bool is_quantized_per_channel{false}; /**< GEMMLowp quantized per-channel flag */ + DataType output_data_type{ + DataType::UNKNOWN}; /**< Output tensor data type to use if the output is not initialized */ +}; +/** GEMM information class. This class stores the necessary information to compute GEMM functions + * + * This object also contains the information about how matrix A and matrix B have been reshaped + * + */ +class GEMMInfo +{ +public: + /** Default constructor */ + GEMMInfo() noexcept + : _is_a_reshaped(false), + _is_b_reshaped(false), + _reshape_b_only_on_first_run(true), + _depth_output_gemm3d(0), + _reinterpret_input_as_3d(false), + _retain_internal_weights(false), + _gemmlowp_output_stage(), + _fast_math(false), + _fp_mixed_precision(false), + _broadcast_bias(false), + _pretranspose_A(false), + _pretranspose_B(false), + _activation_info(), + _fixed_format(false), + _weight_format(arm_compute::WeightFormat::UNSPECIFIED), + _accumulate(false) + { + } + /** Constructor + * + * @param[in] is_a_reshaped True if the matrix A has been reshaped + * @param[in] is_b_reshaped True if the matrix B has been reshaped + * @param[in] reshape_b_only_on_first_run Reshape matrix B only for the first run + * @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] retain_internal_weights (Optional) Retain the weights tensor from previous run + * @param[in] gemmlowp_output_stage (Optional) GEMMLowp Output stage info + * @param[in] fp_mixed_precision (Optional) Use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy. + * @param[in] fast_math (Optional) Use a data type of shorter width to improve performance + * @param[in] broadcast_bias (Optional) Broadcast the shape of the bias tensor from a vector to a matrix. + * @param[in] activation_info (Optional) Activation to apply after the matrix multiplication + * @param[in] fixed_format (Optional) Specify the selection of fixed format kernels for variable weights support in GEMM. These kernels expect the weights tensor to be in amemory format that is fixed by the kernel itself. For more information, see arm_compute::WeightFormat. + * @param[in] weight_format (Optional) arm_gemm:WeightFormat enumeration requested by the user. Default is arm_compute::WeightFormat::UNSPECIFIED. + * @param[in] pretranspose_B (Optional) Pretranspose matrix B (transposition of its lowest 2 dimensions), in addition to and before, any further transformations of B + * @param[in] accumulate (Optional) Whether to accumulate in destination or not + */ + 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 fast_math = false, + bool broadcast_bias = false, + const ActivationLayerInfo &activation_info = ActivationLayerInfo(), + bool fixed_format = false, + arm_compute::WeightFormat weight_format = arm_compute::WeightFormat::UNSPECIFIED, + bool pretranspose_B = false, + bool accumulate = false) noexcept + : _is_a_reshaped(is_a_reshaped), + _is_b_reshaped(is_b_reshaped), + _reshape_b_only_on_first_run(reshape_b_only_on_first_run), + _depth_output_gemm3d(depth_output_gemm3d), + _reinterpret_input_as_3d(reinterpret_input_as_3d), + _retain_internal_weights(retain_internal_weights), + _gemmlowp_output_stage(gemmlowp_output_stage), + _fast_math(fast_math), + _fp_mixed_precision(fp_mixed_precision), + _broadcast_bias(broadcast_bias), + _pretranspose_A(false), + _pretranspose_B(pretranspose_B), + _activation_info(activation_info), + _fixed_format(fixed_format), + _weight_format(weight_format), + _accumulate(accumulate) + { + } + /** Flag which specifies if the matrix A has been reshaped + * + * @return True if the matrix A has been reshaped + */ + bool is_a_reshaped() const + { + return _is_a_reshaped; + }; + /** Flag which specifies if the matrix B has been reshaped + * + * @return True if the matrix B has been reshaped + */ + bool is_b_reshaped() const + { + return _is_b_reshaped; + }; + /** Flag which specifies if the reshape of matrix B should executed only for the first + * + * @note This flag could be set to TRUE when GEMM is used to accelerate convolution layer + * + * @return True if the reshaped of matrix B happens only for the first run + */ + bool reshape_b_only_on_first_run() const + { + return _reshape_b_only_on_first_run; + }; + /** Depth of the output when GEMM output is reinterpreted as 3D tensor + * + * @return the depth of the output tensor + */ + 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 if the weights tensor has to be retained from previous run + * + * @return True if the weights tensor has to be retained + */ + bool retain_internal_weights() const + { + return _retain_internal_weights; + }; + /** GEMMLowp output stage + * + * @return the GEMMLowp output stage info + */ + GEMMLowpOutputStageInfo gemmlowp_output_stage() const + { + return _gemmlowp_output_stage; + }; + /** Sets GEMMLowp output stage + * + * @param[in] output_stage Output stage to set + */ + void set_gemmlowp_output_stage(GEMMLowpOutputStageInfo &output_stage) + { + _gemmlowp_output_stage = output_stage; + }; + /** Flag which specifies if a wider accumulator should be used. + * + * @return True if a wider accumulator has to be used + */ + bool fp_mixed_precision() const + { + return _fp_mixed_precision; + }; + /** Flag which specifies if a shorter accumulator to be used. + * + * @return True if a shorter accumulator has to be used + */ + bool fast_math() const + { + return _fast_math; + }; + /** Set fast math flag + * + * @param[in] fast_math Flag to set + */ + void set_fast_math(bool fast_math) + { + _fast_math = fast_math; + } + /** 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; + }; + /** Flag which specifies whether A should be pre-transposed if supported. + * + * @return True if A should be pre-transposed else false. + */ + bool pretranspose_A() const + { + return _pretranspose_A; + }; + /** Set pre-transpose A flag + * + * @param[in] flag Flag to set + */ + void set_pretranspose_A(bool flag) + { + _pretranspose_A = flag; + } + /** Flag which specifies whether b should be pre-transposed if supported. + * More concretely, the "pre-transpose" is the transposition of the b tensor's lowest 2 dimensions + * If specified true, this pre-transpose will occur in addition to and before, any further transformations of the b matrix + * + * @return True if b should be pre-transposed else false. + */ + bool pretranspose_B() const + { + return _pretranspose_B; + }; + /** Set pre-transpose b flag + * + * @param[in] flag Flag to set + */ + void set_pretranspose_B(bool flag) + { + _pretranspose_B = flag; + } + /** Activation layer to apply after the matrix multiplication + * + * @return ActivationLayerInfo object + */ + ActivationLayerInfo activation_info() const + { + return _activation_info; + } + /** Set activation layer info + * + * @param[in] activation_info ActivationLayerInfo object to set + */ + void set_activation_info(const ActivationLayerInfo &activation_info) + { + _activation_info = activation_info; + } + /** Flag which specifies if the GEMM operation is running fixed-format kernels. + * + * @return True if the GEMM operation is running fixed-format kernel else false. + */ + bool fixed_format() const + { + return _fixed_format; + } + /** Flag which specifies if GEMM should accumulate the result in destination or not. + * + * @return True if GEMM is accumulating the result. + */ + bool accumulate() const + { + return _accumulate; + } + /** Set fixed-format flag + * + * @param[in] fixed_format sets whether or not to use fixed-format kernels + */ + void set_fixed_format(bool fixed_format) + { + _fixed_format = fixed_format; + } + /** Set accumulate flag + * + * @param[in] accumulate sets whether or not to use accumulation + */ + void set_accumulate(bool accumulate) + { + _accumulate = accumulate; + } + + arm_compute::WeightFormat weight_format() const + { + return _weight_format; + } + /** Set weight format to be used + * + * @param[in] weight_format arm_compute::WeightFormat enumeration + */ + void set_weight_format(arm_compute::WeightFormat weight_format) + { + _weight_format = weight_format; + } + +private: + bool _is_a_reshaped; + bool _is_b_reshaped; + bool _reshape_b_only_on_first_run; + int _depth_output_gemm3d; + bool _reinterpret_input_as_3d; + bool _retain_internal_weights; + GEMMLowpOutputStageInfo _gemmlowp_output_stage; + bool _fast_math; + bool _fp_mixed_precision; + bool _broadcast_bias; + bool _pretranspose_A; + bool _pretranspose_B; + ActivationLayerInfo _activation_info; + bool _fixed_format; + arm_compute::WeightFormat _weight_format; + bool _accumulate; +}; +} //namespace arm_compute +#endif // ACL_ARM_COMPUTE_FUNCTION_INFO_GEMMINFO_H diff --git a/arm_compute/function_info/MatMulInfo.h b/arm_compute/function_info/MatMulInfo.h new file mode 100644 index 0000000000..fc73efb44a --- /dev/null +++ b/arm_compute/function_info/MatMulInfo.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2016-2023 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_FUNCTION_INFO_MATMULINFO +#define ACL_ARM_COMPUTE_FUNCTION_INFO_MATMULINFO + +namespace arm_compute +{ +/** Class for holding information related to matrix multiplication function + */ +class MatMulInfo +{ +public: + /* Get Adjoint LHS flag value */ + bool adj_lhs() const + { + return _adj_lhs; + } + /* Get Adjoint RHS flag value */ + bool adj_rhs() const + { + return _adj_rhs; + } + /* Set Adjoint LHS flag */ + MatMulInfo &adj_lhs(bool adj_lhs) + { + _adj_lhs = adj_lhs; + return *this; + } + /* Set Adjoint RHS flag */ + MatMulInfo &adj_rhs(bool adj_rhs) + { + _adj_rhs = adj_rhs; + return *this; + } + +private: + bool _adj_lhs{false}; + bool _adj_rhs{false}; +}; +} // namespace arm_compute +#endif /* ACL_ARM_COMPUTE_FUNCTION_INFO_MATMULINFO */ diff --git a/arm_compute/function_info/ScatterInfo.h b/arm_compute/function_info/ScatterInfo.h new file mode 100644 index 0000000000..176a863ac5 --- /dev/null +++ b/arm_compute/function_info/ScatterInfo.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 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_FUNCTION_INFO_SCATTERINFO_H +#define ACL_ARM_COMPUTE_FUNCTION_INFO_SCATTERINFO_H + +#include "arm_compute/core/Error.h" + +namespace arm_compute +{ +/** Scatter Function */ +enum class ScatterFunction +{ + Update = 0, + Add = 1, + Sub = 2, + Max = 3, + Min = 4 +}; +/** Scatter operator information */ +struct ScatterInfo +{ + ScatterInfo(ScatterFunction f, bool zero) : func(f), zero_initialization(zero) + { + ARM_COMPUTE_ERROR_ON_MSG(f != ScatterFunction::Add && zero, + "Zero initialisation is only supported with Add Scatter Function."); + } + ScatterFunction func; /**< Type of scatter function to use with scatter operator*/ + bool zero_initialization{false}; /**< Fill output tensors with 0. Only available with add scatter function. */ +}; +} // namespace arm_compute + +#endif // ACL_ARM_COMPUTE_FUNCTION_INFO_SCATTERINFO_H |