patch/23.02/_descriptors_8hpp_source.xhtml

 //
 // Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 #pragma once

 #include "Deprecated.hpp"
 #include "DescriptorsFwd.hpp" // Required for class equivalence declarations.
 #include "Tensor.hpp"
 #include "Types.hpp"
 #include <armnn/Exceptions.hpp>

 #include <cstdint>
 #include <iterator>
 #include <utility>
 #include <vector>

 namespace armnn
 {

 /// Base class for all descriptors.
 struct BaseDescriptor
 {
     virtual bool IsNull() const { return false; }
     virtual ~BaseDescriptor() = default;
 };

 /// Null Descriptor used as a return value from the IConnectableLayer GetParameters method
 /// by layers which do not have a descriptor
 struct NullDescriptor : BaseDescriptor
 {
     bool IsNull() const override { return true; }
 };

 /// An ActivationDescriptor for the ActivationLayer.
 struct ActivationDescriptor : BaseDescriptor
 {
     ActivationDescriptor()
         : m_Function(ActivationFunction::Sigmoid)
         , m_A(0)
         , m_B(0)
     {}

     ActivationDescriptor(armnn::ActivationFunction activation,
                          float a = 0,
                          float b = 0)
             : m_Function(activation)
             , m_A(a)
             , m_B(b)
     {}

     bool operator ==(const ActivationDescriptor &rhs) const
     {
         return m_Function == rhs.m_Function && m_A == rhs.m_B && m_B == rhs.m_B;
     }

     /// @brief The activation function to use
     /// (Sigmoid, TanH, Linear, ReLu, BoundedReLu, SoftReLu, LeakyReLu, Abs, Sqrt, Square, Elu).
     ActivationFunction m_Function;
     /// Alpha upper bound value used by the activation functions. (BoundedReLu, Linear, TanH, Elu).
     float              m_A;
     /// Beta lower bound value used by the activation functions. (BoundedReLu, Linear, TanH).
     float              m_B;
 };

 /// An ArgMinMaxDescriptor for ArgMinMaxLayer
 struct ArgMinMaxDescriptor : BaseDescriptor
 {
     ArgMinMaxDescriptor()
         : m_Function(ArgMinMaxFunction::Min)
         , m_Axis(-1)
         , m_Output_Type(armnn::DataType::Signed32)
     {}

     bool operator ==(const ArgMinMaxDescriptor &rhs) const
     {
         return m_Function == rhs.m_Function && m_Axis == rhs.m_Axis && m_Output_Type == rhs.m_Output_Type;
     }

     /// Specify if the function is to find Min or Max.
     ArgMinMaxFunction m_Function;
     /// Axis to reduce across the input tensor.
     int m_Axis;
     /// Deprecated and will be removed in future release.
     armnn::DataType m_Output_Type;
 };

 /// A ComparisonDescriptor for the ComparisonLayer
 struct ComparisonDescriptor : BaseDescriptor
 {
     ComparisonDescriptor()
         : ComparisonDescriptor(ComparisonOperation::Equal)
     {}

     ComparisonDescriptor(ComparisonOperation operation)
         : m_Operation(operation)
     {}

     bool operator ==(const ComparisonDescriptor &rhs) const
     {
         return m_Operation == rhs.m_Operation;
     }

     /// Specifies the comparison operation to execute
     ComparisonOperation m_Operation;
 };

 /// A ElementwiseUnaryDescriptor for the ElementwiseUnaryLayer
 struct ElementwiseUnaryDescriptor : BaseDescriptor
 {
     ElementwiseUnaryDescriptor()
         : ElementwiseUnaryDescriptor(UnaryOperation::Abs)
     {}

     ElementwiseUnaryDescriptor(UnaryOperation operation)
         : m_Operation(operation)
     {}

     bool operator ==(const ElementwiseUnaryDescriptor &rhs) const
     {
         return m_Operation == rhs.m_Operation;
     }

     /// Specifies the elementwiseUnary operation to execute
     UnaryOperation m_Operation;
 };

 /// A PermuteDescriptor for the PermuteLayer.
 struct PermuteDescriptor : BaseDescriptor
 {
     PermuteDescriptor()
         : m_DimMappings{}
     {}

     PermuteDescriptor(const PermutationVector& dimMappings)
         : m_DimMappings(dimMappings)
     {}

     bool operator ==(const PermuteDescriptor &rhs) const
     {
         return m_DimMappings.IsEqual(rhs.m_DimMappings);
     }

     /// @brief Indicates how to translate tensor elements from a given source into the target destination, when
     /// source and target potentially have different memory layouts e.g.
     /// Input Shape        {1, 1, 4, 4}
     /// Permutation Vector {0, 2, 3, 1}
     /// Output Shape       {1, 4, 1, 4}
     /// dim "0" goes into index 0 ([ 1, X, X, X ])
     /// dim "1" goes into index 2 ([ 1, X, 1, X ])
     /// dim "2" goes into index 3 ([ 1, X, 1, 4 ])
     /// dim "3" goes into index 1 ([ 1, 4, 1, 4 ])
     PermutationVector m_DimMappings;
 };

 /// A SoftmaxDescriptor for the SoftmaxLayer.
 struct SoftmaxDescriptor : BaseDescriptor
 {
     SoftmaxDescriptor()
         : m_Beta(1.0f)
         , m_Axis(-1)
     {}

     bool operator ==(const SoftmaxDescriptor& rhs) const
     {
         return m_Beta == rhs.m_Beta && m_Axis == rhs.m_Axis;
     }

     /// Exponentiation value.
     float m_Beta;
     /// Scalar, defaulted to the last index (-1), specifying the dimension the activation will be performed on.
     int m_Axis;
 };

 /// A LogSoftmaxDescriptor for the LogSoftmaxLayer
 using LogSoftmaxDescriptor = SoftmaxDescriptor;

 /// @brief An OriginsDescriptor for the ConcatLayer.
 /// Descriptor to configure the concatenation process. Number of views must be equal to the number of inputs, and
 /// their order must match - e.g. first view corresponds to the first input, second view to the second input, etc.
 struct OriginsDescriptor : BaseDescriptor
 {
     OriginsDescriptor();
     OriginsDescriptor(uint32_t numViews, uint32_t numDimensions = 4);
     OriginsDescriptor(const OriginsDescriptor& other);
     OriginsDescriptor(OriginsDescriptor&& other);

     ~OriginsDescriptor();

     OriginsDescriptor& operator=(OriginsDescriptor rhs);

     bool operator ==(const OriginsDescriptor& rhs) const;

     /// @Brief Set the view origin coordinates. The arguments are: view, dimension, value.
     /// If the view is greater than or equal to GetNumViews(), then the view argument is out of range.
     /// If the coord is greater than or equal to GetNumDimensions(), then the coord argument is out of range.
     Status SetViewOriginCoord(uint32_t view, uint32_t coord, uint32_t value);
     /// Get the number of views.
     uint32_t GetNumViews() const;
     /// Get the number of dimensions.
     uint32_t GetNumDimensions() const;
     /// Return the view origin at the int value idx.
     const uint32_t* GetViewOrigin(uint32_t idx) const;
     /// @brief Reorders the viewOrigins in accordance with the indices presented in newOrdering array.
     /// The number of views must match number of elements in the new ordering array.
     void ReorderOrigins(unsigned int*  newOrdering, unsigned int numNewOrdering);
     /// Swap the ViewsDescriptor values first and second.
     friend void swap(OriginsDescriptor& first, OriginsDescriptor& second);
     /// Set the concatenation axis value.
     void SetConcatAxis(unsigned int concatAxis);
     /// Get the concatenation axis value.
     unsigned int GetConcatAxis() const;

 private:
     unsigned int m_ConcatAxis;
     uint32_t     m_NumViews;
     uint32_t     m_NumDimensions;
     uint32_t**   m_ViewOrigins;
 };

 /// @brief A ViewsDescriptor for the SplitterLayer.
 /// Descriptor to configure the splitting process. Number of Views must be equal to the number of outputs, and
 /// their order must match - e.g. first view corresponds to the first output, second view to the second output, etc.
 struct ViewsDescriptor : BaseDescriptor
 {
     ViewsDescriptor(uint32_t numViews, uint32_t numDimensions = 4);
     ViewsDescriptor(const ViewsDescriptor& other);
     ViewsDescriptor();
     ViewsDescriptor(ViewsDescriptor&& other);

     ~ViewsDescriptor();

     ViewsDescriptor& operator=(ViewsDescriptor rhs);

     bool operator ==(const ViewsDescriptor& rhs) const;

     /// @Brief Set the view origin coordinates. The arguments are: view, dimension, value.
     /// If the view is greater than or equal to GetNumViews(), then the view argument is out of range.
     /// If the coord is greater than or equal to GetNumDimensions(), then the coord argument is out of range.
     Status SetViewOriginCoord(uint32_t view, uint32_t coord, uint32_t value);
     /// @brief Set the size of the views. The arguments are: view, dimension, value.
     /// If the view is greater than or equal to GetNumViews(), then the view argument is out of range.
     /// If the coord is greater than or equal to GetNumDimensions(), then the coord argument is out of range.
     Status SetViewSize(uint32_t view, uint32_t coord, uint32_t value);

     /// Get the number of views.
     uint32_t GetNumViews() const;
     /// Get the number of dimensions.
     uint32_t GetNumDimensions() const;
     /// Get the view origin at the int value idx.
     const uint32_t* GetViewOrigin(uint32_t idx) const;
     /// Get the view sizes at the int value idx.
     const uint32_t* GetViewSizes(uint32_t idx) const;
     /// Get the View Origins
     const OriginsDescriptor& GetOrigins() const;

     /// Swap the ViewsDescriptor value first and second.
     friend void swap(ViewsDescriptor& first, ViewsDescriptor& second);
 private:
     OriginsDescriptor m_Origins;
     uint32_t**        m_ViewSizes;
 };


 /// @brief Convenience template to create an OriginsDescriptor to use when creating a ConcatLayer for performing
 /// concatenation of a number of input tensors.
 template <typename TensorShapeIt>
 OriginsDescriptor CreateDescriptorForConcatenation(TensorShapeIt first,
                                                    TensorShapeIt last,
                                                    unsigned int concatenationDimension)
 {
     auto numInputs = std::distance(first, last);

     if (numInputs < 2)
     {
         throw InvalidArgumentException("Concatenation requires at least 2 inputs");
     }

     const auto& firstInputShape = *first;

     const unsigned int numDimensions = firstInputShape.GetNumDimensions();
     for (auto it = first + 1; it != last; ++it)
     {
         if (it->GetNumDimensions() != numDimensions)
         {
             throw InvalidArgumentException("All inputs to concatenation must have the same number of dimensions");
         }
     }

     if (concatenationDimension >= numDimensions)
     {
         throw InvalidArgumentException("concatenationDimension must be between 0 and the number of dimensions.");
     }

     for (auto it = first; it != last; ++it)
     {
         for (unsigned int d = 0; d < numDimensions; ++d)
         {
             const bool dimSizeOk = (d == concatenationDimension) || (firstInputShape[d] == (*it)[d]);
             if (!dimSizeOk)
             {
                 throw InvalidArgumentException("All inputs to concatenation must be the same size along all dimensions "
                     " except the concatenation dimension");
             }
         }
     }

     OriginsDescriptor viewsDescriptor(static_cast<uint32_t>(numInputs), numDimensions);
     viewsDescriptor.SetConcatAxis(concatenationDimension);

     uint32_t viewIndex = 0u;
     uint32_t coordAlongConcatDim = 0u;
     for (auto it = first; it != last; ++it)
     {
         const auto& inputShape = *it;

         for (unsigned int i = 0; i < concatenationDimension; ++i)
         {
             viewsDescriptor.SetViewOriginCoord(viewIndex, i, 0);
         }

         viewsDescriptor.SetViewOriginCoord(viewIndex, concatenationDimension, coordAlongConcatDim);
         unsigned int dimSize = inputShape[concatenationDimension];
         coordAlongConcatDim += dimSize;


         for (unsigned int i = concatenationDimension + 1; i < numDimensions; ++i)
         {
             viewsDescriptor.SetViewOriginCoord(viewIndex, i, 0);
         }

         ++viewIndex;
     }

     return viewsDescriptor;
 }

 /// A Pooling2dDescriptor for the Pooling2dLayer.
 struct Pooling2dDescriptor : BaseDescriptor
 {
     Pooling2dDescriptor()
         : m_PoolType(PoolingAlgorithm::Max)
         , m_PadLeft(0)
         , m_PadRight(0)
         , m_PadTop(0)
         , m_PadBottom(0)
         , m_PoolWidth(0)
         , m_PoolHeight(0)
         , m_StrideX(0)
         , m_StrideY(0)
         , m_OutputShapeRounding(OutputShapeRounding::Floor)
         , m_PaddingMethod(PaddingMethod::Exclude)
         , m_DataLayout(DataLayout::NCHW)
     {}

     bool operator ==(const Pooling2dDescriptor& rhs) const
     {
         return m_PoolType            == rhs.m_PoolType &&
                m_PadLeft             == rhs.m_PadLeft &&
                m_PadRight            == rhs.m_PadRight &&
                m_PadTop              == rhs.m_PadTop &&
                m_PadBottom           == rhs.m_PadBottom &&
                m_PoolWidth           == rhs.m_PoolWidth &&
                m_PoolHeight          == rhs.m_PoolHeight &&
                m_StrideX             == rhs.m_StrideX &&
                m_StrideY             == rhs.m_StrideY &&
                m_OutputShapeRounding == rhs.m_OutputShapeRounding &&
                m_PaddingMethod       == rhs.m_PaddingMethod &&
                m_DataLayout          == rhs.m_DataLayout;
     }

     /// The pooling algorithm to use (Max. Average, L2).
     PoolingAlgorithm    m_PoolType;
     /// Padding left value in the width dimension.
     uint32_t            m_PadLeft;
     /// Padding right value in the width dimension.
     uint32_t            m_PadRight;
     /// Padding top value in the height dimension.
     uint32_t            m_PadTop;
     /// Padding bottom value in the height dimension.
     uint32_t            m_PadBottom;
     /// Pooling width value.
     uint32_t            m_PoolWidth;
     /// Pooling height value.
     uint32_t            m_PoolHeight;
     /// Stride value when proceeding through input for the width dimension.
     uint32_t            m_StrideX;
     /// Stride value when proceeding through input for the height dimension.
     uint32_t            m_StrideY;
     /// The rounding method for the output shape. (Floor, Ceiling).
     OutputShapeRounding m_OutputShapeRounding;
     /// The padding method to be used. (Exclude, IgnoreValue).
     PaddingMethod       m_PaddingMethod;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout   m_DataLayout;
 };

 /// A Pooling3dDescriptor for the Pooling3dLayer.
 struct Pooling3dDescriptor : BaseDescriptor
 {
     Pooling3dDescriptor()
         : m_PoolType(PoolingAlgorithm::Max)
         , m_PadLeft(0)
         , m_PadRight(0)
         , m_PadTop(0)
         , m_PadBottom(0)
         , m_PadFront(0)
         , m_PadBack(0)
         , m_PoolWidth(0)
         , m_PoolHeight(0)
         , m_PoolDepth(0)
         , m_StrideX(0)
         , m_StrideY(0)
         , m_StrideZ(0)
         , m_OutputShapeRounding(OutputShapeRounding::Floor)
         , m_PaddingMethod(PaddingMethod::Exclude)
         , m_DataLayout(DataLayout::NCDHW)
     {}

     bool operator ==(const Pooling3dDescriptor& rhs) const
     {
         return m_PoolType            == rhs.m_PoolType &&
                m_PadLeft             == rhs.m_PadLeft &&
                m_PadRight            == rhs.m_PadRight &&
                m_PadTop              == rhs.m_PadTop &&
                m_PadBottom           == rhs.m_PadBottom &&
                m_PadFront            == rhs.m_PadFront &&
                m_PadBack             == rhs.m_PadBack &&
                m_PoolWidth           == rhs.m_PoolWidth &&
                m_PoolHeight          == rhs.m_PoolHeight &&
                m_PoolDepth           == rhs.m_PoolDepth &&
                m_StrideX             == rhs.m_StrideX &&
                m_StrideY             == rhs.m_StrideY &&
                m_StrideZ             == rhs.m_StrideZ &&
                m_OutputShapeRounding == rhs.m_OutputShapeRounding &&
                m_PaddingMethod       == rhs.m_PaddingMethod &&
                m_DataLayout          == rhs.m_DataLayout;
     }

     /// The pooling algorithm to use (Max. Average, L2).
     PoolingAlgorithm    m_PoolType;
     /// Padding left value in the width dimension.
     uint32_t            m_PadLeft;
     /// Padding right value in the width dimension.
     uint32_t            m_PadRight;
     /// Padding top value in the height dimension.
     uint32_t            m_PadTop;
     /// Padding bottom value in the height dimension.
     uint32_t            m_PadBottom;
     /// Padding front value in the depth dimension.
     uint32_t            m_PadFront;
     /// Padding back value in the depth dimension.
     uint32_t            m_PadBack;
     /// Pooling width value.
     uint32_t            m_PoolWidth;
     /// Pooling height value.
     uint32_t            m_PoolHeight;
     /// Pooling depth value.
     uint32_t            m_PoolDepth;
     /// Stride value when proceeding through input for the width dimension.
     uint32_t            m_StrideX;
     /// Stride value when proceeding through input for the height dimension.
     uint32_t            m_StrideY;
     /// Stride value when proceeding through input for the depth dimension.
     uint32_t            m_StrideZ;
     /// The rounding method for the output shape. (Floor, Ceiling).
     OutputShapeRounding m_OutputShapeRounding;
     /// The padding method to be used. (Exclude, IgnoreValue).
     PaddingMethod       m_PaddingMethod;
     /// The data layout to be used (NCDHW, NDHWC).
     DataLayout   m_DataLayout;
 };

 /// A FullyConnectedDescriptor for the FullyConnectedLayer.
 struct FullyConnectedDescriptor : BaseDescriptor
 {
     FullyConnectedDescriptor()
         : m_BiasEnabled(false)
         , m_TransposeWeightMatrix(false)
         , m_ConstantWeights(true)
     {}

     bool operator ==(const FullyConnectedDescriptor& rhs) const
     {
         return m_BiasEnabled == rhs.m_BiasEnabled
                && m_TransposeWeightMatrix == rhs.m_TransposeWeightMatrix
                && m_ConstantWeights == rhs.m_ConstantWeights;
     }

     /// Get the number of inputs.
     uint32_t GetNumInputs() const;

     /// Enable/disable bias.
     bool m_BiasEnabled;
     /// Enable/disable transpose weight matrix.
     bool m_TransposeWeightMatrix;
     /// Enable/disable constant weights and biases.
     bool m_ConstantWeights;
 };

 /// A Convolution2dDescriptor for the Convolution2dLayer.
 struct Convolution2dDescriptor : BaseDescriptor
 {
     Convolution2dDescriptor()
         : m_PadLeft(0)
         , m_PadRight(0)
         , m_PadTop(0)
         , m_PadBottom(0)
         , m_StrideX(1)
         , m_StrideY(1)
         , m_DilationX(1)
         , m_DilationY(1)
         , m_BiasEnabled(false)
         , m_DataLayout(DataLayout::NCHW)
     {}

     bool operator ==(const Convolution2dDescriptor& rhs) const
     {
         return m_PadLeft     == rhs.m_PadLeft &&
                m_PadRight    == rhs.m_PadRight &&
                m_PadTop      == rhs.m_PadTop &&
                m_PadBottom   == rhs.m_PadBottom &&
                m_StrideX     == rhs.m_StrideX &&
                m_StrideY     == rhs.m_StrideY &&
                m_DilationX   == rhs.m_DilationX &&
                m_DilationY   == rhs.m_DilationY &&
                m_BiasEnabled == rhs.m_BiasEnabled &&
                m_DataLayout  == rhs.m_DataLayout;
     }
     uint32_t GetNumInputs() const;


     /// Padding left value in the width dimension.
     uint32_t             m_PadLeft;
     /// Padding right value in the width dimension.
     uint32_t             m_PadRight;
     /// Padding top value in the height dimension.
     uint32_t             m_PadTop;
     /// Padding bottom value in the height dimension.
     uint32_t             m_PadBottom;
     /// Stride value when proceeding through input for the width dimension.
     uint32_t             m_StrideX;
     /// Stride value when proceeding through input for the height dimension.
     uint32_t             m_StrideY;
     /// Dilation along x axis
     uint32_t             m_DilationX;
     /// Dilation along y axis
     uint32_t             m_DilationY;
     /// Enable/disable bias.
     bool                 m_BiasEnabled;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout           m_DataLayout;
 };

 /// A Convolution3dDescriptor for the Convolution3dLayer.
 struct Convolution3dDescriptor : BaseDescriptor
 {
     Convolution3dDescriptor()
         : m_PadLeft(0)
         , m_PadRight(0)
         , m_PadTop(0)
         , m_PadBottom(0)
         , m_PadFront(0)
         , m_PadBack(0)
         , m_StrideX(1)
         , m_StrideY(1)
         , m_StrideZ(1)
         , m_DilationX(1)
         , m_DilationY(1)
         , m_DilationZ(1)
         , m_BiasEnabled(false)
         , m_DataLayout(DataLayout::NDHWC)
     {}

     bool operator ==(const Convolution3dDescriptor& rhs) const
     {
         return m_PadLeft     == rhs.m_PadLeft &&
                m_PadRight    == rhs.m_PadRight &&
                m_PadTop      == rhs.m_PadTop &&
                m_PadBottom   == rhs.m_PadBottom &&
                m_PadFront    == rhs.m_PadFront &&
                m_PadBack     == rhs.m_PadBack &&
                m_StrideX     == rhs.m_StrideX &&
                m_StrideY     == rhs.m_StrideY &&
                m_StrideZ     == rhs.m_StrideZ &&
                m_DilationX   == rhs.m_DilationX &&
                m_DilationY   == rhs.m_DilationY &&
                m_DilationZ   == rhs.m_DilationZ &&
                m_BiasEnabled == rhs.m_BiasEnabled &&
                m_DataLayout  == rhs.m_DataLayout;
     }

     /// Get the number of views/inputs.
     uint32_t GetNumInputs() const;

     /// Padding left value in the width dimension.
     uint32_t             m_PadLeft;
     /// Padding right value in the width dimension.
     uint32_t             m_PadRight;
     /// Padding top value in the height dimension.
     uint32_t             m_PadTop;
     /// Padding bottom value in the height dimension.
     uint32_t             m_PadBottom;
     /// Padding front value in the depth dimension.
     uint32_t             m_PadFront;
     /// Padding back value in the depth dimension.
     uint32_t             m_PadBack;
     /// Stride value when proceeding through input for the width dimension.
     uint32_t             m_StrideX;
     /// Stride value when proceeding through input for the height dimension.
     uint32_t             m_StrideY;
     /// Stride value when proceeding through input for the depth dimension.
     uint32_t             m_StrideZ;
     /// Dilation along x axis
     uint32_t             m_DilationX;
     /// Dilation along y axis
     uint32_t             m_DilationY;
     /// Dilation along z axis
     uint32_t             m_DilationZ;
     /// Enable/disable bias.
     bool                 m_BiasEnabled;
     /// The data layout to be used (NDHWC, NCDHW).
     DataLayout           m_DataLayout;
 };

 /// A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
 struct DepthwiseConvolution2dDescriptor : BaseDescriptor
 {
     DepthwiseConvolution2dDescriptor()
         : m_PadLeft(0)
         , m_PadRight(0)
         , m_PadTop(0)
         , m_PadBottom(0)
         , m_StrideX(1)
         , m_StrideY(1)
         , m_DilationX(1)
         , m_DilationY(1)
         , m_BiasEnabled(false)
         , m_DataLayout(DataLayout::NCHW)
     {}

     bool operator ==(const DepthwiseConvolution2dDescriptor& rhs) const
     {
         return m_PadLeft     == rhs.m_PadLeft &&
                m_PadRight    == rhs.m_PadRight &&
                m_PadTop      == rhs.m_PadTop &&
                m_PadBottom   == rhs.m_PadBottom &&
                m_StrideX     == rhs.m_StrideX &&
                m_StrideY     == rhs.m_StrideY &&
                m_DilationX   == rhs.m_DilationX &&
                m_DilationY   == rhs.m_DilationY &&
                m_BiasEnabled == rhs.m_BiasEnabled &&
                m_DataLayout  == rhs.m_DataLayout;
     }

     /// Get the number of views/inputs.
     uint32_t GetNumInputs() const;

     /// Padding left value in the width dimension.
     uint32_t   m_PadLeft;
     /// Padding right value in the width dimension.
     uint32_t   m_PadRight;
     /// Padding top value in the height dimension.
     uint32_t   m_PadTop;
     /// Padding bottom value in the height dimension.
     uint32_t   m_PadBottom;
     /// Stride value when proceeding through input for the width dimension.
     uint32_t   m_StrideX;
     /// Stride value when proceeding through input for the height dimension.
     uint32_t   m_StrideY;
     /// Dilation factor value for width dimension.
     uint32_t   m_DilationX;
     /// Dilation factor value for height dimension.
     uint32_t   m_DilationY;
     /// Enable/disable bias.
     bool       m_BiasEnabled;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout m_DataLayout;
 };

 struct DetectionPostProcessDescriptor : BaseDescriptor
 {
     DetectionPostProcessDescriptor()
         : m_MaxDetections(0)
         , m_MaxClassesPerDetection(1)
         , m_DetectionsPerClass(1)
         , m_NmsScoreThreshold(0)
         , m_NmsIouThreshold(0)
         , m_NumClasses(0)
         , m_UseRegularNms(false)
         , m_ScaleX(0)
         , m_ScaleY(0)
         , m_ScaleW(0)
         , m_ScaleH(0)
     {}

     bool operator ==(const DetectionPostProcessDescriptor& rhs) const
     {
         return m_MaxDetections          == rhs.m_MaxDetections &&
                m_MaxClassesPerDetection == rhs.m_MaxClassesPerDetection &&
                m_DetectionsPerClass     == rhs.m_DetectionsPerClass &&
                m_NmsScoreThreshold      == rhs.m_NmsScoreThreshold &&
                m_NmsIouThreshold        == rhs.m_NmsIouThreshold &&
                m_NumClasses             == rhs.m_NumClasses &&
                m_UseRegularNms          == rhs.m_UseRegularNms &&
                m_ScaleX                 == rhs.m_ScaleX &&
                m_ScaleY                 == rhs.m_ScaleY &&
                m_ScaleW                 == rhs.m_ScaleW &&
                m_ScaleH                 == rhs.m_ScaleH;
     }

     /// Maximum numbers of detections.
     uint32_t m_MaxDetections;
     /// Maximum numbers of classes per detection, used in Fast NMS.
     uint32_t m_MaxClassesPerDetection;
     /// Detections per classes, used in Regular NMS.
     uint32_t m_DetectionsPerClass;
     /// NMS score threshold.
     float m_NmsScoreThreshold;
     /// Intersection over union threshold.
     float m_NmsIouThreshold;
     /// Number of classes.
     uint32_t m_NumClasses;
     /// Use Regular NMS.
     bool m_UseRegularNms;
     /// Center size encoding scale x.
     float m_ScaleX;
     /// Center size encoding scale y.
     float m_ScaleY;
     /// Center size encoding scale weight.
     float m_ScaleW;
     /// Center size encoding scale height.
     float m_ScaleH;
 };

 /// A NormalizationDescriptor for the NormalizationLayer.
 struct NormalizationDescriptor : BaseDescriptor
 {
     NormalizationDescriptor()
         : m_NormChannelType(NormalizationAlgorithmChannel::Across)
         , m_NormMethodType(NormalizationAlgorithmMethod::LocalBrightness)
         , m_NormSize(0)
         , m_Alpha(0.f)
         , m_Beta(0.f)
         , m_K(0.f)
         , m_DataLayout(DataLayout::NCHW)
     {}

     bool operator ==(const NormalizationDescriptor& rhs) const
     {
         return m_NormChannelType == rhs.m_NormChannelType &&
                m_NormMethodType  == rhs.m_NormMethodType &&
                m_NormSize        == rhs.m_NormSize &&
                m_Alpha           == rhs.m_Alpha &&
                m_Beta            == rhs.m_Beta &&
                m_K               == rhs.m_K &&
                m_DataLayout      == rhs.m_DataLayout;
     }

     /// Normalization channel algorithm to use (Across, Within).
     NormalizationAlgorithmChannel m_NormChannelType;
     /// Normalization method algorithm to use (LocalBrightness, LocalContrast).
     NormalizationAlgorithmMethod  m_NormMethodType;
     /// Depth radius value.
     uint32_t                      m_NormSize;
     /// Alpha value for the normalization equation.
     float                         m_Alpha;
     /// Beta value for the normalization equation.
     float                         m_Beta;
     /// Kappa value used for the across channel normalization equation.
     float                         m_K;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout                    m_DataLayout;
 };

 /// A L2NormalizationDescriptor for the L2NormalizationLayer.
 struct L2NormalizationDescriptor : BaseDescriptor
 {
     L2NormalizationDescriptor()
         : m_Eps(1e-12f)
         , m_DataLayout(DataLayout::NCHW)
     {}

     bool operator ==(const L2NormalizationDescriptor& rhs) const
     {
         return m_Eps == rhs.m_Eps && m_DataLayout == rhs.m_DataLayout;
     }

     /// Used to avoid dividing by zero.
     float m_Eps;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout m_DataLayout;
 };

 /// A BatchNormalizationDescriptor for the BatchNormalizationLayer.
 struct BatchNormalizationDescriptor : BaseDescriptor
 {
     BatchNormalizationDescriptor()
         : m_Eps(0.0001f)
         , m_DataLayout(DataLayout::NCHW)
     {}

     bool operator ==(const BatchNormalizationDescriptor& rhs) const
     {
         return m_Eps == rhs.m_Eps && m_DataLayout == rhs.m_DataLayout;
     }

     /// Value to add to the variance. Used to avoid dividing by zero.
     float m_Eps;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout m_DataLayout;
 };

 /// An InstanceNormalizationDescriptor for InstanceNormalizationLayer
 struct InstanceNormalizationDescriptor : BaseDescriptor
 {
     InstanceNormalizationDescriptor()
         : m_Gamma(1.0f)
         , m_Beta(0.0f)
         , m_Eps(1e-12f)
         , m_DataLayout(DataLayout::NCHW)
     {}

     bool operator ==(const InstanceNormalizationDescriptor& rhs) const
     {
         return m_Gamma      == rhs.m_Gamma &&
                m_Beta       == rhs.m_Beta &&
                m_Eps        == rhs.m_Eps &&
                m_DataLayout == rhs.m_DataLayout;
     }

     /// Gamma, the scale scalar value applied for the normalized tensor. Defaults to 1.0.
     float m_Gamma;
     /// Beta, the offset scalar value applied for the normalized tensor. Defaults to 1.0.
     float m_Beta;
     /// Epsilon, small scalar value added to variance to avoid dividing by zero. Defaults to 1e-12f.
     float m_Eps;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout m_DataLayout;
 };

 /// A BatchToSpaceNdDescriptor for the BatchToSpaceNdLayer.
 struct BatchToSpaceNdDescriptor : BaseDescriptor
 {
     BatchToSpaceNdDescriptor()
         : m_BlockShape({1, 1})
         , m_Crops({{0, 0}, {0, 0}})
         , m_DataLayout(DataLayout::NCHW)
     {}

     BatchToSpaceNdDescriptor(std::vector<unsigned int> blockShape,
                              std::vector<std::pair<unsigned int, unsigned int>> crops)
         : m_BlockShape(blockShape)
         , m_Crops(crops)
         , m_DataLayout(DataLayout::NCHW)
     {}

     bool operator ==(const BatchToSpaceNdDescriptor& rhs) const
     {
         return m_BlockShape == rhs.m_BlockShape &&
                m_Crops      == rhs.m_Crops &&
                m_DataLayout == rhs.m_DataLayout;
     }

     /// Block shape values.
     std::vector<unsigned int> m_BlockShape;
     /// The values to crop from the input dimension.
     std::vector<std::pair<unsigned int, unsigned int>> m_Crops;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout m_DataLayout;
 };

 /// A FakeQuantizationDescriptor for the FakeQuantizationLayer.
 struct FakeQuantizationDescriptor : BaseDescriptor
 {
         FakeQuantizationDescriptor()
         : m_Min(-6.0f)
         , m_Max(6.0f)
     {}

     bool operator ==(const FakeQuantizationDescriptor& rhs) const
     {
         return m_Min == rhs.m_Min && m_Max == rhs.m_Max;
     }

     /// Minimum value.
     float m_Min;
     /// Maximum value.
     float m_Max;
 };

 /// A FillDescriptor for the FillLayer
 struct FillDescriptor : BaseDescriptor
 {
     FillDescriptor()
     : m_Value(0)
     {}

     FillDescriptor(const float& value)
     : m_Value(value)
     {}

     bool operator ==(const FillDescriptor& rhs) const
     {
         return m_Value == rhs.m_Value;
     }

     float m_Value;
 };

 /// A GatherDescriptor for the GatherLayer.
 struct GatherDescriptor : BaseDescriptor
 {
     GatherDescriptor()
         : m_Axis(0)
     {}

     GatherDescriptor(int32_t axis)
         : m_Axis(axis)
     {}

     bool operator ==(const GatherDescriptor& rhs) const
     {
         return m_Axis == rhs.m_Axis;
     }

     /// The axis in params to gather indices from
     int32_t m_Axis;
 };

 /// A ResizeDescriptor for the ResizeLayer.
 struct ResizeDescriptor : BaseDescriptor
 {
     ResizeDescriptor()
         : m_TargetWidth(0)
         , m_TargetHeight(0)
         , m_Method(ResizeMethod::NearestNeighbor)
         , m_DataLayout(DataLayout::NCHW)
         , m_AlignCorners(false)
         , m_HalfPixelCenters(false)
     {}

     bool operator ==(const ResizeDescriptor& rhs) const
     {
         return m_TargetWidth          == rhs.m_TargetWidth &&
                m_TargetHeight         == rhs.m_TargetHeight &&
                m_Method               == rhs.m_Method &&
                m_DataLayout           == rhs.m_DataLayout &&
                m_AlignCorners         == rhs.m_AlignCorners &&
                m_HalfPixelCenters     == rhs.m_HalfPixelCenters;
     }

     /// Target width value.
     uint32_t m_TargetWidth;
     /// Target height value.
     uint32_t m_TargetHeight;
     /// The Interpolation method to use
     /// (Bilinear, NearestNeighbor).
     ResizeMethod m_Method;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout m_DataLayout;
     /// Aligned corners
     bool m_AlignCorners;
     /// Half Pixel Centers
     bool m_HalfPixelCenters;
 };


 /// A ReshapeDescriptor for the ReshapeLayer.
 struct ReshapeDescriptor : BaseDescriptor
 {
     ReshapeDescriptor()
         : m_TargetShape()
     {}

     ReshapeDescriptor(const TensorShape& shape)
         : m_TargetShape(shape)
     {}

     bool operator ==(const ReshapeDescriptor& rhs) const
     {
         return m_TargetShape == rhs.m_TargetShape;
     }

     /// Target shape value.
     TensorShape m_TargetShape;
 };

 /// A SpaceToBatchNdDescriptor for the SpaceToBatchNdLayer.
 struct SpaceToBatchNdDescriptor : BaseDescriptor
 {
     SpaceToBatchNdDescriptor()
         : m_BlockShape({1, 1})
         , m_PadList({{0, 0}, {0, 0}})
         , m_DataLayout(DataLayout::NCHW)
     {}

     SpaceToBatchNdDescriptor(const std::vector<unsigned int>& blockShape,
                              const std::vector<std::pair<unsigned int, unsigned int>>& padList)
         : m_BlockShape(blockShape)
         , m_PadList(padList)
         , m_DataLayout(DataLayout::NCHW)
     {}

     bool operator ==(const SpaceToBatchNdDescriptor& rhs) const
     {
         return m_BlockShape == rhs.m_BlockShape &&
                m_PadList    == rhs.m_PadList &&
                m_DataLayout == rhs.m_DataLayout;
     }

     /// Block shape value.
     std::vector<unsigned int> m_BlockShape;
     /// @brief Specifies the padding values for the input dimension:
     /// heightPad{top, bottom} widthPad{left, right}.
     std::vector<std::pair<unsigned int, unsigned int>> m_PadList;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout m_DataLayout;
 };

 /// A SpaceToDepthDescriptor for the SpaceToDepthLayer
 struct SpaceToDepthDescriptor : BaseDescriptor
 {
     SpaceToDepthDescriptor()
         : SpaceToDepthDescriptor(1u, DataLayout::NHWC)
     {}

     SpaceToDepthDescriptor(unsigned int blockSize, DataLayout dataLayout)
         : m_BlockSize(blockSize)
         , m_DataLayout(dataLayout)
     {}

     bool operator ==(const SpaceToDepthDescriptor& rhs) const
     {
         return m_BlockSize == rhs.m_BlockSize && m_DataLayout == rhs.m_DataLayout;
     }

     /// Scalar specifying the input block size. It must be >= 1
     unsigned int m_BlockSize;

     /// The data layout to be used (NCHW, NHWC).
     DataLayout m_DataLayout;
 };

 /// A DepthToSpaceDescriptor for the DepthToSpaceLayer
 using DepthToSpaceDescriptor = SpaceToDepthDescriptor;

 /// An LstmDescriptor for the LstmLayer.
 struct LstmDescriptor : BaseDescriptor
 {
     LstmDescriptor()
         : m_ActivationFunc(1) // 0: None, 1: Relu, 3: Relu6, 4: Tanh, 6: Sigmoid
         , m_ClippingThresCell(0.0)
         , m_ClippingThresProj(0.0)
         , m_CifgEnabled(true)
         , m_PeepholeEnabled(false)
         , m_ProjectionEnabled(false)
         , m_LayerNormEnabled(false)
         , m_TimeMajor(false)
         , m_InputIntermediateScale(0.0)
         , m_ForgetIntermediateScale(0.0)
         , m_CellIntermediateScale(0.0)
         , m_OutputIntermediateScale(0.0)
         , m_HiddenStateZeroPoint(0)
         , m_HiddenStateScale(0.0)
     {}

     bool operator ==(const LstmDescriptor& rhs) const
     {
         return m_ActivationFunc          == rhs.m_ActivationFunc &&
                m_ClippingThresCell       == rhs.m_ClippingThresCell &&
                m_ClippingThresProj       == rhs.m_ClippingThresProj &&
                m_CifgEnabled             == rhs.m_CifgEnabled &&
                m_PeepholeEnabled         == rhs.m_PeepholeEnabled &&
                m_LayerNormEnabled        == rhs.m_LayerNormEnabled &&
                m_TimeMajor               == rhs.m_TimeMajor &&
                m_InputIntermediateScale  == rhs.m_InputIntermediateScale &&
                m_ForgetIntermediateScale == rhs.m_ForgetIntermediateScale &&
                m_CellIntermediateScale   == rhs.m_CellIntermediateScale &&
                m_OutputIntermediateScale == rhs.m_OutputIntermediateScale &&
                m_HiddenStateZeroPoint    == rhs.m_HiddenStateZeroPoint &&
                m_HiddenStateScale        == rhs.m_HiddenStateScale;
     }

     /// @brief The activation function to use.
     /// 0: None, 1: Relu, 3: Relu6, 4: Tanh, 6: Sigmoid.
     uint32_t m_ActivationFunc;
     /// Clipping threshold value for the cell state.
     float m_ClippingThresCell;
     /// Clipping threshold value for the projection.
     float m_ClippingThresProj;
     /// Enable/disable cifg (coupled input & forget gate).
     bool m_CifgEnabled;
     /// Enable/disable peephole.
     bool m_PeepholeEnabled;
     /// Enable/disable the projection layer.
     bool m_ProjectionEnabled;
     /// Enable/disable layer normalization
     bool m_LayerNormEnabled;
     /// Enable/disable time major
     bool m_TimeMajor;
     /// Input intermediate quantization scale
     float m_InputIntermediateScale;
     /// Forget intermediate quantization scale
     float m_ForgetIntermediateScale;
     /// Cell intermediate quantization scale
     float m_CellIntermediateScale;
     /// Output intermediate quantization scale
     float m_OutputIntermediateScale;
     /// Hidden State zero point
     int32_t m_HiddenStateZeroPoint;
     /// Hidden State quantization scale
     float m_HiddenStateScale;
 };

 using UnidirectionalSequenceLstmDescriptor = LstmDescriptor;

 /// A MeanDescriptor for the MeanLayer.
 struct MeanDescriptor : BaseDescriptor
 {
     MeanDescriptor()
         : m_Axis()
         , m_KeepDims(false)
     {}

     MeanDescriptor(const std::vector<unsigned int>& axis, bool keepDims)
         : m_Axis(axis)
         , m_KeepDims(keepDims)
     {}

     bool operator ==(const MeanDescriptor& rhs) const
     {
         return m_Axis == rhs.m_Axis && m_KeepDims == rhs.m_KeepDims;
     }

     /// Values for the dimensions to reduce.
     std::vector<unsigned int> m_Axis;
     /// Enable/disable keep dimensions. If true, then the reduced dimensions that are of length 1 are kept.
     bool m_KeepDims;
 };

 /// A PadDescriptor for the PadLayer.
 struct PadDescriptor : BaseDescriptor
 {
     PadDescriptor() : m_PadValue(0), m_PaddingMode(PaddingMode::Constant)
     {}

     PadDescriptor(const std::vector<std::pair<unsigned int, unsigned int>>& padList,
                   const float& padValue = 0,
                   const PaddingMode& paddingMode = PaddingMode::Constant)
         : m_PadList(padList)
         , m_PadValue(padValue)
         , m_PaddingMode(paddingMode)
     {}

     bool operator ==(const PadDescriptor& rhs) const
     {
         return m_PadList == rhs.m_PadList && m_PadValue == rhs.m_PadValue && m_PaddingMode == rhs.m_PaddingMode;
     }

     /// @brief Specifies the padding for input dimension.
     /// First is the number of values to add before the tensor in the dimension.
     /// Second is the number of values to add after the tensor in the dimension.
     /// The number of pairs should match the number of dimensions in the input tensor.
     std::vector<std::pair<unsigned int, unsigned int>> m_PadList;

     /// Optional value to use for padding, defaults to 0
     float m_PadValue;

     /// Specifies the Padding mode (Constant, Reflect or Symmetric)
     PaddingMode m_PaddingMode;
 };

 /// A SliceDescriptor for the SliceLayer.
 struct SliceDescriptor : BaseDescriptor
 {
     SliceDescriptor(const std::vector<unsigned int>& begin, const std::vector<unsigned int>& size)
         : m_Begin(begin)
         , m_Size(size)
     {}

     SliceDescriptor() : SliceDescriptor({}, {})
     {}

     bool operator ==(const SliceDescriptor& rhs) const
     {
         return m_Begin == rhs.m_Begin && m_Size == rhs.m_Size;
     }

     /// Beginning indices of the slice in each dimension.
     std::vector<unsigned int> m_Begin;

     /// Size of the slice in each dimension.
     std::vector<unsigned int> m_Size;
 };

 /// A StackDescriptor for the StackLayer.
 struct StackDescriptor : BaseDescriptor
 {
     StackDescriptor()
         : m_Axis(0)
         , m_NumInputs(0)
         , m_InputShape()
     {}

     StackDescriptor(uint32_t axis, uint32_t numInputs, const TensorShape& inputShape)
         : m_Axis(axis)
         , m_NumInputs(numInputs)
         , m_InputShape(inputShape)
     {}

     bool operator ==(const StackDescriptor& rhs) const
     {
         return m_Axis       == rhs.m_Axis &&
                m_NumInputs  == rhs.m_NumInputs &&
                m_InputShape == rhs.m_InputShape;
     }

     /// 0-based axis along which to stack the input tensors.
     uint32_t m_Axis;
     /// Number of input tensors.
     uint32_t m_NumInputs;
     /// Required shape of all input tensors.
     TensorShape m_InputShape;
 };

 /// A StandInDescriptor for the StandIn layer
 struct StandInDescriptor : BaseDescriptor
 {
     StandInDescriptor() {};

     StandInDescriptor(uint32_t numInputs, uint32_t numOutputs)
         : m_NumInputs(numInputs)
         , m_NumOutputs(numOutputs)
     {}

     bool operator ==(const StandInDescriptor& rhs) const
     {
         return m_NumInputs  == rhs.m_NumInputs &&
                m_NumOutputs == rhs.m_NumOutputs;
     }

     /// Number of input tensors
     uint32_t m_NumInputs = 0;
     /// Number of output tensors
     uint32_t m_NumOutputs = 0;
 };

 /// A StridedSliceDescriptor for the StridedSliceLayer.
 struct StridedSliceDescriptor : BaseDescriptor
 {
     StridedSliceDescriptor(const std::vector<int>& begin,
                            const std::vector<int>& end,
                            const std::vector<int>& stride)
         : m_Begin(begin)
         , m_End(end)
         , m_Stride(stride)
         , m_BeginMask(0)
         , m_EndMask(0)
         , m_ShrinkAxisMask(0)
         , m_EllipsisMask(0)
         , m_NewAxisMask(0)
         , m_DataLayout(DataLayout::NCHW)
     {}

     StridedSliceDescriptor()
         : StridedSliceDescriptor({}, {}, {})
     {}

     bool operator ==(const StridedSliceDescriptor& rhs) const
     {
         return m_Begin          == rhs.m_Begin &&
                m_End            == rhs.m_End &&
                m_Stride         == rhs.m_Stride &&
                m_BeginMask      == rhs.m_BeginMask &&
                m_EndMask        == rhs.m_EndMask &&
                m_ShrinkAxisMask == rhs.m_ShrinkAxisMask &&
                m_EllipsisMask   == rhs.m_EllipsisMask &&
                m_NewAxisMask    == rhs.m_NewAxisMask &&
                m_DataLayout     == rhs.m_DataLayout;
     }

     int GetStartForAxis(const TensorShape& inputShape, unsigned int axis) const;
     int GetStopForAxis(const TensorShape& inputShape,
                        unsigned int axis,
                        int startForAxis) const;

     /// Begin values for the input that will be sliced.
     std::vector<int> m_Begin;
     /// End values for the input that will be sliced.
     std::vector<int> m_End;
     /// Stride values for the input that will be sliced.
     std::vector<int> m_Stride;

     /// @brief Begin mask value. If set, then the begin is disregarded and the fullest
     /// range is used for the dimension.
     int32_t m_BeginMask;
     /// @brief End mask value. If set, then the end is disregarded and the fullest range
     /// is used for the dimension.
     int32_t m_EndMask;
     /// Shrink axis mask value. If set, the nth specification shrinks the dimensionality by 1.
     int32_t m_ShrinkAxisMask;
     /// Ellipsis mask value.
     int32_t m_EllipsisMask;
     /// @brief New axis mask value. If set, the begin, end and stride is disregarded and
     /// a new 1 dimension is inserted to this location of the output tensor.
     int32_t m_NewAxisMask;

     /// The data layout to be used (NCHW, NHWC).
     DataLayout m_DataLayout;
 };

 /// A PreCompiledDescriptor for the PreCompiledLayer.
 struct PreCompiledDescriptor : BaseDescriptor
 {
     PreCompiledDescriptor(unsigned int numInputSlots = 1u, unsigned int numOutputSlots = 1u)
         : m_NumInputSlots(numInputSlots), m_NumOutputSlots(numOutputSlots)
     {}

     ~PreCompiledDescriptor() = default;

     unsigned int m_NumInputSlots;
     unsigned int m_NumOutputSlots;
 };

 /// A QLstmDescriptor for the QLstmLayer.
 struct QLstmDescriptor : BaseDescriptor
 {
     QLstmDescriptor()
             : m_CellClip(0.0)
             , m_ProjectionClip(0.0)
             , m_CifgEnabled(true)
             , m_PeepholeEnabled(false)
             , m_ProjectionEnabled(false)
             , m_LayerNormEnabled(false)
             , m_InputIntermediateScale(0.0)
             , m_ForgetIntermediateScale(0.0)
             , m_CellIntermediateScale(0.0)
             , m_OutputIntermediateScale(0.0)
             , m_HiddenStateZeroPoint(0)
             , m_HiddenStateScale(0.0)
     {}

     bool operator ==(const QLstmDescriptor& rhs) const
     {
         return m_CellClip          == rhs.m_CellClip &&
                m_ProjectionClip    == rhs.m_ProjectionClip &&
                m_CifgEnabled       == rhs.m_CifgEnabled &&
                m_PeepholeEnabled   == rhs.m_PeepholeEnabled &&
                m_ProjectionEnabled == rhs.m_ProjectionEnabled &&
                m_LayerNormEnabled  == rhs.m_LayerNormEnabled &&
                m_InputIntermediateScale == rhs.m_InputIntermediateScale &&
                m_ForgetIntermediateScale == rhs.m_ForgetIntermediateScale &&
                m_CellIntermediateScale == rhs.m_CellIntermediateScale &&
                m_OutputIntermediateScale == rhs.m_OutputIntermediateScale &&
                m_HiddenStateZeroPoint == rhs.m_HiddenStateZeroPoint &&
                m_HiddenStateScale == rhs.m_HiddenStateScale;
     }

     /// Clipping threshold value for the cell state
     float m_CellClip;
     /// Clipping threshold value for the projection
     float m_ProjectionClip;
     /// Enable/disable CIFG (coupled input & forget gate).
     bool m_CifgEnabled;
     /// Enable/disable peephole
     bool m_PeepholeEnabled;
     /// Enable/disable the projection layer
     bool m_ProjectionEnabled;
     /// Enable/disable layer normalization
     bool m_LayerNormEnabled;
     /// Input intermediate quantization scale
     float m_InputIntermediateScale;
     /// Forget intermediate quantization scale
     float m_ForgetIntermediateScale;
     /// Cell intermediate quantization scale
     float m_CellIntermediateScale;
     /// Output intermediate quantization scale
     float m_OutputIntermediateScale;
     /// Hidden State zero point
     int32_t m_HiddenStateZeroPoint;
     /// Hidden State quantization scale
     float m_HiddenStateScale;
 };

 /// A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer.
 struct TransposeConvolution2dDescriptor : BaseDescriptor
 {
     TransposeConvolution2dDescriptor() :
         m_PadLeft(0),
         m_PadRight(0),
         m_PadTop(0),
         m_PadBottom(0),
         m_StrideX(0),
         m_StrideY(0),
         m_BiasEnabled(false),
         m_DataLayout(DataLayout::NCHW),
         m_OutputShapeEnabled(false)
     {}

     bool operator ==(const TransposeConvolution2dDescriptor& rhs) const
     {
         return m_PadLeft            == rhs.m_PadLeft &&
                m_PadRight           == rhs.m_PadRight &&
                m_PadTop             == rhs.m_PadTop &&
                m_PadBottom          == rhs.m_PadBottom &&
                m_StrideX            == rhs.m_StrideX &&
                m_StrideY            == rhs.m_StrideY &&
                m_BiasEnabled        == rhs.m_BiasEnabled &&
                m_DataLayout         == rhs.m_DataLayout &&
                m_OutputShapeEnabled == rhs.m_OutputShapeEnabled &&
                m_OutputShape        == rhs.m_OutputShape;
     }

     /// Padding left value in the width dimension.
     uint32_t                  m_PadLeft;
     /// Padding right value in the width dimension.
     uint32_t                  m_PadRight;
     /// Padding top value in the height dimension.
     uint32_t                  m_PadTop;
     /// Padding bottom value in the height dimension.
     uint32_t                  m_PadBottom;
     /// Stride value when proceeding through input for the width dimension.
     uint32_t                  m_StrideX;
     /// Stride value when proceeding through input for the height dimension.
     uint32_t                  m_StrideY;
     /// Enable/disable bias.
     bool                      m_BiasEnabled;
     /// The data layout to be used (NCHW, NHWC).
     DataLayout                m_DataLayout;
     /// Output shape if it has been specified.
     bool                      m_OutputShapeEnabled;
     std::vector<unsigned int> m_OutputShape;
 };

 /// A TransposeDescriptor for the TransposeLayer.
 struct TransposeDescriptor : BaseDescriptor
 {
     TransposeDescriptor()
             : m_DimMappings{}
     {}

     TransposeDescriptor(const PermutationVector& dimMappings)
             : m_DimMappings(dimMappings)
     {}

     bool operator ==(const TransposeDescriptor &rhs) const
     {
         return m_DimMappings.IsEqual(rhs.m_DimMappings);
     }

     /// @brief Indicates how to translate tensor elements from a given source into the target destination, when
     /// source and target potentially have different memory layouts e.g.
     /// Input Shape        {1, 1, 4, 4}
     /// Permutation Vector {0, 2, 3, 1}
     /// Output Shape       {1, 4, 4, 1}
     /// dim "0" of input goes into index 0 ([ 1, X, X, X])
     /// dim "2" of input goes into index 1 ([ 1, 4, X, X ])
     /// dim "3" of input goes into index 2 ([ 1, 4, 4, X ])
     /// dim "1" of input goes into index 3 ([ 1, 4, 4, 1 ])
     PermutationVector m_DimMappings;
 };

 /// A LogicalBinaryDescriptor for the LogicalBinaryLayer
 struct LogicalBinaryDescriptor : BaseDescriptor
 {
     LogicalBinaryDescriptor()
         : LogicalBinaryDescriptor(LogicalBinaryOperation::LogicalAnd)
     {}

     LogicalBinaryDescriptor(LogicalBinaryOperation operation)
         : m_Operation(operation)
     {}

     bool operator ==(const LogicalBinaryDescriptor &rhs) const
     {
         return m_Operation == rhs.m_Operation;
     }

     /// Specifies the logical operation to execute
     LogicalBinaryOperation m_Operation;
 };

 /// A ReduceDescriptor for the REDUCE operators.
 struct ReduceDescriptor : BaseDescriptor
 {
     ReduceDescriptor()
         : m_KeepDims(false)
         , m_vAxis()
         , m_ReduceOperation(ReduceOperation::Sum)
     {}

     bool operator ==(const ReduceDescriptor& rhs) const
     {
         return m_KeepDims             == rhs.m_KeepDims &&
                m_vAxis                == rhs.m_vAxis &&
                m_ReduceOperation      == rhs.m_ReduceOperation;
     }

     /// if true then output shape has no change.
     bool m_KeepDims;
     /// The indices of the dimensions to reduce.
     std::vector<uint32_t> m_vAxis;
     /// Specifies the reduction operation to execute
     ReduceOperation m_ReduceOperation;
 };

 /// A ChannelShuffleDescriptor for the ChannelShuffle operator
 struct ChannelShuffleDescriptor : BaseDescriptor
 {
     ChannelShuffleDescriptor()
         : m_NumGroups(0), m_Axis(0)
     {}

     ChannelShuffleDescriptor(const uint32_t& numGroups, const uint32_t& axis)
         : m_NumGroups(numGroups), m_Axis(axis)
     {}

     bool operator ==(const ChannelShuffleDescriptor& rhs) const
     {
         return m_NumGroups == rhs.m_NumGroups;
     }

     /// Number of groups for the channel shuffle operation
     uint32_t m_NumGroups;
     /// Axis to apply channel shuffle operation on
     uint32_t m_Axis;
 };

 /// A BatchMatMulDescriptor for the BatchMatMul operator
 struct BatchMatMulDescriptor : BaseDescriptor
 {
     BatchMatMulDescriptor(bool transposeX = false,
                           bool transposeY = false,
                           bool adjointX = false,
                           bool adjointY = false,
                           DataLayout dataLayoutX = DataLayout::NCHW,
                           DataLayout dataLayoutY = DataLayout::NCHW)
         : m_TransposeX(transposeX)
         , m_TransposeY(transposeY)
         , m_AdjointX(adjointX)
         , m_AdjointY(adjointY)
         , m_DataLayoutX(dataLayoutX)
         , m_DataLayoutY(dataLayoutY)
     {}

     bool operator ==(const BatchMatMulDescriptor &rhs)  const
     {
         return m_TransposeX == rhs.m_TransposeX &&
                m_TransposeY == rhs.m_TransposeY &&
                m_AdjointX == rhs.m_AdjointX &&
                m_AdjointY == rhs.m_AdjointY &&
                m_DataLayoutX == rhs.m_DataLayoutX &&
                m_DataLayoutY == rhs.m_DataLayoutY;
     }

     /// Transpose the slices of each input tensor
     /// Transpose and Adjoint can not both be set to true for the same tensor at the same time
     bool m_TransposeX;
     bool m_TransposeY;

     /// Adjoint the slices of each input tensor
     /// Transpose and Adjoint can not both be set to true for the same tensor at the same time
     bool m_AdjointX;
     bool m_AdjointY;

     /// Data layout of each input tensor, such as NHWC/NDHWC (leave as default for arbitrary layout)
     DataLayout m_DataLayoutX;
     DataLayout m_DataLayoutY;

     ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use ABI Stable "
                                       "GetAxesToMul(DataLayout dataLayout, const TensorShape& tensorShape) instead.",
                                       "23.05")
     static std::pair<std::pair<unsigned int, unsigned int>, std::pair<unsigned int, unsigned int>> GetAxesToMul(
         const BatchMatMulDescriptor& desc,
         const TensorShape& tensorXShape,
         const TensorShape& tensorYShape);

     ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use ABI Stable "
                                       "GetAxesNotMul(DataLayout dataLayout, const TensorShape& tensorShape) instead.",
                                       "23.05")
     static std::pair<std::vector<unsigned int>, std::vector<unsigned int>> GetAxesNotMul(
         const BatchMatMulDescriptor& desc,
         const TensorShape& inputXShape,
         const TensorShape& inputYShape);

     /// Static helper to get the two axes (for each input) for multiplication
     static std::pair<unsigned int, unsigned int> GetAxesToMul(
         DataLayout dataLayout,
         const TensorShape& tensorShape);

     /// Static helper to get the axes (for each input) that will not be multiplied together
     static std::vector<unsigned int> GetAxesNotMul(
         DataLayout dataLayout,
         const TensorShape& tensorShape);

     /// Static helper to get the axes which will be transposed
     static PermutationVector GetPermuteVec(
         DataLayout dataLayout,
         const TensorShape& tensorShape);
 };

 } // namespace armnn
armnn::ElementwiseUnaryDescriptor::ElementwiseUnaryDescriptor
ElementwiseUnaryDescriptor(UnaryOperation operation)
Definition: Descriptors.hpp:115

-armnn::Convolution2dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:540

-armnn::PermuteDescriptor::PermuteDescriptor
PermuteDescriptor()
Definition: Descriptors.hpp:131

-armnn::Convolution2dDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:550

-armnn::Pooling3dDescriptor::m_PoolType
PoolingAlgorithm m_PoolType
The pooling algorithm to use (Max. Average, L2).
Definition: Descriptors.hpp:441

-armnn::L2NormalizationDescriptor::m_Eps
float m_Eps
Used to avoid dividing by zero.
Definition: Descriptors.hpp:790

-armnn::MeanDescriptor::MeanDescriptor
MeanDescriptor(const std::vector< unsigned int > &axis, bool keepDims)
Definition: Descriptors.hpp:1126

-armnn::ComparisonDescriptor::ComparisonDescriptor
ComparisonDescriptor()
Definition: Descriptors.hpp:91

-armnn::BatchMatMulDescriptor::m_AdjointY
bool m_AdjointY
Definition: Descriptors.hpp:1565

-armnn::LstmDescriptor::m_ProjectionEnabled
bool m_ProjectionEnabled
Enable/disable the projection layer.
Definition: Descriptors.hpp:1097

-armnn::Convolution2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:552

-armnn::PreCompiledDescriptor::PreCompiledDescriptor
PreCompiledDescriptor(unsigned int numInputSlots=1u, unsigned int numOutputSlots=1u)
Definition: Descriptors.hpp:1316

-armnn::MeanDescriptor::MeanDescriptor
MeanDescriptor()
Definition: Descriptors.hpp:1121

-armnn::BatchMatMulDescriptor::m_DataLayoutY
DataLayout m_DataLayoutY
Definition: Descriptors.hpp:1569

-armnn::TransposeConvolution2dDescriptor::TransposeConvolution2dDescriptor
TransposeConvolution2dDescriptor()
Definition: Descriptors.hpp:1389

-armnn::SliceDescriptor::SliceDescriptor
SliceDescriptor(const std::vector< unsigned int > &begin, const std::vector< unsigned int > &size)
Definition: Descriptors.hpp:1177

-armnn::ElementwiseUnaryDescriptor::m_Operation
UnaryOperation m_Operation
Specifies the elementwiseUnary operation to execute.
Definition: Descriptors.hpp:125

-armnn::StackDescriptor::m_Axis
uint32_t m_Axis
0-based axis along which to stack the input tensors.
Definition: Descriptors.hpp:1220

-armnn::ViewsDescriptor
A ViewsDescriptor for the SplitterLayer.
Definition: Descriptors.hpp:224

-armnn::DetectionPostProcessDescriptor::m_ScaleW
float m_ScaleW
Center size encoding scale weight.
Definition: Descriptors.hpp:731

-armnn::Pooling2dDescriptor::Pooling2dDescriptor
Pooling2dDescriptor()
Definition: Descriptors.hpp:341

-armnn::Pooling2dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:381

-armnn::DepthwiseConvolution2dDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:676

-armnn::DataLayout
DataLayout
Definition: Types.hpp:62

-armnn::NormalizationDescriptor::m_K
float m_K
Kappa value used for the across channel normalization equation.
Definition: Descriptors.hpp:771

-armnn::SoftmaxDescriptor::m_Axis
int m_Axis
Scalar, defaulted to the last index (-1), specifying the dimension the activation will be performed o...
Definition: Descriptors.hpp:172

-armnn::TransposeConvolution2dDescriptor
A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer.
Definition: Descriptors.hpp:1387

-armnn::Pooling3dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:463

-Tensor.hpp

-armnn::Pooling3dDescriptor::m_PoolWidth
uint32_t m_PoolWidth
Pooling width value.
Definition: Descriptors.hpp:455

-armnn::DepthwiseConvolution2dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:666

-armnn::Pooling2dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:375

-armnn::LstmDescriptor::m_ClippingThresProj
float m_ClippingThresProj
Clipping threshold value for the projection.
Definition: Descriptors.hpp:1091

-armnn::Pooling3dDescriptor::m_PoolDepth
uint32_t m_PoolDepth
Pooling depth value.
Definition: Descriptors.hpp:459

-armnn::ComparisonOperation::Equal

-armnn::swap
void swap(OriginsDescriptor &first, OriginsDescriptor &second)
Definition: Descriptors.cpp:350

-armnn::StridedSliceDescriptor::m_ShrinkAxisMask
int32_t m_ShrinkAxisMask
Shrink axis mask value. If set, the nth specification shrinks the dimensionality by 1...
Definition: Descriptors.hpp:1302

-armnn::OutputShapeRounding::Floor

-armnn::ReshapeDescriptor
A ReshapeDescriptor for the ReshapeLayer.
Definition: Descriptors.hpp:970

-armnn::NormalizationDescriptor::NormalizationDescriptor
NormalizationDescriptor()
Definition: Descriptors.hpp:739

-armnn::StridedSliceDescriptor::m_Begin
std::vector< int > m_Begin
Begin values for the input that will be sliced.
Definition: Descriptors.hpp:1289

-armnn::NullDescriptor::IsNull
bool IsNull() const override
Definition: Descriptors.hpp:32

-armnn::Convolution3dDescriptor::m_PadBack
uint32_t m_PadBack
Padding back value in the depth dimension.
Definition: Descriptors.hpp:607

-armnn::StridedSliceDescriptor::StridedSliceDescriptor
StridedSliceDescriptor()
Definition: Descriptors.hpp:1266

-armnn::PadDescriptor::m_PadValue
float m_PadValue
Optional value to use for padding, defaults to 0.
Definition: Descriptors.hpp:1168

-armnn::DepthwiseConvolution2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:678

-armnn::StridedSliceDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:1310

-armnn::ComparisonDescriptor
A ComparisonDescriptor for the ComparisonLayer.
Definition: Descriptors.hpp:89

-armnn::DetectionPostProcessDescriptor::m_ScaleX
float m_ScaleX
Center size encoding scale x.
Definition: Descriptors.hpp:727

-armnn::StackDescriptor::m_InputShape
TensorShape m_InputShape
Required shape of all input tensors.
Definition: Descriptors.hpp:1224

-armnn::FullyConnectedDescriptor::m_TransposeWeightMatrix
bool m_TransposeWeightMatrix
Enable/disable transpose weight matrix.
Definition: Descriptors.hpp:496

-armnn::FakeQuantizationDescriptor::m_Min
float m_Min
Minimum value.
Definition: Descriptors.hpp:887

-armnn::PermuteDescriptor::PermuteDescriptor
PermuteDescriptor(const PermutationVector &dimMappings)
Definition: Descriptors.hpp:135

-armnn::LogicalBinaryOperation::LogicalAnd

-armnn::Pooling2dDescriptor::m_PoolWidth
uint32_t m_PoolWidth
Pooling width value.
Definition: Descriptors.hpp:383

-armnn::QLstmDescriptor::m_PeepholeEnabled
bool m_PeepholeEnabled
Enable/disable peephole.
Definition: Descriptors.hpp:1367

-armnn::Convolution3dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:609

-armnn::Convolution2dDescriptor
A Convolution2dDescriptor for the Convolution2dLayer.
Definition: Descriptors.hpp:502

-armnn::DataType::Signed32

-armnn::NormalizationDescriptor::m_Alpha
float m_Alpha
Alpha value for the normalization equation.
Definition: Descriptors.hpp:767

-armnn::PadDescriptor::PadDescriptor
PadDescriptor(const std::vector< std::pair< unsigned int, unsigned int >> &padList, const float &padValue=0, const PaddingMode &paddingMode=PaddingMode::Constant)
Definition: Descriptors.hpp:1148

-armnn::DepthwiseConvolution2dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:660

-armnn::ReduceDescriptor::m_KeepDims
bool m_KeepDims
if true then output shape has no change.
Definition: Descriptors.hpp:1501

-armnn::QLstmDescriptor::m_HiddenStateScale
float m_HiddenStateScale
Hidden State quantization scale.
Definition: Descriptors.hpp:1383

-armnn::TransposeConvolution2dDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:1428

-armnn::BatchMatMulDescriptor::m_TransposeX
bool m_TransposeX
Transpose the slices of each input tensor Transpose and Adjoint can not both be set to true for the s...
Definition: Descriptors.hpp:1559

-armnn::TransposeConvolution2dDescriptor::m_OutputShape
std::vector< unsigned int > m_OutputShape
Definition: Descriptors.hpp:1433

-armnn::QLstmDescriptor::m_OutputIntermediateScale
float m_OutputIntermediateScale
Output intermediate quantization scale.
Definition: Descriptors.hpp:1379

-armnn::ResizeDescriptor::m_Method
ResizeMethod m_Method
The Interpolation method to use (Bilinear, NearestNeighbor).
Definition: Descriptors.hpp:959

-armnn::InstanceNormalizationDescriptor::m_Gamma
float m_Gamma
Gamma, the scale scalar value applied for the normalized tensor. Defaults to 1.0. ...
Definition: Descriptors.hpp:833

-armnn::SoftmaxDescriptor::m_Beta
float m_Beta
Exponentiation value.
Definition: Descriptors.hpp:170

-armnn::SliceDescriptor::m_Size
std::vector< unsigned int > m_Size
Size of the slice in each dimension.
Definition: Descriptors.hpp:1194

-armnn::ActivationDescriptor::ActivationDescriptor
ActivationDescriptor(armnn::ActivationFunction activation, float a=0, float b=0)
Definition: Descriptors.hpp:44

-armnn::PaddingMethod::Exclude
The padding fields don&#39;t count and are ignored.

-armnn::BatchNormalizationDescriptor::m_Eps
float m_Eps
Value to add to the variance. Used to avoid dividing by zero.
Definition: Descriptors.hpp:809

-armnn::Pooling2dDescriptor::m_PaddingMethod
PaddingMethod m_PaddingMethod
The padding method to be used. (Exclude, IgnoreValue).
Definition: Descriptors.hpp:393

-armnn::ArgMinMaxDescriptor::m_Function
ArgMinMaxFunction m_Function
Specify if the function is to find Min or Max.
Definition: Descriptors.hpp:81

-armnn::DetectionPostProcessDescriptor::m_DetectionsPerClass
uint32_t m_DetectionsPerClass
Detections per classes, used in Regular NMS.
Definition: Descriptors.hpp:717

-armnn::BatchNormalizationDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:811

-armnn::QLstmDescriptor::QLstmDescriptor
QLstmDescriptor()
Definition: Descriptors.hpp:1329

-armnn::NormalizationAlgorithmChannel
NormalizationAlgorithmChannel
Definition: Types.hpp:193

-armnn::TransposeConvolution2dDescriptor::m_OutputShapeEnabled
bool m_OutputShapeEnabled
Output shape if it has been specified.
Definition: Descriptors.hpp:1432

-armnn::BatchToSpaceNdDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:870

-armnn::BatchToSpaceNdDescriptor::BatchToSpaceNdDescriptor
BatchToSpaceNdDescriptor()
Definition: Descriptors.hpp:845

-armnn::LogicalBinaryDescriptor::LogicalBinaryDescriptor
LogicalBinaryDescriptor()
Definition: Descriptors.hpp:1467

-armnn::ActivationFunction::Abs

-armnn::BatchMatMulDescriptor::m_AdjointX
bool m_AdjointX
Adjoint the slices of each input tensor Transpose and Adjoint can not both be set to true for the sam...
Definition: Descriptors.hpp:1564

-armnn::Pooling3dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:445

-armnn::Pooling2dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:379

-armnn::ActivationFunction::Sigmoid

-armnn::Convolution3dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:603

-armnn::SliceDescriptor::SliceDescriptor
SliceDescriptor()
Definition: Descriptors.hpp:1182

-armnn::Convolution3dDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:621

-armnn::LogicalBinaryDescriptor
A LogicalBinaryDescriptor for the LogicalBinaryLayer.
Definition: Descriptors.hpp:1465

-armnn::LstmDescriptor::LstmDescriptor
LstmDescriptor()
Definition: Descriptors.hpp:1051

-armnn::Convolution2dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:536

-armnn::NormalizationDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:773

-armnn::PadDescriptor::m_PadList
std::vector< std::pair< unsigned int, unsigned int > > m_PadList
Specifies the padding for input dimension.
Definition: Descriptors.hpp:1165

-armnn::ReduceDescriptor::m_ReduceOperation
ReduceOperation m_ReduceOperation
Specifies the reduction operation to execute.
Definition: Descriptors.hpp:1505

-armnn::LstmDescriptor::m_TimeMajor
bool m_TimeMajor
Enable/disable time major.
Definition: Descriptors.hpp:1101

-armnn::BatchMatMulDescriptor::BatchMatMulDescriptor
BatchMatMulDescriptor(bool transposeX=false, bool transposeY=false, bool adjointX=false, bool adjointY=false, DataLayout dataLayoutX=DataLayout::NCHW, DataLayout dataLayoutY=DataLayout::NCHW)
Definition: Descriptors.hpp:1533

-armnn::ChannelShuffleDescriptor::ChannelShuffleDescriptor
ChannelShuffleDescriptor(const uint32_t &numGroups, const uint32_t &axis)
Definition: Descriptors.hpp:1515

-armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_quick_start.dox:6

-armnn::Pooling3dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCDHW, NDHWC).
Definition: Descriptors.hpp:471

-armnn::TransposeConvolution2dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:1422

-armnn::StridedSliceDescriptor::m_BeginMask
int32_t m_BeginMask
Begin mask value.
Definition: Descriptors.hpp:1297

-armnn::TensorShape
Definition: Tensor.hpp:20

-armnn::Pooling3dDescriptor::m_PadFront
uint32_t m_PadFront
Padding front value in the depth dimension.
Definition: Descriptors.hpp:451

-armnn::Convolution2dDescriptor::m_DilationY
uint32_t m_DilationY
Dilation along y axis.
Definition: Descriptors.hpp:548

-armnn::StridedSliceDescriptor::m_EndMask
int32_t m_EndMask
End mask value.
Definition: Descriptors.hpp:1300

-armnn::SpaceToDepthDescriptor
A SpaceToDepthDescriptor for the SpaceToDepthLayer.
Definition: Descriptors.hpp:1022

-armnn::PoolingAlgorithm
PoolingAlgorithm
Definition: Types.hpp:136

-armnn::BaseDescriptor::~BaseDescriptor
virtual ~BaseDescriptor()=default

-armnn::SpaceToBatchNdDescriptor::m_PadList
std::vector< std::pair< unsigned int, unsigned int > > m_PadList
Specifies the padding values for the input dimension: heightPad{top, bottom} widthPad{left, right}.
Definition: Descriptors.hpp:1016

-armnn::Pooling3dDescriptor::m_PoolHeight
uint32_t m_PoolHeight
Pooling height value.
Definition: Descriptors.hpp:457

-armnn::Convolution3dDescriptor::m_DilationX
uint32_t m_DilationX
Dilation along x axis.
Definition: Descriptors.hpp:615

-armnn::DepthwiseConvolution2dDescriptor::m_DilationY
uint32_t m_DilationY
Dilation factor value for height dimension.
Definition: Descriptors.hpp:674

-armnn::StridedSliceDescriptor::StridedSliceDescriptor
StridedSliceDescriptor(const std::vector< int > &begin, const std::vector< int > &end, const std::vector< int > &stride)
Definition: Descriptors.hpp:1252

-armnn::LogicalBinaryDescriptor::m_Operation
LogicalBinaryOperation m_Operation
Specifies the logical operation to execute.
Definition: Descriptors.hpp:1481

-armnn::BatchToSpaceNdDescriptor
A BatchToSpaceNdDescriptor for the BatchToSpaceNdLayer.
Definition: Descriptors.hpp:843

-armnn::Pooling2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:387

-armnn::LogicalBinaryOperation
LogicalBinaryOperation
Definition: Types.hpp:118

-armnn::PermuteDescriptor::m_DimMappings
PermutationVector m_DimMappings
Indicates how to translate tensor elements from a given source into the target destination, when source and target potentially have different memory layouts e.g.
Definition: Descriptors.hpp:153

-armnn::Convolution3dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:611

-armnn::StandInDescriptor::m_NumOutputs
uint32_t m_NumOutputs
Number of output tensors.
Definition: Descriptors.hpp:1246

-armnn::NormalizationDescriptor::m_NormMethodType
NormalizationAlgorithmMethod m_NormMethodType
Normalization method algorithm to use (LocalBrightness, LocalContrast).
Definition: Descriptors.hpp:763

-armnn::ResizeDescriptor
A ResizeDescriptor for the ResizeLayer.
Definition: Descriptors.hpp:932

-armnn::PaddingMethod
PaddingMethod
The padding method modifies the output of pooling layers.
Definition: Types.hpp:174

-armnn::L2NormalizationDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:792

-armnn::DetectionPostProcessDescriptor::m_MaxClassesPerDetection
uint32_t m_MaxClassesPerDetection
Maximum numbers of classes per detection, used in Fast NMS.
Definition: Descriptors.hpp:715

-armnn::BaseDescriptor
Base class for all descriptors.
Definition: Descriptors.hpp:22

-armnn::MeanDescriptor::m_Axis
std::vector< unsigned int > m_Axis
Values for the dimensions to reduce.
Definition: Descriptors.hpp:1137

-armnn::StackDescriptor
A StackDescriptor for the StackLayer.
Definition: Descriptors.hpp:1198

-armnn::SpaceToBatchNdDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:1018

-armnn::LstmDescriptor::m_ForgetIntermediateScale
float m_ForgetIntermediateScale
Forget intermediate quantization scale.
Definition: Descriptors.hpp:1105

-armnn::L2NormalizationDescriptor::L2NormalizationDescriptor
L2NormalizationDescriptor()
Definition: Descriptors.hpp:779

-armnn::ReshapeDescriptor::m_TargetShape
TensorShape m_TargetShape
Target shape value.
Definition: Descriptors.hpp:986

-armnn::ResizeDescriptor::ResizeDescriptor
ResizeDescriptor()
Definition: Descriptors.hpp:934

-armnn::ComparisonDescriptor::ComparisonDescriptor
ComparisonDescriptor(ComparisonOperation operation)
Definition: Descriptors.hpp:95

-armnn::Pooling2dDescriptor::m_PoolHeight
uint32_t m_PoolHeight
Pooling height value.
Definition: Descriptors.hpp:385

-armnn::ReshapeDescriptor::ReshapeDescriptor
ReshapeDescriptor()
Definition: Descriptors.hpp:972

-armnn::Convolution2dDescriptor::Convolution2dDescriptor
Convolution2dDescriptor()
Definition: Descriptors.hpp:504

-armnn::Convolution2dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:538

-armnn::DetectionPostProcessDescriptor::m_MaxDetections
uint32_t m_MaxDetections
Maximum numbers of detections.
Definition: Descriptors.hpp:713

-armnn::PadDescriptor
A PadDescriptor for the PadLayer.
Definition: Descriptors.hpp:1143

-armnn::FullyConnectedDescriptor::FullyConnectedDescriptor
FullyConnectedDescriptor()
Definition: Descriptors.hpp:477

-std
Definition: BackendId.hpp:149

-armnn::BatchMatMulDescriptor::m_DataLayoutX
DataLayout m_DataLayoutX
Data layout of each input tensor, such as NHWC/NDHWC (leave as default for arbitrary layout) ...
Definition: Descriptors.hpp:1568

-armnn::Convolution2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:542

-armnn::LstmDescriptor::m_HiddenStateZeroPoint
int32_t m_HiddenStateZeroPoint
Hidden State zero point.
Definition: Descriptors.hpp:1111

-armnn::ComparisonOperation
ComparisonOperation
Definition: Types.hpp:108

-armnn::Pooling3dDescriptor::m_PadBack
uint32_t m_PadBack
Padding back value in the depth dimension.
Definition: Descriptors.hpp:453

-armnn::DataLayout::NCDHW

-armnn::DepthwiseConvolution2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:668

-armnn::ReduceOperation
ReduceOperation
Definition: Types.hpp:143

-armnnUtils::operator==
bool operator==(const armnn::DataLayout &dataLayout, const DataLayoutIndexed &indexed)
Equality methods.
Definition: DataLayoutIndexed.cpp:46

-armnn::NullDescriptor
Null Descriptor used as a return value from the IConnectableLayer GetParameters method by layers whic...
Definition: Descriptors.hpp:30

-armnn::QLstmDescriptor::m_LayerNormEnabled
bool m_LayerNormEnabled
Enable/disable layer normalization.
Definition: Descriptors.hpp:1371

-armnn::GetNumInputs
uint32_t GetNumInputs(bool biasEnabled)
Definition: Descriptors.cpp:428

-armnn::DataType
DataType
Definition: Types.hpp:48

-armnn::DetectionPostProcessDescriptor::m_NmsIouThreshold
float m_NmsIouThreshold
Intersection over union threshold.
Definition: Descriptors.hpp:721

-armnn::LstmDescriptor::m_CellIntermediateScale
float m_CellIntermediateScale
Cell intermediate quantization scale.
Definition: Descriptors.hpp:1107

-armnn::TransposeDescriptor::TransposeDescriptor
TransposeDescriptor(const PermutationVector &dimMappings)
Definition: Descriptors.hpp:1443

-armnn::LstmDescriptor
An LstmDescriptor for the LstmLayer.
Definition: Descriptors.hpp:1049

-armnn::Pooling2dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:377

-armnn::DepthwiseConvolution2dDescriptor::m_DilationX
uint32_t m_DilationX
Dilation factor value for width dimension.
Definition: Descriptors.hpp:672

-armnn::DepthwiseConvolution2dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:664

-armnn::SliceDescriptor::m_Begin
std::vector< unsigned int > m_Begin
Beginning indices of the slice in each dimension.
Definition: Descriptors.hpp:1191

-armnn::StridedSliceDescriptor::m_NewAxisMask
int32_t m_NewAxisMask
New axis mask value.
Definition: Descriptors.hpp:1307

-armnn::MeanDescriptor::m_KeepDims
bool m_KeepDims
Enable/disable keep dimensions. If true, then the reduced dimensions that are of length 1 are kept...
Definition: Descriptors.hpp:1139

-armnn::BatchToSpaceNdDescriptor::m_BlockShape
std::vector< unsigned int > m_BlockShape
Block shape values.
Definition: Descriptors.hpp:866

-armnn::ArgMinMaxFunction::Max

-armnn::InstanceNormalizationDescriptor::m_Eps
float m_Eps
Epsilon, small scalar value added to variance to avoid dividing by zero. Defaults to 1e-12f...
Definition: Descriptors.hpp:837

-armnn::Pooling3dDescriptor::Pooling3dDescriptor
Pooling3dDescriptor()
Definition: Descriptors.hpp:401

-armnn::L2NormalizationDescriptor
A L2NormalizationDescriptor for the L2NormalizationLayer.
Definition: Descriptors.hpp:777

-armnn::ArgMinMaxDescriptor
An ArgMinMaxDescriptor for ArgMinMaxLayer.
Definition: Descriptors.hpp:67

-armnn::ActivationDescriptor::ActivationDescriptor
ActivationDescriptor()
Definition: Descriptors.hpp:38

-armnn::OriginsDescriptor
An OriginsDescriptor for the ConcatLayer.
Definition: Descriptors.hpp:181

-armnn::ReduceDescriptor
A ReduceDescriptor for the REDUCE operators.
Definition: Descriptors.hpp:1485

-armnn::QLstmDescriptor::m_ProjectionClip
float m_ProjectionClip
Clipping threshold value for the projection.
Definition: Descriptors.hpp:1363

-Types.hpp

-armnn::FullyConnectedDescriptor
A FullyConnectedDescriptor for the FullyConnectedLayer.
Definition: Descriptors.hpp:475

-armnn::TransposeDescriptor::TransposeDescriptor
TransposeDescriptor()
Definition: Descriptors.hpp:1439

-armnn::ChannelShuffleDescriptor::ChannelShuffleDescriptor
ChannelShuffleDescriptor()
Definition: Descriptors.hpp:1511

-armnn::StridedSliceDescriptor::m_EllipsisMask
int32_t m_EllipsisMask
Ellipsis mask value.
Definition: Descriptors.hpp:1304

-armnn::FullyConnectedDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:494

-armnn::PadDescriptor::PadDescriptor
PadDescriptor()
Definition: Descriptors.hpp:1145

-armnn::QLstmDescriptor::m_InputIntermediateScale
float m_InputIntermediateScale
Input intermediate quantization scale.
Definition: Descriptors.hpp:1373

-armnn::Pooling3dDescriptor::m_OutputShapeRounding
OutputShapeRounding m_OutputShapeRounding
The rounding method for the output shape. (Floor, Ceiling).
Definition: Descriptors.hpp:467

-armnn::FakeQuantizationDescriptor
A FakeQuantizationDescriptor for the FakeQuantizationLayer.
Definition: Descriptors.hpp:874

-armnn::DepthwiseConvolution2dDescriptor::DepthwiseConvolution2dDescriptor
DepthwiseConvolution2dDescriptor()
Definition: Descriptors.hpp:629

-armnn::SpaceToBatchNdDescriptor::SpaceToBatchNdDescriptor
SpaceToBatchNdDescriptor()
Definition: Descriptors.hpp:992

-armnn::ResizeDescriptor::m_TargetWidth
uint32_t m_TargetWidth
Target width value.
Definition: Descriptors.hpp:954

-armnn::GatherDescriptor
A GatherDescriptor for the GatherLayer.
Definition: Descriptors.hpp:912

-armnn::Pooling3dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:449

-armnn::LstmDescriptor::m_PeepholeEnabled
bool m_PeepholeEnabled
Enable/disable peephole.
Definition: Descriptors.hpp:1095

-armnn::Status
Status
enumeration
Definition: Types.hpp:42

-armnn::DetectionPostProcessDescriptor::m_NumClasses
uint32_t m_NumClasses
Number of classes.
Definition: Descriptors.hpp:723

-armnn::ResizeDescriptor::m_HalfPixelCenters
bool m_HalfPixelCenters
Half Pixel Centers.
Definition: Descriptors.hpp:965

-armnn::LstmDescriptor::m_InputIntermediateScale
float m_InputIntermediateScale
Input intermediate quantization scale.
Definition: Descriptors.hpp:1103

-armnn::TransposeConvolution2dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:1420

-armnn::StandInDescriptor
A StandInDescriptor for the StandIn layer.
Definition: Descriptors.hpp:1228

-armnn::QLstmDescriptor
A QLstmDescriptor for the QLstmLayer.
Definition: Descriptors.hpp:1327

-armnn::BatchMatMulDescriptor::m_TransposeY
bool m_TransposeY
Definition: Descriptors.hpp:1560

-armnn::PreCompiledDescriptor::m_NumInputSlots
unsigned int m_NumInputSlots
Definition: Descriptors.hpp:1322

-armnn::DetectionPostProcessDescriptor::m_UseRegularNms
bool m_UseRegularNms
Use Regular NMS.
Definition: Descriptors.hpp:725

-armnn::Convolution3dDescriptor::m_PadFront
uint32_t m_PadFront
Padding front value in the depth dimension.
Definition: Descriptors.hpp:605

-armnn::TransposeConvolution2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:1430

-armnn::SpaceToBatchNdDescriptor::m_BlockShape
std::vector< unsigned int > m_BlockShape
Block shape value.
Definition: Descriptors.hpp:1013

-armnn::StridedSliceDescriptor::m_Stride
std::vector< int > m_Stride
Stride values for the input that will be sliced.
Definition: Descriptors.hpp:1293

-armnn::PaddingMode
PaddingMode
The padding mode controls whether the padding should be filled with constant values (Constant)...
Definition: Types.hpp:186

-armnn::ActivationDescriptor
An ActivationDescriptor for the ActivationLayer.
Definition: Descriptors.hpp:36

-armnn::SpaceToBatchNdDescriptor::SpaceToBatchNdDescriptor
SpaceToBatchNdDescriptor(const std::vector< unsigned int > &blockShape, const std::vector< std::pair< unsigned int, unsigned int >> &padList)
Definition: Descriptors.hpp:998

-armnn::InvalidArgumentException
Definition: Exceptions.hpp:80

-armnn::StackDescriptor::m_NumInputs
uint32_t m_NumInputs
Number of input tensors.
Definition: Descriptors.hpp:1222

-armnn::Convolution3dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:597

-armnn::ResizeDescriptor::m_TargetHeight
uint32_t m_TargetHeight
Target height value.
Definition: Descriptors.hpp:956

-armnn::LstmDescriptor::m_ActivationFunc
uint32_t m_ActivationFunc
The activation function to use.
Definition: Descriptors.hpp:1087

-armnn::SliceDescriptor
A SliceDescriptor for the SliceLayer.
Definition: Descriptors.hpp:1175

-armnn::PermutationVector
Definition: Types.hpp:295

-armnn::Convolution2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:544

-armnn::ElementwiseUnaryDescriptor::ElementwiseUnaryDescriptor
ElementwiseUnaryDescriptor()
Definition: Descriptors.hpp:111

-armnn::Convolution3dDescriptor
A Convolution3dDescriptor for the Convolution3dLayer.
Definition: Descriptors.hpp:556

-armnn::Convolution3dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:599

-armnn::LstmDescriptor::m_ClippingThresCell
float m_ClippingThresCell
Clipping threshold value for the cell state.
Definition: Descriptors.hpp:1089

-armnn::SpaceToDepthDescriptor::m_BlockSize
unsigned int m_BlockSize
Scalar specifying the input block size. It must be >= 1.
Definition: Descriptors.hpp:1039

-armnn::ChannelShuffleDescriptor::m_NumGroups
uint32_t m_NumGroups
Number of groups for the channel shuffle operation.
Definition: Descriptors.hpp:1525

-armnn::BatchMatMulDescriptor
A BatchMatMulDescriptor for the BatchMatMul operator.
Definition: Descriptors.hpp:1531

-armnn::PadDescriptor::m_PaddingMode
PaddingMode m_PaddingMode
Specifies the Padding mode (Constant, Reflect or Symmetric)
Definition: Descriptors.hpp:1171

-armnn::InstanceNormalizationDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:839

-armnn::SoftmaxDescriptor::SoftmaxDescriptor
SoftmaxDescriptor()
Definition: Descriptors.hpp:159

-armnn::QLstmDescriptor::m_ForgetIntermediateScale
float m_ForgetIntermediateScale
Forget intermediate quantization scale.
Definition: Descriptors.hpp:1375

-armnn::Pooling2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:395

-armnn::InstanceNormalizationDescriptor::m_Beta
float m_Beta
Beta, the offset scalar value applied for the normalized tensor. Defaults to 1.0. ...
Definition: Descriptors.hpp:835

-armnn::LstmDescriptor::m_HiddenStateScale
float m_HiddenStateScale
Hidden State quantization scale.
Definition: Descriptors.hpp:1113

-armnn::InstanceNormalizationDescriptor::InstanceNormalizationDescriptor
InstanceNormalizationDescriptor()
Definition: Descriptors.hpp:817

-armnn::Pooling3dDescriptor
A Pooling3dDescriptor for the Pooling3dLayer.
Definition: Descriptors.hpp:399

-armnn::Pooling3dDescriptor::m_StrideZ
uint32_t m_StrideZ
Stride value when proceeding through input for the depth dimension.
Definition: Descriptors.hpp:465

-armnn::ReduceDescriptor::m_vAxis
std::vector< uint32_t > m_vAxis
The indices of the dimensions to reduce.
Definition: Descriptors.hpp:1503

-armnn::DetectionPostProcessDescriptor::m_ScaleH
float m_ScaleH
Center size encoding scale height.
Definition: Descriptors.hpp:733

-armnn::ComparisonDescriptor::m_Operation
ComparisonOperation m_Operation
Specifies the comparison operation to execute.
Definition: Descriptors.hpp:105

-armnn::StridedSliceDescriptor::m_End
std::vector< int > m_End
End values for the input that will be sliced.
Definition: Descriptors.hpp:1291

-armnn::SpaceToBatchNdDescriptor
A SpaceToBatchNdDescriptor for the SpaceToBatchNdLayer.
Definition: Descriptors.hpp:990

-armnn::OutputShapeRounding
OutputShapeRounding
Definition: Types.hpp:207

-armnn::Convolution3dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NDHWC, NCDHW).
Definition: Descriptors.hpp:623

-armnn::NormalizationDescriptor::m_NormChannelType
NormalizationAlgorithmChannel m_NormChannelType
Normalization channel algorithm to use (Across, Within).
Definition: Descriptors.hpp:761

-armnn::QLstmDescriptor::m_CellClip
float m_CellClip
Clipping threshold value for the cell state.
Definition: Descriptors.hpp:1361

-ARMNN_DEPRECATED_MSG_REMOVAL_DATE
#define ARMNN_DEPRECATED_MSG_REMOVAL_DATE(message, removed_in_release)
Definition: Deprecated.hpp:44

-armnn::ActivationDescriptor::m_A
float m_A
Alpha upper bound value used by the activation functions. (BoundedReLu, Linear, TanH, Elu).
Definition: Descriptors.hpp:61

-armnn::FillDescriptor::m_Value
float m_Value
Definition: Descriptors.hpp:908

-armnn::Convolution2dDescriptor::m_DilationX
uint32_t m_DilationX
Dilation along x axis.
Definition: Descriptors.hpp:546

-armnn::FillDescriptor::FillDescriptor
FillDescriptor(const float &value)
Definition: Descriptors.hpp:899

-armnn::SpaceToDepthDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:1042

-Deprecated.hpp

-armnn::LstmDescriptor::m_CifgEnabled
bool m_CifgEnabled
Enable/disable cifg (coupled input & forget gate).
Definition: Descriptors.hpp:1093

-armnn::StandInDescriptor::StandInDescriptor
StandInDescriptor(uint32_t numInputs, uint32_t numOutputs)
Definition: Descriptors.hpp:1232

-armnn::TransposeConvolution2dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:1416

-armnn::ResizeDescriptor::m_AlignCorners
bool m_AlignCorners
Aligned corners.
Definition: Descriptors.hpp:963

-armnn::TransposeConvolution2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:1424

-armnn::GatherDescriptor::m_Axis
int32_t m_Axis
The axis in params to gather indices from.
Definition: Descriptors.hpp:928

-armnn::ElementwiseUnaryDescriptor
A ElementwiseUnaryDescriptor for the ElementwiseUnaryLayer.
Definition: Descriptors.hpp:109

-armnn::Pooling2dDescriptor::m_PoolType
PoolingAlgorithm m_PoolType
The pooling algorithm to use (Max. Average, L2).
Definition: Descriptors.hpp:373

-armnn::DepthwiseConvolution2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:670

-armnn::TransposeConvolution2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:1426

-armnn::Pooling3dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:443

-armnn::SpaceToDepthDescriptor::SpaceToDepthDescriptor
SpaceToDepthDescriptor()
Definition: Descriptors.hpp:1024

-armnn::SpaceToDepthDescriptor::SpaceToDepthDescriptor
SpaceToDepthDescriptor(unsigned int blockSize, DataLayout dataLayout)
Definition: Descriptors.hpp:1028

-armnn::BatchToSpaceNdDescriptor::m_Crops
std::vector< std::pair< unsigned int, unsigned int > > m_Crops
The values to crop from the input dimension.
Definition: Descriptors.hpp:868

-Exceptions.hpp

-armnn::Convolution3dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:601

-armnn::Pooling3dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:447

-armnn::QLstmDescriptor::m_ProjectionEnabled
bool m_ProjectionEnabled
Enable/disable the projection layer.
Definition: Descriptors.hpp:1369

-armnn::ArgMinMaxFunction
ArgMinMaxFunction
Definition: Types.hpp:102

-armnn::Pooling2dDescriptor::m_OutputShapeRounding
OutputShapeRounding m_OutputShapeRounding
The rounding method for the output shape. (Floor, Ceiling).
Definition: Descriptors.hpp:391

-armnn::StandInDescriptor::m_NumInputs
uint32_t m_NumInputs
Number of input tensors.
Definition: Descriptors.hpp:1244

-armnn::FakeQuantizationDescriptor::FakeQuantizationDescriptor
FakeQuantizationDescriptor()
Definition: Descriptors.hpp:876

-armnn::OriginsDescriptor::SetConcatAxis
void SetConcatAxis(unsigned int concatAxis)
Set the concatenation axis value.
Definition: Descriptors.cpp:158

-armnn::ResizeMethod
ResizeMethod
Definition: Types.hpp:152

-armnn::MeanDescriptor
A MeanDescriptor for the MeanLayer.
Definition: Descriptors.hpp:1119

-armnn::UnaryOperation
UnaryOperation
Definition: Types.hpp:124

-armnn::Convolution3dDescriptor::Convolution3dDescriptor
Convolution3dDescriptor()
Definition: Descriptors.hpp:558

-armnn::LstmDescriptor::m_LayerNormEnabled
bool m_LayerNormEnabled
Enable/disable layer normalization.
Definition: Descriptors.hpp:1099

-armnn::TransposeConvolution2dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:1418

-armnn::TransposeDescriptor
A TransposeDescriptor for the TransposeLayer.
Definition: Descriptors.hpp:1437

-armnn::StridedSliceDescriptor
A StridedSliceDescriptor for the StridedSliceLayer.
Definition: Descriptors.hpp:1250

-armnn::ChannelShuffleDescriptor::m_Axis
uint32_t m_Axis
Axis to apply channel shuffle operation on.
Definition: Descriptors.hpp:1527

-armnn::ResizeMethod::NearestNeighbor

-armnn::ArgMinMaxDescriptor::m_Axis
int m_Axis
Axis to reduce across the input tensor.
Definition: Descriptors.hpp:83

-armnn::ReduceOperation::Sum

-armnn::DetectionPostProcessDescriptor::m_ScaleY
float m_ScaleY
Center size encoding scale y.
Definition: Descriptors.hpp:729

-armnn::CreateDescriptorForConcatenation
OriginsDescriptor CreateDescriptorForConcatenation(TensorShapeIt first, TensorShapeIt last, unsigned int concatenationDimension)
Convenience template to create an OriginsDescriptor to use when creating a ConcatLayer for performing...
Definition: Descriptors.hpp:268

-armnn::DetectionPostProcessDescriptor::m_NmsScoreThreshold
float m_NmsScoreThreshold
NMS score threshold.
Definition: Descriptors.hpp:719

-armnn::ArgMinMaxDescriptor::ArgMinMaxDescriptor
ArgMinMaxDescriptor()
Definition: Descriptors.hpp:69

-armnn::PreCompiledDescriptor
A PreCompiledDescriptor for the PreCompiledLayer.
Definition: Descriptors.hpp:1314

-armnn::GatherDescriptor::GatherDescriptor
GatherDescriptor(int32_t axis)
Definition: Descriptors.hpp:918

-DescriptorsFwd.hpp

-armnn::DataLayout::NCHW

-armnn::NormalizationAlgorithmMethod::LocalBrightness
Krichevsky 2012: Local Brightness Normalization.

-armnn::Pooling2dDescriptor
A Pooling2dDescriptor for the Pooling2dLayer.
Definition: Descriptors.hpp:339

-armnn::NormalizationAlgorithmChannel::Across

-armnn::NormalizationDescriptor
A NormalizationDescriptor for the NormalizationLayer.
Definition: Descriptors.hpp:737

-armnn::StandInDescriptor::StandInDescriptor
StandInDescriptor()
Definition: Descriptors.hpp:1230

-armnn::Pooling3dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:461

-armnn::ResizeDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:961

-armnn::DetectionPostProcessDescriptor
Definition: Descriptors.hpp:681

-armnn::InstanceNormalizationDescriptor
An InstanceNormalizationDescriptor for InstanceNormalizationLayer.
Definition: Descriptors.hpp:815

-armnn::Pooling3dDescriptor::m_PaddingMethod
PaddingMethod m_PaddingMethod
The padding method to be used. (Exclude, IgnoreValue).
Definition: Descriptors.hpp:469

-armnn::NormalizationAlgorithmMethod
NormalizationAlgorithmMethod
Definition: Types.hpp:199

-armnn::PaddingMode::Constant

-armnn::PreCompiledDescriptor::m_NumOutputSlots
unsigned int m_NumOutputSlots
Definition: Descriptors.hpp:1323

-armnn::ChannelShuffleDescriptor
A ChannelShuffleDescriptor for the ChannelShuffle operator.
Definition: Descriptors.hpp:1509

-armnn::GatherDescriptor::GatherDescriptor
GatherDescriptor()
Definition: Descriptors.hpp:914

-armnn::StackDescriptor::StackDescriptor
StackDescriptor(uint32_t axis, uint32_t numInputs, const TensorShape &inputShape)
Definition: Descriptors.hpp:1206

-armnn::ReshapeDescriptor::ReshapeDescriptor
ReshapeDescriptor(const TensorShape &shape)
Definition: Descriptors.hpp:976

-armnn::QLstmDescriptor::m_CellIntermediateScale
float m_CellIntermediateScale
Cell intermediate quantization scale.
Definition: Descriptors.hpp:1377

-armnn::DataLayout::NDHWC

-armnn::LogicalBinaryDescriptor::LogicalBinaryDescriptor
LogicalBinaryDescriptor(LogicalBinaryOperation operation)
Definition: Descriptors.hpp:1471

-armnn::DetectionPostProcessDescriptor::DetectionPostProcessDescriptor
DetectionPostProcessDescriptor()
Definition: Descriptors.hpp:683

-armnn::Convolution3dDescriptor::m_DilationZ
uint32_t m_DilationZ
Dilation along z axis.
Definition: Descriptors.hpp:619

-armnn::ActivationDescriptor::m_B
float m_B
Beta lower bound value used by the activation functions. (BoundedReLu, Linear, TanH).
Definition: Descriptors.hpp:63

-armnn::SoftmaxDescriptor
A SoftmaxDescriptor for the SoftmaxLayer.
Definition: Descriptors.hpp:157

-armnn::NormalizationDescriptor::m_Beta
float m_Beta
Beta value for the normalization equation.
Definition: Descriptors.hpp:769

-armnn::FakeQuantizationDescriptor::m_Max
float m_Max
Maximum value.
Definition: Descriptors.hpp:889

-armnn::BaseDescriptor::IsNull
virtual bool IsNull() const
Definition: Descriptors.hpp:24

-armnn::Convolution3dDescriptor::m_StrideZ
uint32_t m_StrideZ
Stride value when proceeding through input for the depth dimension.
Definition: Descriptors.hpp:613

-armnn::StackDescriptor::StackDescriptor
StackDescriptor()
Definition: Descriptors.hpp:1200

-armnn::BatchToSpaceNdDescriptor::BatchToSpaceNdDescriptor
BatchToSpaceNdDescriptor(std::vector< unsigned int > blockShape, std::vector< std::pair< unsigned int, unsigned int >> crops)
Definition: Descriptors.hpp:851

-armnn::QLstmDescriptor::m_CifgEnabled
bool m_CifgEnabled
Enable/disable CIFG (coupled input & forget gate).
Definition: Descriptors.hpp:1365

-armnn::TransposeDescriptor::m_DimMappings
PermutationVector m_DimMappings
Indicates how to translate tensor elements from a given source into the target destination, when source and target potentially have different memory layouts e.g.
Definition: Descriptors.hpp:1461

-armnn::NormalizationDescriptor::m_NormSize
uint32_t m_NormSize
Depth radius value.
Definition: Descriptors.hpp:765

-armnn::ActivationDescriptor::m_Function
ActivationFunction m_Function
The activation function to use (Sigmoid, TanH, Linear, ReLu, BoundedReLu, SoftReLu, LeakyReLu, Abs, Sqrt, Square, Elu).
Definition: Descriptors.hpp:59

-armnn::ArgMinMaxDescriptor::m_Output_Type
armnn::DataType m_Output_Type
Deprecated and will be removed in future release.
Definition: Descriptors.hpp:85

-armnn::FillDescriptor::FillDescriptor
FillDescriptor()
Definition: Descriptors.hpp:895

-armnn::Pooling2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:389

-armnn::DepthwiseConvolution2dDescriptor
A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
Definition: Descriptors.hpp:627

-armnn::Convolution3dDescriptor::m_DilationY
uint32_t m_DilationY
Dilation along y axis.
Definition: Descriptors.hpp:617

-armnn::FillDescriptor
A FillDescriptor for the FillLayer.
Definition: Descriptors.hpp:893

-armnn::BatchNormalizationDescriptor
A BatchNormalizationDescriptor for the BatchNormalizationLayer.
Definition: Descriptors.hpp:796

-armnn::Convolution2dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:534

-armnn::DataLayout::NHWC

-armnn::ActivationFunction
ActivationFunction
Definition: Types.hpp:86

-armnn::OriginsDescriptor::SetViewOriginCoord
Status SetViewOriginCoord(uint32_t view, uint32_t coord, uint32_t value)
Set the view origin coordinates.
Definition: Descriptors.cpp:167

-armnn::ArgMinMaxFunction::Min

-armnn::ReduceDescriptor::ReduceDescriptor
ReduceDescriptor()
Definition: Descriptors.hpp:1487

-armnn::PermuteDescriptor
A PermuteDescriptor for the PermuteLayer.
Definition: Descriptors.hpp:129

-armnn::DepthwiseConvolution2dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:662

-armnn::QLstmDescriptor::m_HiddenStateZeroPoint
int32_t m_HiddenStateZeroPoint
Hidden State zero point.
Definition: Descriptors.hpp:1381

-armnn::LstmDescriptor::m_OutputIntermediateScale
float m_OutputIntermediateScale
Output intermediate quantization scale.
Definition: Descriptors.hpp:1109

-armnn::FullyConnectedDescriptor::m_ConstantWeights
bool m_ConstantWeights
Enable/disable constant weights and biases.
Definition: Descriptors.hpp:498

-armnn::BatchNormalizationDescriptor::BatchNormalizationDescriptor
BatchNormalizationDescriptor()
Definition: Descriptors.hpp:798

+Go to the documentation of this file. //

+ // Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved.

+ // SPDX-License-Identifier: MIT

+ //

+ #pragma once

+

+ #include "Deprecated.hpp"

+ #include "DescriptorsFwd.hpp" // Required for class equivalence declarations.

+ #include "Tensor.hpp"

+ #include "Types.hpp"

+ #include <armnn/Exceptions.hpp>

+

+ #include <cstdint>

+ #include <iterator>

+ #include <utility>

+ #include <vector>

+

+ namespace armnn

+ {

+

+ /// Base class for all descriptors.

+ struct BaseDescriptor

+ {

+     virtual bool IsNull() const { return false; }

+     virtual ~BaseDescriptor() = default;

+ };

+

+ /// Null Descriptor used as a return value from the IConnectableLayer GetParameters method

+ /// by layers which do not have a descriptor

+ struct NullDescriptor : BaseDescriptor

+ {

+     bool IsNull() const override { return true; }

+ };

+

+ /// An ActivationDescriptor for the ActivationLayer.

+ struct ActivationDescriptor : BaseDescriptor

+ {

+     ActivationDescriptor()

+         : m_Function(ActivationFunction::Sigmoid)

+         , m_A(0)

+         , m_B(0)

+     {}

+

+     ActivationDescriptor(armnn::ActivationFunction activation,

+                          float a = 0,

+                          float b = 0)

+             : m_Function(activation)

+             , m_A(a)

+             , m_B(b)

+     {}

+

+     bool operator ==(const ActivationDescriptor &rhs) const

+     {

+         return m_Function == rhs.m_Function && m_A == rhs.m_B && m_B == rhs.m_B;

+     }

+

+     /// @brief The activation function to use

+     /// (Sigmoid, TanH, Linear, ReLu, BoundedReLu, SoftReLu, LeakyReLu, Abs, Sqrt, Square, Elu).

+     ActivationFunction m_Function;

+     /// Alpha upper bound value used by the activation functions. (BoundedReLu, Linear, TanH, Elu).

+     float              m_A;

+     /// Beta lower bound value used by the activation functions. (BoundedReLu, Linear, TanH).

+     float              m_B;

+ };

+

+ /// An ArgMinMaxDescriptor for ArgMinMaxLayer

+ struct ArgMinMaxDescriptor : BaseDescriptor

+ {

+     ArgMinMaxDescriptor()

+         : m_Function(ArgMinMaxFunction::Min)

+         , m_Axis(-1)

+         , m_Output_Type(armnn::DataType::Signed32)

+     {}

+

+     bool operator ==(const ArgMinMaxDescriptor &rhs) const

+     {

+         return m_Function == rhs.m_Function && m_Axis == rhs.m_Axis && m_Output_Type == rhs.m_Output_Type;

+     }

+

+     /// Specify if the function is to find Min or Max.

+     ArgMinMaxFunction m_Function;

+     /// Axis to reduce across the input tensor.

+     int m_Axis;

+     /// Deprecated and will be removed in future release.

+     armnn::DataType m_Output_Type;

+ };

+

+ /// A ComparisonDescriptor for the ComparisonLayer

+ struct ComparisonDescriptor : BaseDescriptor

+ {

+     ComparisonDescriptor()

+         : ComparisonDescriptor(ComparisonOperation::Equal)

+     {}

+

+     ComparisonDescriptor(ComparisonOperation operation)

+         : m_Operation(operation)

+     {}

+

+     bool operator ==(const ComparisonDescriptor &rhs) const

+     {

+         return m_Operation == rhs.m_Operation;

+     }

+

+     /// Specifies the comparison operation to execute

+     ComparisonOperation m_Operation;

+ };

+

+ /// A ElementwiseUnaryDescriptor for the ElementwiseUnaryLayer

+ struct ElementwiseUnaryDescriptor : BaseDescriptor

+ {

+     ElementwiseUnaryDescriptor()

+         : ElementwiseUnaryDescriptor(UnaryOperation::Abs)

+     {}

+

+     ElementwiseUnaryDescriptor(UnaryOperation operation)

+         : m_Operation(operation)

+     {}

+

+     bool operator ==(const ElementwiseUnaryDescriptor &rhs) const

+     {

+         return m_Operation == rhs.m_Operation;

+     }

+

+     /// Specifies the elementwiseUnary operation to execute

+     UnaryOperation m_Operation;

+ };

+

+ /// A PermuteDescriptor for the PermuteLayer.

+ struct PermuteDescriptor : BaseDescriptor

+ {

+     PermuteDescriptor()

+         : m_DimMappings{}

+     {}

+

+     PermuteDescriptor(const PermutationVector& dimMappings)

+         : m_DimMappings(dimMappings)

+     {}

+

+     bool operator ==(const PermuteDescriptor &rhs) const

+     {

+         return m_DimMappings.IsEqual(rhs.m_DimMappings);

+     }

+

+     /// @brief Indicates how to translate tensor elements from a given source into the target destination, when

+     /// source and target potentially have different memory layouts e.g.

+     /// Input Shape        {1, 1, 4, 4}

+     /// Permutation Vector {0, 2, 3, 1}

+     /// Output Shape       {1, 4, 1, 4}

+     /// dim "0" goes into index 0 ([ 1, X, X, X ])

+     /// dim "1" goes into index 2 ([ 1, X, 1, X ])

+     /// dim "2" goes into index 3 ([ 1, X, 1, 4 ])

+     /// dim "3" goes into index 1 ([ 1, 4, 1, 4 ])

+     PermutationVector m_DimMappings;

+ };

+

+ /// A SoftmaxDescriptor for the SoftmaxLayer.

+ struct SoftmaxDescriptor : BaseDescriptor

+ {

+     SoftmaxDescriptor()

+         : m_Beta(1.0f)

+         , m_Axis(-1)

+     {}

+

+     bool operator ==(const SoftmaxDescriptor& rhs) const

+     {

+         return m_Beta == rhs.m_Beta && m_Axis == rhs.m_Axis;

+     }

+

+     /// Exponentiation value.

+     float m_Beta;

+     /// Scalar, defaulted to the last index (-1), specifying the dimension the activation will be performed on.

+     int m_Axis;

+ };

+

+ /// A LogSoftmaxDescriptor for the LogSoftmaxLayer

+ using LogSoftmaxDescriptor = SoftmaxDescriptor;

+

+ /// @brief An OriginsDescriptor for the ConcatLayer.

+ /// Descriptor to configure the concatenation process. Number of views must be equal to the number of inputs, and

+ /// their order must match - e.g. first view corresponds to the first input, second view to the second input, etc.

+ struct OriginsDescriptor : BaseDescriptor

+ {

+     OriginsDescriptor();

+     OriginsDescriptor(uint32_t numViews, uint32_t numDimensions = 4);

+     OriginsDescriptor(const OriginsDescriptor& other);

+     OriginsDescriptor(OriginsDescriptor&& other);

+

+     ~OriginsDescriptor();

+

+     OriginsDescriptor& operator=(OriginsDescriptor rhs);

+

+     bool operator ==(const OriginsDescriptor& rhs) const;

+

+     /// @Brief Set the view origin coordinates. The arguments are: view, dimension, value.

+     /// If the view is greater than or equal to GetNumViews(), then the view argument is out of range.

+     /// If the coord is greater than or equal to GetNumDimensions(), then the coord argument is out of range.

+     Status SetViewOriginCoord(uint32_t view, uint32_t coord, uint32_t value);

+     /// Get the number of views.

+     uint32_t GetNumViews() const;

+     /// Get the number of dimensions.

+     uint32_t GetNumDimensions() const;

+     /// Return the view origin at the int value idx.

+     const uint32_t* GetViewOrigin(uint32_t idx) const;

+     /// @brief Reorders the viewOrigins in accordance with the indices presented in newOrdering array.

+     /// The number of views must match number of elements in the new ordering array.

+     void ReorderOrigins(unsigned int*  newOrdering, unsigned int numNewOrdering);

+     /// Swap the ViewsDescriptor values first and second.

+     friend void swap(OriginsDescriptor& first, OriginsDescriptor& second);

+     /// Set the concatenation axis value.

+     void SetConcatAxis(unsigned int concatAxis);

+     /// Get the concatenation axis value.

+     unsigned int GetConcatAxis() const;

+

+ private:

+     unsigned int m_ConcatAxis;

+     uint32_t     m_NumViews;

+     uint32_t     m_NumDimensions;

+     uint32_t**   m_ViewOrigins;

+ };

+

+ /// @brief A ViewsDescriptor for the SplitterLayer.

+ /// Descriptor to configure the splitting process. Number of Views must be equal to the number of outputs, and

+ /// their order must match - e.g. first view corresponds to the first output, second view to the second output, etc.

+ struct ViewsDescriptor : BaseDescriptor

+ {

+     ViewsDescriptor(uint32_t numViews, uint32_t numDimensions = 4);

+     ViewsDescriptor(const ViewsDescriptor& other);

+     ViewsDescriptor();

+     ViewsDescriptor(ViewsDescriptor&& other);

+

+     ~ViewsDescriptor();

+

+     ViewsDescriptor& operator=(ViewsDescriptor rhs);

+

+     bool operator ==(const ViewsDescriptor& rhs) const;

+

+     /// @Brief Set the view origin coordinates. The arguments are: view, dimension, value.

+     /// If the view is greater than or equal to GetNumViews(), then the view argument is out of range.

+     /// If the coord is greater than or equal to GetNumDimensions(), then the coord argument is out of range.

+     Status SetViewOriginCoord(uint32_t view, uint32_t coord, uint32_t value);

+     /// @brief Set the size of the views. The arguments are: view, dimension, value.

+     /// If the view is greater than or equal to GetNumViews(), then the view argument is out of range.

+     /// If the coord is greater than or equal to GetNumDimensions(), then the coord argument is out of range.

+     Status SetViewSize(uint32_t view, uint32_t coord, uint32_t value);

+

+     /// Get the number of views.

+     uint32_t GetNumViews() const;

+     /// Get the number of dimensions.

+     uint32_t GetNumDimensions() const;

+     /// Get the view origin at the int value idx.

+     const uint32_t* GetViewOrigin(uint32_t idx) const;

+     /// Get the view sizes at the int value idx.

+     const uint32_t* GetViewSizes(uint32_t idx) const;

+     /// Get the View Origins

+     const OriginsDescriptor& GetOrigins() const;

+

+     /// Swap the ViewsDescriptor value first and second.

+     friend void swap(ViewsDescriptor& first, ViewsDescriptor& second);

+ private:

+     OriginsDescriptor m_Origins;

+     uint32_t**        m_ViewSizes;

+ };

+

+

+ /// @brief Convenience template to create an OriginsDescriptor to use when creating a ConcatLayer for performing

+ /// concatenation of a number of input tensors.

+ template <typename TensorShapeIt>

+ OriginsDescriptor CreateDescriptorForConcatenation(TensorShapeIt first,

+                                                    TensorShapeIt last,

+                                                    unsigned int concatenationDimension)

+ {

+     auto numInputs = std::distance(first, last);

+

+     if (numInputs < 2)

+     {

+         throw InvalidArgumentException("Concatenation requires at least 2 inputs");

+     }

+

+     const auto& firstInputShape = *first;

+

+     const unsigned int numDimensions = firstInputShape.GetNumDimensions();

+     for (auto it = first + 1; it != last; ++it)

+     {

+         if (it->GetNumDimensions() != numDimensions)

+         {

+             throw InvalidArgumentException("All inputs to concatenation must have the same number of dimensions");

+         }

+     }

+

+     if (concatenationDimension >= numDimensions)

+     {

+         throw InvalidArgumentException("concatenationDimension must be between 0 and the number of dimensions.");

+     }

+

+     for (auto it = first; it != last; ++it)

+     {

+         for (unsigned int d = 0; d < numDimensions; ++d)

+         {

+             const bool dimSizeOk = (d == concatenationDimension) || (firstInputShape[d] == (*it)[d]);

+             if (!dimSizeOk)

+             {

+                 throw InvalidArgumentException("All inputs to concatenation must be the same size along all dimensions "

+                     " except the concatenation dimension");

+             }

+         }

+     }

+

+     OriginsDescriptor viewsDescriptor(static_cast<uint32_t>(numInputs), numDimensions);

+     viewsDescriptor.SetConcatAxis(concatenationDimension);

+

+     uint32_t viewIndex = 0u;

+     uint32_t coordAlongConcatDim = 0u;

+     for (auto it = first; it != last; ++it)

+     {

+         const auto& inputShape = *it;

+

+         for (unsigned int i = 0; i < concatenationDimension; ++i)

+         {

+             viewsDescriptor.SetViewOriginCoord(viewIndex, i, 0);

+         }

+

+         viewsDescriptor.SetViewOriginCoord(viewIndex, concatenationDimension, coordAlongConcatDim);

+         unsigned int dimSize = inputShape[concatenationDimension];

+         coordAlongConcatDim += dimSize;

+

+

+         for (unsigned int i = concatenationDimension + 1; i < numDimensions; ++i)

+         {

+             viewsDescriptor.SetViewOriginCoord(viewIndex, i, 0);

+         }

+

+         ++viewIndex;

+     }

+

+     return viewsDescriptor;

+ }

+

+ /// A Pooling2dDescriptor for the Pooling2dLayer.

+ struct Pooling2dDescriptor : BaseDescriptor

+ {

+     Pooling2dDescriptor()

+         : m_PoolType(PoolingAlgorithm::Max)

+         , m_PadLeft(0)

+         , m_PadRight(0)

+         , m_PadTop(0)

+         , m_PadBottom(0)

+         , m_PoolWidth(0)

+         , m_PoolHeight(0)

+         , m_StrideX(0)

+         , m_StrideY(0)

+         , m_OutputShapeRounding(OutputShapeRounding::Floor)

+         , m_PaddingMethod(PaddingMethod::Exclude)

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     bool operator ==(const Pooling2dDescriptor& rhs) const

+     {

+         return m_PoolType            == rhs.m_PoolType &&

+                m_PadLeft             == rhs.m_PadLeft &&

+                m_PadRight            == rhs.m_PadRight &&

+                m_PadTop              == rhs.m_PadTop &&

+                m_PadBottom           == rhs.m_PadBottom &&

+                m_PoolWidth           == rhs.m_PoolWidth &&

+                m_PoolHeight          == rhs.m_PoolHeight &&

+                m_StrideX             == rhs.m_StrideX &&

+                m_StrideY             == rhs.m_StrideY &&

+                m_OutputShapeRounding == rhs.m_OutputShapeRounding &&

+                m_PaddingMethod       == rhs.m_PaddingMethod &&

+                m_DataLayout          == rhs.m_DataLayout;

+     }

+

+     /// The pooling algorithm to use (Max. Average, L2).

+     PoolingAlgorithm    m_PoolType;

+     /// Padding left value in the width dimension.

+     uint32_t            m_PadLeft;

+     /// Padding right value in the width dimension.

+     uint32_t            m_PadRight;

+     /// Padding top value in the height dimension.

+     uint32_t            m_PadTop;

+     /// Padding bottom value in the height dimension.

+     uint32_t            m_PadBottom;

+     /// Pooling width value.

+     uint32_t            m_PoolWidth;

+     /// Pooling height value.

+     uint32_t            m_PoolHeight;

+     /// Stride value when proceeding through input for the width dimension.

+     uint32_t            m_StrideX;

+     /// Stride value when proceeding through input for the height dimension.

+     uint32_t            m_StrideY;

+     /// The rounding method for the output shape. (Floor, Ceiling).

+     OutputShapeRounding m_OutputShapeRounding;

+     /// The padding method to be used. (Exclude, IgnoreValue).

+     PaddingMethod       m_PaddingMethod;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout   m_DataLayout;

+ };

+

+ /// A Pooling3dDescriptor for the Pooling3dLayer.

+ struct Pooling3dDescriptor : BaseDescriptor

+ {

+     Pooling3dDescriptor()

+         : m_PoolType(PoolingAlgorithm::Max)

+         , m_PadLeft(0)

+         , m_PadRight(0)

+         , m_PadTop(0)

+         , m_PadBottom(0)

+         , m_PadFront(0)

+         , m_PadBack(0)

+         , m_PoolWidth(0)

+         , m_PoolHeight(0)

+         , m_PoolDepth(0)

+         , m_StrideX(0)

+         , m_StrideY(0)

+         , m_StrideZ(0)

+         , m_OutputShapeRounding(OutputShapeRounding::Floor)

+         , m_PaddingMethod(PaddingMethod::Exclude)

+         , m_DataLayout(DataLayout::NCDHW)

+     {}

+

+     bool operator ==(const Pooling3dDescriptor& rhs) const

+     {

+         return m_PoolType            == rhs.m_PoolType &&

+                m_PadLeft             == rhs.m_PadLeft &&

+                m_PadRight            == rhs.m_PadRight &&

+                m_PadTop              == rhs.m_PadTop &&

+                m_PadBottom           == rhs.m_PadBottom &&

+                m_PadFront            == rhs.m_PadFront &&

+                m_PadBack             == rhs.m_PadBack &&

+                m_PoolWidth           == rhs.m_PoolWidth &&

+                m_PoolHeight          == rhs.m_PoolHeight &&

+                m_PoolDepth           == rhs.m_PoolDepth &&

+                m_StrideX             == rhs.m_StrideX &&

+                m_StrideY             == rhs.m_StrideY &&

+                m_StrideZ             == rhs.m_StrideZ &&

+                m_OutputShapeRounding == rhs.m_OutputShapeRounding &&

+                m_PaddingMethod       == rhs.m_PaddingMethod &&

+                m_DataLayout          == rhs.m_DataLayout;

+     }

+

+     /// The pooling algorithm to use (Max. Average, L2).

+     PoolingAlgorithm    m_PoolType;

+     /// Padding left value in the width dimension.

+     uint32_t            m_PadLeft;

+     /// Padding right value in the width dimension.

+     uint32_t            m_PadRight;

+     /// Padding top value in the height dimension.

+     uint32_t            m_PadTop;

+     /// Padding bottom value in the height dimension.

+     uint32_t            m_PadBottom;

+     /// Padding front value in the depth dimension.

+     uint32_t            m_PadFront;

+     /// Padding back value in the depth dimension.

+     uint32_t            m_PadBack;

+     /// Pooling width value.

+     uint32_t            m_PoolWidth;

+     /// Pooling height value.

+     uint32_t            m_PoolHeight;

+     /// Pooling depth value.

+     uint32_t            m_PoolDepth;

+     /// Stride value when proceeding through input for the width dimension.

+     uint32_t            m_StrideX;

+     /// Stride value when proceeding through input for the height dimension.

+     uint32_t            m_StrideY;

+     /// Stride value when proceeding through input for the depth dimension.

+     uint32_t            m_StrideZ;

+     /// The rounding method for the output shape. (Floor, Ceiling).

+     OutputShapeRounding m_OutputShapeRounding;

+     /// The padding method to be used. (Exclude, IgnoreValue).

+     PaddingMethod       m_PaddingMethod;

+     /// The data layout to be used (NCDHW, NDHWC).

+     DataLayout   m_DataLayout;

+ };

+

+ /// A FullyConnectedDescriptor for the FullyConnectedLayer.

+ struct FullyConnectedDescriptor : BaseDescriptor

+ {

+     FullyConnectedDescriptor()

+         : m_BiasEnabled(false)

+         , m_TransposeWeightMatrix(false)

+         , m_ConstantWeights(true)

+     {}

+

+     bool operator ==(const FullyConnectedDescriptor& rhs) const

+     {

+         return m_BiasEnabled == rhs.m_BiasEnabled

+                && m_TransposeWeightMatrix == rhs.m_TransposeWeightMatrix

+                && m_ConstantWeights == rhs.m_ConstantWeights;

+     }

+

+     /// Get the number of inputs.

+     uint32_t GetNumInputs() const;

+

+     /// Enable/disable bias.

+     bool m_BiasEnabled;

+     /// Enable/disable transpose weight matrix.

+     bool m_TransposeWeightMatrix;

+     /// Enable/disable constant weights and biases.

+     bool m_ConstantWeights;

+ };

+

+ /// A Convolution2dDescriptor for the Convolution2dLayer.

+ struct Convolution2dDescriptor : BaseDescriptor

+ {

+     Convolution2dDescriptor()

+         : m_PadLeft(0)

+         , m_PadRight(0)

+         , m_PadTop(0)

+         , m_PadBottom(0)

+         , m_StrideX(1)

+         , m_StrideY(1)

+         , m_DilationX(1)

+         , m_DilationY(1)

+         , m_BiasEnabled(false)

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     bool operator ==(const Convolution2dDescriptor& rhs) const

+     {

+         return m_PadLeft     == rhs.m_PadLeft &&

+                m_PadRight    == rhs.m_PadRight &&

+                m_PadTop      == rhs.m_PadTop &&

+                m_PadBottom   == rhs.m_PadBottom &&

+                m_StrideX     == rhs.m_StrideX &&

+                m_StrideY     == rhs.m_StrideY &&

+                m_DilationX   == rhs.m_DilationX &&

+                m_DilationY   == rhs.m_DilationY &&

+                m_BiasEnabled == rhs.m_BiasEnabled &&

+                m_DataLayout  == rhs.m_DataLayout;

+     }

+     uint32_t GetNumInputs() const;

+

+

+     /// Padding left value in the width dimension.

+     uint32_t             m_PadLeft;

+     /// Padding right value in the width dimension.

+     uint32_t             m_PadRight;

+     /// Padding top value in the height dimension.

+     uint32_t             m_PadTop;

+     /// Padding bottom value in the height dimension.

+     uint32_t             m_PadBottom;

+     /// Stride value when proceeding through input for the width dimension.

+     uint32_t             m_StrideX;

+     /// Stride value when proceeding through input for the height dimension.

+     uint32_t             m_StrideY;

+     /// Dilation along x axis

+     uint32_t             m_DilationX;

+     /// Dilation along y axis

+     uint32_t             m_DilationY;

+     /// Enable/disable bias.

+     bool                 m_BiasEnabled;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout           m_DataLayout;

+ };

+

+ /// A Convolution3dDescriptor for the Convolution3dLayer.

+ struct Convolution3dDescriptor : BaseDescriptor

+ {

+     Convolution3dDescriptor()

+         : m_PadLeft(0)

+         , m_PadRight(0)

+         , m_PadTop(0)

+         , m_PadBottom(0)

+         , m_PadFront(0)

+         , m_PadBack(0)

+         , m_StrideX(1)

+         , m_StrideY(1)

+         , m_StrideZ(1)

+         , m_DilationX(1)

+         , m_DilationY(1)

+         , m_DilationZ(1)

+         , m_BiasEnabled(false)

+         , m_DataLayout(DataLayout::NDHWC)

+     {}

+

+     bool operator ==(const Convolution3dDescriptor& rhs) const

+     {

+         return m_PadLeft     == rhs.m_PadLeft &&

+                m_PadRight    == rhs.m_PadRight &&

+                m_PadTop      == rhs.m_PadTop &&

+                m_PadBottom   == rhs.m_PadBottom &&

+                m_PadFront    == rhs.m_PadFront &&

+                m_PadBack     == rhs.m_PadBack &&

+                m_StrideX     == rhs.m_StrideX &&

+                m_StrideY     == rhs.m_StrideY &&

+                m_StrideZ     == rhs.m_StrideZ &&

+                m_DilationX   == rhs.m_DilationX &&

+                m_DilationY   == rhs.m_DilationY &&

+                m_DilationZ   == rhs.m_DilationZ &&

+                m_BiasEnabled == rhs.m_BiasEnabled &&

+                m_DataLayout  == rhs.m_DataLayout;

+     }

+

+     /// Get the number of views/inputs.

+     uint32_t GetNumInputs() const;

+

+     /// Padding left value in the width dimension.

+     uint32_t             m_PadLeft;

+     /// Padding right value in the width dimension.

+     uint32_t             m_PadRight;

+     /// Padding top value in the height dimension.

+     uint32_t             m_PadTop;

+     /// Padding bottom value in the height dimension.

+     uint32_t             m_PadBottom;

+     /// Padding front value in the depth dimension.

+     uint32_t             m_PadFront;

+     /// Padding back value in the depth dimension.

+     uint32_t             m_PadBack;

+     /// Stride value when proceeding through input for the width dimension.

+     uint32_t             m_StrideX;

+     /// Stride value when proceeding through input for the height dimension.

+     uint32_t             m_StrideY;

+     /// Stride value when proceeding through input for the depth dimension.

+     uint32_t             m_StrideZ;

+     /// Dilation along x axis

+     uint32_t             m_DilationX;

+     /// Dilation along y axis

+     uint32_t             m_DilationY;

+     /// Dilation along z axis

+     uint32_t             m_DilationZ;

+     /// Enable/disable bias.

+     bool                 m_BiasEnabled;

+     /// The data layout to be used (NDHWC, NCDHW).

+     DataLayout           m_DataLayout;

+ };

+

+ /// A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.

+ struct DepthwiseConvolution2dDescriptor : BaseDescriptor

+ {

+     DepthwiseConvolution2dDescriptor()

+         : m_PadLeft(0)

+         , m_PadRight(0)

+         , m_PadTop(0)

+         , m_PadBottom(0)

+         , m_StrideX(1)

+         , m_StrideY(1)

+         , m_DilationX(1)

+         , m_DilationY(1)

+         , m_BiasEnabled(false)

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     bool operator ==(const DepthwiseConvolution2dDescriptor& rhs) const

+     {

+         return m_PadLeft     == rhs.m_PadLeft &&

+                m_PadRight    == rhs.m_PadRight &&

+                m_PadTop      == rhs.m_PadTop &&

+                m_PadBottom   == rhs.m_PadBottom &&

+                m_StrideX     == rhs.m_StrideX &&

+                m_StrideY     == rhs.m_StrideY &&

+                m_DilationX   == rhs.m_DilationX &&

+                m_DilationY   == rhs.m_DilationY &&

+                m_BiasEnabled == rhs.m_BiasEnabled &&

+                m_DataLayout  == rhs.m_DataLayout;

+     }

+

+     /// Get the number of views/inputs.

+     uint32_t GetNumInputs() const;

+

+     /// Padding left value in the width dimension.

+     uint32_t   m_PadLeft;

+     /// Padding right value in the width dimension.

+     uint32_t   m_PadRight;

+     /// Padding top value in the height dimension.

+     uint32_t   m_PadTop;

+     /// Padding bottom value in the height dimension.

+     uint32_t   m_PadBottom;

+     /// Stride value when proceeding through input for the width dimension.

+     uint32_t   m_StrideX;

+     /// Stride value when proceeding through input for the height dimension.

+     uint32_t   m_StrideY;

+     /// Dilation factor value for width dimension.

+     uint32_t   m_DilationX;

+     /// Dilation factor value for height dimension.

+     uint32_t   m_DilationY;

+     /// Enable/disable bias.

+     bool       m_BiasEnabled;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout m_DataLayout;

+ };

+

+ struct DetectionPostProcessDescriptor : BaseDescriptor

+ {

+     DetectionPostProcessDescriptor()

+         : m_MaxDetections(0)

+         , m_MaxClassesPerDetection(1)

+         , m_DetectionsPerClass(1)

+         , m_NmsScoreThreshold(0)

+         , m_NmsIouThreshold(0)

+         , m_NumClasses(0)

+         , m_UseRegularNms(false)

+         , m_ScaleX(0)

+         , m_ScaleY(0)

+         , m_ScaleW(0)

+         , m_ScaleH(0)

+     {}

+

+     bool operator ==(const DetectionPostProcessDescriptor& rhs) const

+     {

+         return m_MaxDetections          == rhs.m_MaxDetections &&

+                m_MaxClassesPerDetection == rhs.m_MaxClassesPerDetection &&

+                m_DetectionsPerClass     == rhs.m_DetectionsPerClass &&

+                m_NmsScoreThreshold      == rhs.m_NmsScoreThreshold &&

+                m_NmsIouThreshold        == rhs.m_NmsIouThreshold &&

+                m_NumClasses             == rhs.m_NumClasses &&

+                m_UseRegularNms          == rhs.m_UseRegularNms &&

+                m_ScaleX                 == rhs.m_ScaleX &&

+                m_ScaleY                 == rhs.m_ScaleY &&

+                m_ScaleW                 == rhs.m_ScaleW &&

+                m_ScaleH                 == rhs.m_ScaleH;

+     }

+

+     /// Maximum numbers of detections.

+     uint32_t m_MaxDetections;

+     /// Maximum numbers of classes per detection, used in Fast NMS.

+     uint32_t m_MaxClassesPerDetection;

+     /// Detections per classes, used in Regular NMS.

+     uint32_t m_DetectionsPerClass;

+     /// NMS score threshold.

+     float m_NmsScoreThreshold;

+     /// Intersection over union threshold.

+     float m_NmsIouThreshold;

+     /// Number of classes.

+     uint32_t m_NumClasses;

+     /// Use Regular NMS.

+     bool m_UseRegularNms;

+     /// Center size encoding scale x.

+     float m_ScaleX;

+     /// Center size encoding scale y.

+     float m_ScaleY;

+     /// Center size encoding scale weight.

+     float m_ScaleW;

+     /// Center size encoding scale height.

+     float m_ScaleH;

+ };

+

+ /// A NormalizationDescriptor for the NormalizationLayer.

+ struct NormalizationDescriptor : BaseDescriptor

+ {

+     NormalizationDescriptor()

+         : m_NormChannelType(NormalizationAlgorithmChannel::Across)

+         , m_NormMethodType(NormalizationAlgorithmMethod::LocalBrightness)

+         , m_NormSize(0)

+         , m_Alpha(0.f)

+         , m_Beta(0.f)

+         , m_K(0.f)

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     bool operator ==(const NormalizationDescriptor& rhs) const

+     {

+         return m_NormChannelType == rhs.m_NormChannelType &&

+                m_NormMethodType  == rhs.m_NormMethodType &&

+                m_NormSize        == rhs.m_NormSize &&

+                m_Alpha           == rhs.m_Alpha &&

+                m_Beta            == rhs.m_Beta &&

+                m_K               == rhs.m_K &&

+                m_DataLayout      == rhs.m_DataLayout;

+     }

+

+     /// Normalization channel algorithm to use (Across, Within).

+     NormalizationAlgorithmChannel m_NormChannelType;

+     /// Normalization method algorithm to use (LocalBrightness, LocalContrast).

+     NormalizationAlgorithmMethod  m_NormMethodType;

+     /// Depth radius value.

+     uint32_t                      m_NormSize;

+     /// Alpha value for the normalization equation.

+     float                         m_Alpha;

+     /// Beta value for the normalization equation.

+     float                         m_Beta;

+     /// Kappa value used for the across channel normalization equation.

+     float                         m_K;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout                    m_DataLayout;

+ };

+

+ /// A L2NormalizationDescriptor for the L2NormalizationLayer.

+ struct L2NormalizationDescriptor : BaseDescriptor

+ {

+     L2NormalizationDescriptor()

+         : m_Eps(1e-12f)

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     bool operator ==(const L2NormalizationDescriptor& rhs) const

+     {

+         return m_Eps == rhs.m_Eps && m_DataLayout == rhs.m_DataLayout;

+     }

+

+     /// Used to avoid dividing by zero.

+     float m_Eps;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout m_DataLayout;

+ };

+

+ /// A BatchNormalizationDescriptor for the BatchNormalizationLayer.

+ struct BatchNormalizationDescriptor : BaseDescriptor

+ {

+     BatchNormalizationDescriptor()

+         : m_Eps(0.0001f)

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     bool operator ==(const BatchNormalizationDescriptor& rhs) const

+     {

+         return m_Eps == rhs.m_Eps && m_DataLayout == rhs.m_DataLayout;

+     }

+

+     /// Value to add to the variance. Used to avoid dividing by zero.

+     float m_Eps;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout m_DataLayout;

+ };

+

+ /// An InstanceNormalizationDescriptor for InstanceNormalizationLayer

+ struct InstanceNormalizationDescriptor : BaseDescriptor

+ {

+     InstanceNormalizationDescriptor()

+         : m_Gamma(1.0f)

+         , m_Beta(0.0f)

+         , m_Eps(1e-12f)

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     bool operator ==(const InstanceNormalizationDescriptor& rhs) const

+     {

+         return m_Gamma      == rhs.m_Gamma &&

+                m_Beta       == rhs.m_Beta &&

+                m_Eps        == rhs.m_Eps &&

+                m_DataLayout == rhs.m_DataLayout;

+     }

+

+     /// Gamma, the scale scalar value applied for the normalized tensor. Defaults to 1.0.

+     float m_Gamma;

+     /// Beta, the offset scalar value applied for the normalized tensor. Defaults to 1.0.

+     float m_Beta;

+     /// Epsilon, small scalar value added to variance to avoid dividing by zero. Defaults to 1e-12f.

+     float m_Eps;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout m_DataLayout;

+ };

+

+ /// A BatchToSpaceNdDescriptor for the BatchToSpaceNdLayer.

+ struct BatchToSpaceNdDescriptor : BaseDescriptor

+ {

+     BatchToSpaceNdDescriptor()

+         : m_BlockShape({1, 1})

+         , m_Crops({{0, 0}, {0, 0}})

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     BatchToSpaceNdDescriptor(std::vector<unsigned int> blockShape,

+                              std::vector<std::pair<unsigned int, unsigned int>> crops)

+         : m_BlockShape(blockShape)

+         , m_Crops(crops)

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     bool operator ==(const BatchToSpaceNdDescriptor& rhs) const

+     {

+         return m_BlockShape == rhs.m_BlockShape &&

+                m_Crops      == rhs.m_Crops &&

+                m_DataLayout == rhs.m_DataLayout;

+     }

+

+     /// Block shape values.

+     std::vector<unsigned int> m_BlockShape;

+     /// The values to crop from the input dimension.

+     std::vector<std::pair<unsigned int, unsigned int>> m_Crops;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout m_DataLayout;

+ };

+

+ /// A FakeQuantizationDescriptor for the FakeQuantizationLayer.

+ struct FakeQuantizationDescriptor : BaseDescriptor

+ {

+         FakeQuantizationDescriptor()

+         : m_Min(-6.0f)

+         , m_Max(6.0f)

+     {}

+

+     bool operator ==(const FakeQuantizationDescriptor& rhs) const

+     {

+         return m_Min == rhs.m_Min && m_Max == rhs.m_Max;

+     }

+

+     /// Minimum value.

+     float m_Min;

+     /// Maximum value.

+     float m_Max;

+ };

+

+ /// A FillDescriptor for the FillLayer

+ struct FillDescriptor : BaseDescriptor

+ {

+     FillDescriptor()

+     : m_Value(0)

+     {}

+

+     FillDescriptor(const float& value)

+     : m_Value(value)

+     {}

+

+     bool operator ==(const FillDescriptor& rhs) const

+     {

+         return m_Value == rhs.m_Value;

+     }

+

+     float m_Value;

+ };

+

+ /// A GatherDescriptor for the GatherLayer.

+ struct GatherDescriptor : BaseDescriptor

+ {

+     GatherDescriptor()

+         : m_Axis(0)

+     {}

+

+     GatherDescriptor(int32_t axis)

+         : m_Axis(axis)

+     {}

+

+     bool operator ==(const GatherDescriptor& rhs) const

+     {

+         return m_Axis == rhs.m_Axis;

+     }

+

+     /// The axis in params to gather indices from

+     int32_t m_Axis;

+ };

+

+ /// A ResizeDescriptor for the ResizeLayer.

+ struct ResizeDescriptor : BaseDescriptor

+ {

+     ResizeDescriptor()

+         : m_TargetWidth(0)

+         , m_TargetHeight(0)

+         , m_Method(ResizeMethod::NearestNeighbor)

+         , m_DataLayout(DataLayout::NCHW)

+         , m_AlignCorners(false)

+         , m_HalfPixelCenters(false)

+     {}

+

+     bool operator ==(const ResizeDescriptor& rhs) const

+     {

+         return m_TargetWidth          == rhs.m_TargetWidth &&

+                m_TargetHeight         == rhs.m_TargetHeight &&

+                m_Method               == rhs.m_Method &&

+                m_DataLayout           == rhs.m_DataLayout &&

+                m_AlignCorners         == rhs.m_AlignCorners &&

+                m_HalfPixelCenters     == rhs.m_HalfPixelCenters;

+     }

+

+     /// Target width value.

+     uint32_t m_TargetWidth;

+     /// Target height value.

+     uint32_t m_TargetHeight;

+     /// The Interpolation method to use

+     /// (Bilinear, NearestNeighbor).

+     ResizeMethod m_Method;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout m_DataLayout;

+     /// Aligned corners

+     bool m_AlignCorners;

+     /// Half Pixel Centers

+     bool m_HalfPixelCenters;

+ };

+

+

+ /// A ReshapeDescriptor for the ReshapeLayer.

+ struct ReshapeDescriptor : BaseDescriptor

+ {

+     ReshapeDescriptor()

+         : m_TargetShape()

+     {}

+

+     ReshapeDescriptor(const TensorShape& shape)

+         : m_TargetShape(shape)

+     {}

+

+     bool operator ==(const ReshapeDescriptor& rhs) const

+     {

+         return m_TargetShape == rhs.m_TargetShape;

+     }

+

+     /// Target shape value.

+     TensorShape m_TargetShape;

+ };

+

+ /// A SpaceToBatchNdDescriptor for the SpaceToBatchNdLayer.

+ struct SpaceToBatchNdDescriptor : BaseDescriptor

+ {

+     SpaceToBatchNdDescriptor()

+         : m_BlockShape({1, 1})

+         , m_PadList({{0, 0}, {0, 0}})

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     SpaceToBatchNdDescriptor(const std::vector<unsigned int>& blockShape,

+                              const std::vector<std::pair<unsigned int, unsigned int>>& padList)

+         : m_BlockShape(blockShape)

+         , m_PadList(padList)

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     bool operator ==(const SpaceToBatchNdDescriptor& rhs) const

+     {

+         return m_BlockShape == rhs.m_BlockShape &&

+                m_PadList    == rhs.m_PadList &&

+                m_DataLayout == rhs.m_DataLayout;

+     }

+

+     /// Block shape value.

+     std::vector<unsigned int> m_BlockShape;

+     /// @brief Specifies the padding values for the input dimension:

+     /// heightPad{top, bottom} widthPad{left, right}.

+     std::vector<std::pair<unsigned int, unsigned int>> m_PadList;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout m_DataLayout;

+ };

+

+ /// A SpaceToDepthDescriptor for the SpaceToDepthLayer

+ struct SpaceToDepthDescriptor : BaseDescriptor

+ {

+     SpaceToDepthDescriptor()

+         : SpaceToDepthDescriptor(1u, DataLayout::NHWC)

+     {}

+

+     SpaceToDepthDescriptor(unsigned int blockSize, DataLayout dataLayout)

+         : m_BlockSize(blockSize)

+         , m_DataLayout(dataLayout)

+     {}

+

+     bool operator ==(const SpaceToDepthDescriptor& rhs) const

+     {

+         return m_BlockSize == rhs.m_BlockSize && m_DataLayout == rhs.m_DataLayout;

+     }

+

+     /// Scalar specifying the input block size. It must be >= 1

+     unsigned int m_BlockSize;

+

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout m_DataLayout;

+ };

+

+ /// A DepthToSpaceDescriptor for the DepthToSpaceLayer

+ using DepthToSpaceDescriptor = SpaceToDepthDescriptor;

+

+ /// An LstmDescriptor for the LstmLayer.

+ struct LstmDescriptor : BaseDescriptor

+ {

+     LstmDescriptor()

+         : m_ActivationFunc(1) // 0: None, 1: Relu, 3: Relu6, 4: Tanh, 6: Sigmoid

+         , m_ClippingThresCell(0.0)

+         , m_ClippingThresProj(0.0)

+         , m_CifgEnabled(true)

+         , m_PeepholeEnabled(false)

+         , m_ProjectionEnabled(false)

+         , m_LayerNormEnabled(false)

+         , m_TimeMajor(false)

+         , m_InputIntermediateScale(0.0)

+         , m_ForgetIntermediateScale(0.0)

+         , m_CellIntermediateScale(0.0)

+         , m_OutputIntermediateScale(0.0)

+         , m_HiddenStateZeroPoint(0)

+         , m_HiddenStateScale(0.0)

+     {}

+

+     bool operator ==(const LstmDescriptor& rhs) const

+     {

+         return m_ActivationFunc          == rhs.m_ActivationFunc &&

+                m_ClippingThresCell       == rhs.m_ClippingThresCell &&

+                m_ClippingThresProj       == rhs.m_ClippingThresProj &&

+                m_CifgEnabled             == rhs.m_CifgEnabled &&

+                m_PeepholeEnabled         == rhs.m_PeepholeEnabled &&

+                m_LayerNormEnabled        == rhs.m_LayerNormEnabled &&

+                m_TimeMajor               == rhs.m_TimeMajor &&

+                m_InputIntermediateScale  == rhs.m_InputIntermediateScale &&

+                m_ForgetIntermediateScale == rhs.m_ForgetIntermediateScale &&

+                m_CellIntermediateScale   == rhs.m_CellIntermediateScale &&

+                m_OutputIntermediateScale == rhs.m_OutputIntermediateScale &&

+                m_HiddenStateZeroPoint    == rhs.m_HiddenStateZeroPoint &&

+                m_HiddenStateScale        == rhs.m_HiddenStateScale;

+     }

+

+     /// @brief The activation function to use.

+     /// 0: None, 1: Relu, 3: Relu6, 4: Tanh, 6: Sigmoid.

+     uint32_t m_ActivationFunc;

+     /// Clipping threshold value for the cell state.

+     float m_ClippingThresCell;

+     /// Clipping threshold value for the projection.

+     float m_ClippingThresProj;

+     /// Enable/disable cifg (coupled input & forget gate).

+     bool m_CifgEnabled;

+     /// Enable/disable peephole.

+     bool m_PeepholeEnabled;

+     /// Enable/disable the projection layer.

+     bool m_ProjectionEnabled;

+     /// Enable/disable layer normalization

+     bool m_LayerNormEnabled;

+     /// Enable/disable time major

+     bool m_TimeMajor;

+     /// Input intermediate quantization scale

+     float m_InputIntermediateScale;

+     /// Forget intermediate quantization scale

+     float m_ForgetIntermediateScale;

+     /// Cell intermediate quantization scale

+     float m_CellIntermediateScale;

+     /// Output intermediate quantization scale

+     float m_OutputIntermediateScale;

+     /// Hidden State zero point

+     int32_t m_HiddenStateZeroPoint;

+     /// Hidden State quantization scale

+     float m_HiddenStateScale;

+ };

+

+ using UnidirectionalSequenceLstmDescriptor = LstmDescriptor;

+

+ /// A MeanDescriptor for the MeanLayer.

+ struct MeanDescriptor : BaseDescriptor

+ {

+     MeanDescriptor()

+         : m_Axis()

+         , m_KeepDims(false)

+     {}

+

+     MeanDescriptor(const std::vector<unsigned int>& axis, bool keepDims)

+         : m_Axis(axis)

+         , m_KeepDims(keepDims)

+     {}

+

+     bool operator ==(const MeanDescriptor& rhs) const

+     {

+         return m_Axis == rhs.m_Axis && m_KeepDims == rhs.m_KeepDims;

+     }

+

+     /// Values for the dimensions to reduce.

+     std::vector<unsigned int> m_Axis;

+     /// Enable/disable keep dimensions. If true, then the reduced dimensions that are of length 1 are kept.

+     bool m_KeepDims;

+ };

+

+ /// A PadDescriptor for the PadLayer.

+ struct PadDescriptor : BaseDescriptor

+ {

+     PadDescriptor() : m_PadValue(0), m_PaddingMode(PaddingMode::Constant)

+     {}

+

+     PadDescriptor(const std::vector<std::pair<unsigned int, unsigned int>>& padList,

+                   const float& padValue = 0,

+                   const PaddingMode& paddingMode = PaddingMode::Constant)

+         : m_PadList(padList)

+         , m_PadValue(padValue)

+         , m_PaddingMode(paddingMode)

+     {}

+

+     bool operator ==(const PadDescriptor& rhs) const

+     {

+         return m_PadList == rhs.m_PadList && m_PadValue == rhs.m_PadValue && m_PaddingMode == rhs.m_PaddingMode;

+     }

+

+     /// @brief Specifies the padding for input dimension.

+     /// First is the number of values to add before the tensor in the dimension.

+     /// Second is the number of values to add after the tensor in the dimension.

+     /// The number of pairs should match the number of dimensions in the input tensor.

+     std::vector<std::pair<unsigned int, unsigned int>> m_PadList;

+

+     /// Optional value to use for padding, defaults to 0

+     float m_PadValue;

+

+     /// Specifies the Padding mode (Constant, Reflect or Symmetric)

+     PaddingMode m_PaddingMode;

+ };

+

+ /// A SliceDescriptor for the SliceLayer.

+ struct SliceDescriptor : BaseDescriptor

+ {

+     SliceDescriptor(const std::vector<unsigned int>& begin, const std::vector<unsigned int>& size)

+         : m_Begin(begin)

+         , m_Size(size)

+     {}

+

+     SliceDescriptor() : SliceDescriptor({}, {})

+     {}

+

+     bool operator ==(const SliceDescriptor& rhs) const

+     {

+         return m_Begin == rhs.m_Begin && m_Size == rhs.m_Size;

+     }

+

+     /// Beginning indices of the slice in each dimension.

+     std::vector<unsigned int> m_Begin;

+

+     /// Size of the slice in each dimension.

+     std::vector<unsigned int> m_Size;

+ };

+

+ /// A StackDescriptor for the StackLayer.

+ struct StackDescriptor : BaseDescriptor

+ {

+     StackDescriptor()

+         : m_Axis(0)

+         , m_NumInputs(0)

+         , m_InputShape()

+     {}

+

+     StackDescriptor(uint32_t axis, uint32_t numInputs, const TensorShape& inputShape)

+         : m_Axis(axis)

+         , m_NumInputs(numInputs)

+         , m_InputShape(inputShape)

+     {}

+

+     bool operator ==(const StackDescriptor& rhs) const

+     {

+         return m_Axis       == rhs.m_Axis &&

+                m_NumInputs  == rhs.m_NumInputs &&

+                m_InputShape == rhs.m_InputShape;

+     }

+

+     /// 0-based axis along which to stack the input tensors.

+     uint32_t m_Axis;

+     /// Number of input tensors.

+     uint32_t m_NumInputs;

+     /// Required shape of all input tensors.

+     TensorShape m_InputShape;

+ };

+

+ /// A StandInDescriptor for the StandIn layer

+ struct StandInDescriptor : BaseDescriptor

+ {

+     StandInDescriptor() {};

+

+     StandInDescriptor(uint32_t numInputs, uint32_t numOutputs)

+         : m_NumInputs(numInputs)

+         , m_NumOutputs(numOutputs)

+     {}

+

+     bool operator ==(const StandInDescriptor& rhs) const

+     {

+         return m_NumInputs  == rhs.m_NumInputs &&

+                m_NumOutputs == rhs.m_NumOutputs;

+     }

+

+     /// Number of input tensors

+     uint32_t m_NumInputs = 0;

+     /// Number of output tensors

+     uint32_t m_NumOutputs = 0;

+ };

+

+ /// A StridedSliceDescriptor for the StridedSliceLayer.

+ struct StridedSliceDescriptor : BaseDescriptor

+ {

+     StridedSliceDescriptor(const std::vector<int>& begin,

+                            const std::vector<int>& end,

+                            const std::vector<int>& stride)

+         : m_Begin(begin)

+         , m_End(end)

+         , m_Stride(stride)

+         , m_BeginMask(0)

+         , m_EndMask(0)

+         , m_ShrinkAxisMask(0)

+         , m_EllipsisMask(0)

+         , m_NewAxisMask(0)

+         , m_DataLayout(DataLayout::NCHW)

+     {}

+

+     StridedSliceDescriptor()

+         : StridedSliceDescriptor({}, {}, {})

+     {}

+

+     bool operator ==(const StridedSliceDescriptor& rhs) const

+     {

+         return m_Begin          == rhs.m_Begin &&

+                m_End            == rhs.m_End &&

+                m_Stride         == rhs.m_Stride &&

+                m_BeginMask      == rhs.m_BeginMask &&

+                m_EndMask        == rhs.m_EndMask &&

+                m_ShrinkAxisMask == rhs.m_ShrinkAxisMask &&

+                m_EllipsisMask   == rhs.m_EllipsisMask &&

+                m_NewAxisMask    == rhs.m_NewAxisMask &&

+                m_DataLayout     == rhs.m_DataLayout;

+     }

+

+     int GetStartForAxis(const TensorShape& inputShape, unsigned int axis) const;

+     int GetStopForAxis(const TensorShape& inputShape,

+                        unsigned int axis,

+                        int startForAxis) const;

+

+     /// Begin values for the input that will be sliced.

+     std::vector<int> m_Begin;

+     /// End values for the input that will be sliced.

+     std::vector<int> m_End;

+     /// Stride values for the input that will be sliced.

+     std::vector<int> m_Stride;

+

+     /// @brief Begin mask value. If set, then the begin is disregarded and the fullest

+     /// range is used for the dimension.

+     int32_t m_BeginMask;

+     /// @brief End mask value. If set, then the end is disregarded and the fullest range

+     /// is used for the dimension.

+     int32_t m_EndMask;

+     /// Shrink axis mask value. If set, the nth specification shrinks the dimensionality by 1.

+     int32_t m_ShrinkAxisMask;

+     /// Ellipsis mask value.

+     int32_t m_EllipsisMask;

+     /// @brief New axis mask value. If set, the begin, end and stride is disregarded and

+     /// a new 1 dimension is inserted to this location of the output tensor.

+     int32_t m_NewAxisMask;

+

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout m_DataLayout;

+ };

+

+ /// A PreCompiledDescriptor for the PreCompiledLayer.

+ struct PreCompiledDescriptor : BaseDescriptor

+ {

+     PreCompiledDescriptor(unsigned int numInputSlots = 1u, unsigned int numOutputSlots = 1u)

+         : m_NumInputSlots(numInputSlots), m_NumOutputSlots(numOutputSlots)

+     {}

+

+     ~PreCompiledDescriptor() = default;

+

+     unsigned int m_NumInputSlots;

+     unsigned int m_NumOutputSlots;

+ };

+

+ /// A QLstmDescriptor for the QLstmLayer.

+ struct QLstmDescriptor : BaseDescriptor

+ {

+     QLstmDescriptor()

+             : m_CellClip(0.0)

+             , m_ProjectionClip(0.0)

+             , m_CifgEnabled(true)

+             , m_PeepholeEnabled(false)

+             , m_ProjectionEnabled(false)

+             , m_LayerNormEnabled(false)

+             , m_InputIntermediateScale(0.0)

+             , m_ForgetIntermediateScale(0.0)

+             , m_CellIntermediateScale(0.0)

+             , m_OutputIntermediateScale(0.0)

+             , m_HiddenStateZeroPoint(0)

+             , m_HiddenStateScale(0.0)

+     {}

+

+     bool operator ==(const QLstmDescriptor& rhs) const

+     {

+         return m_CellClip          == rhs.m_CellClip &&

+                m_ProjectionClip    == rhs.m_ProjectionClip &&

+                m_CifgEnabled       == rhs.m_CifgEnabled &&

+                m_PeepholeEnabled   == rhs.m_PeepholeEnabled &&

+                m_ProjectionEnabled == rhs.m_ProjectionEnabled &&

+                m_LayerNormEnabled  == rhs.m_LayerNormEnabled &&

+                m_InputIntermediateScale == rhs.m_InputIntermediateScale &&

+                m_ForgetIntermediateScale == rhs.m_ForgetIntermediateScale &&

+                m_CellIntermediateScale == rhs.m_CellIntermediateScale &&

+                m_OutputIntermediateScale == rhs.m_OutputIntermediateScale &&

+                m_HiddenStateZeroPoint == rhs.m_HiddenStateZeroPoint &&

+                m_HiddenStateScale == rhs.m_HiddenStateScale;

+     }

+

+     /// Clipping threshold value for the cell state

+     float m_CellClip;

+     /// Clipping threshold value for the projection

+     float m_ProjectionClip;

+     /// Enable/disable CIFG (coupled input & forget gate).

+     bool m_CifgEnabled;

+     /// Enable/disable peephole

+     bool m_PeepholeEnabled;

+     /// Enable/disable the projection layer

+     bool m_ProjectionEnabled;

+     /// Enable/disable layer normalization

+     bool m_LayerNormEnabled;

+     /// Input intermediate quantization scale

+     float m_InputIntermediateScale;

+     /// Forget intermediate quantization scale

+     float m_ForgetIntermediateScale;

+     /// Cell intermediate quantization scale

+     float m_CellIntermediateScale;

+     /// Output intermediate quantization scale

+     float m_OutputIntermediateScale;

+     /// Hidden State zero point

+     int32_t m_HiddenStateZeroPoint;

+     /// Hidden State quantization scale

+     float m_HiddenStateScale;

+ };

+

+ /// A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer.

+ struct TransposeConvolution2dDescriptor : BaseDescriptor

+ {

+     TransposeConvolution2dDescriptor() :

+         m_PadLeft(0),

+         m_PadRight(0),

+         m_PadTop(0),

+         m_PadBottom(0),

+         m_StrideX(0),

+         m_StrideY(0),

+         m_BiasEnabled(false),

+         m_DataLayout(DataLayout::NCHW),

+         m_OutputShapeEnabled(false)

+     {}

+

+     bool operator ==(const TransposeConvolution2dDescriptor& rhs) const

+     {

+         return m_PadLeft            == rhs.m_PadLeft &&

+                m_PadRight           == rhs.m_PadRight &&

+                m_PadTop             == rhs.m_PadTop &&

+                m_PadBottom          == rhs.m_PadBottom &&

+                m_StrideX            == rhs.m_StrideX &&

+                m_StrideY            == rhs.m_StrideY &&

+                m_BiasEnabled        == rhs.m_BiasEnabled &&

+                m_DataLayout         == rhs.m_DataLayout &&

+                m_OutputShapeEnabled == rhs.m_OutputShapeEnabled &&

+                m_OutputShape        == rhs.m_OutputShape;

+     }

+

+     /// Padding left value in the width dimension.

+     uint32_t                  m_PadLeft;

+     /// Padding right value in the width dimension.

+     uint32_t                  m_PadRight;

+     /// Padding top value in the height dimension.

+     uint32_t                  m_PadTop;

+     /// Padding bottom value in the height dimension.

+     uint32_t                  m_PadBottom;

+     /// Stride value when proceeding through input for the width dimension.

+     uint32_t                  m_StrideX;

+     /// Stride value when proceeding through input for the height dimension.

+     uint32_t                  m_StrideY;

+     /// Enable/disable bias.

+     bool                      m_BiasEnabled;

+     /// The data layout to be used (NCHW, NHWC).

+     DataLayout                m_DataLayout;

+     /// Output shape if it has been specified.

+     bool                      m_OutputShapeEnabled;

+     std::vector<unsigned int> m_OutputShape;

+ };

+

+ /// A TransposeDescriptor for the TransposeLayer.

+ struct TransposeDescriptor : BaseDescriptor

+ {

+     TransposeDescriptor()

+             : m_DimMappings{}

+     {}

+

+     TransposeDescriptor(const PermutationVector& dimMappings)

+             : m_DimMappings(dimMappings)

+     {}

+

+     bool operator ==(const TransposeDescriptor &rhs) const

+     {

+         return m_DimMappings.IsEqual(rhs.m_DimMappings);

+     }

+

+     /// @brief Indicates how to translate tensor elements from a given source into the target destination, when

+     /// source and target potentially have different memory layouts e.g.

+     /// Input Shape        {1, 1, 4, 4}

+     /// Permutation Vector {0, 2, 3, 1}

+     /// Output Shape       {1, 4, 4, 1}

+     /// dim "0" of input goes into index 0 ([ 1, X, X, X])

+     /// dim "2" of input goes into index 1 ([ 1, 4, X, X ])

+     /// dim "3" of input goes into index 2 ([ 1, 4, 4, X ])

+     /// dim "1" of input goes into index 3 ([ 1, 4, 4, 1 ])

+     PermutationVector m_DimMappings;

+ };

+

+ /// A LogicalBinaryDescriptor for the LogicalBinaryLayer

+ struct LogicalBinaryDescriptor : BaseDescriptor

+ {

+     LogicalBinaryDescriptor()

+         : LogicalBinaryDescriptor(LogicalBinaryOperation::LogicalAnd)

+     {}

+

+     LogicalBinaryDescriptor(LogicalBinaryOperation operation)

+         : m_Operation(operation)

+     {}

+

+     bool operator ==(const LogicalBinaryDescriptor &rhs) const

+     {

+         return m_Operation == rhs.m_Operation;

+     }

+

+     /// Specifies the logical operation to execute

+     LogicalBinaryOperation m_Operation;

+ };

+

+ /// A ReduceDescriptor for the REDUCE operators.

+ struct ReduceDescriptor : BaseDescriptor

+ {

+     ReduceDescriptor()

+         : m_KeepDims(false)

+         , m_vAxis()

+         , m_ReduceOperation(ReduceOperation::Sum)

+     {}

+

+     bool operator ==(const ReduceDescriptor& rhs) const

+     {

+         return m_KeepDims             == rhs.m_KeepDims &&

+                m_vAxis                == rhs.m_vAxis &&

+                m_ReduceOperation      == rhs.m_ReduceOperation;

+     }

+

+     /// if true then output shape has no change.

+     bool m_KeepDims;

+     /// The indices of the dimensions to reduce.

+     std::vector<uint32_t> m_vAxis;

+     /// Specifies the reduction operation to execute

+     ReduceOperation m_ReduceOperation;

+ };

+

+ /// A ChannelShuffleDescriptor for the ChannelShuffle operator

+ struct ChannelShuffleDescriptor : BaseDescriptor

+ {

+     ChannelShuffleDescriptor()

+         : m_NumGroups(0), m_Axis(0)

+     {}

+

+     ChannelShuffleDescriptor(const uint32_t& numGroups, const uint32_t& axis)

+         : m_NumGroups(numGroups), m_Axis(axis)

+     {}

+

+     bool operator ==(const ChannelShuffleDescriptor& rhs) const

+     {

+         return m_NumGroups == rhs.m_NumGroups;

+     }

+

+     /// Number of groups for the channel shuffle operation

+     uint32_t m_NumGroups;

+     /// Axis to apply channel shuffle operation on

+     uint32_t m_Axis;

+ };

+

+ /// A BatchMatMulDescriptor for the BatchMatMul operator

+ struct BatchMatMulDescriptor : BaseDescriptor

+ {

+     BatchMatMulDescriptor(bool transposeX = false,

+                           bool transposeY = false,

+                           bool adjointX = false,

+                           bool adjointY = false,

+                           DataLayout dataLayoutX = DataLayout::NCHW,

+                           DataLayout dataLayoutY = DataLayout::NCHW)

+         : m_TransposeX(transposeX)

+         , m_TransposeY(transposeY)

+         , m_AdjointX(adjointX)

+         , m_AdjointY(adjointY)

+         , m_DataLayoutX(dataLayoutX)

+         , m_DataLayoutY(dataLayoutY)

+     {}

+

+     bool operator ==(const BatchMatMulDescriptor &rhs)  const

+     {

+         return m_TransposeX == rhs.m_TransposeX &&

+                m_TransposeY == rhs.m_TransposeY &&

+                m_AdjointX == rhs.m_AdjointX &&

+                m_AdjointY == rhs.m_AdjointY &&

+                m_DataLayoutX == rhs.m_DataLayoutX &&

+                m_DataLayoutY == rhs.m_DataLayoutY;

+     }

+

+     /// Transpose the slices of each input tensor

+     /// Transpose and Adjoint can not both be set to true for the same tensor at the same time

+     bool m_TransposeX;

+     bool m_TransposeY;

+

+     /// Adjoint the slices of each input tensor

+     /// Transpose and Adjoint can not both be set to true for the same tensor at the same time

+     bool m_AdjointX;

+     bool m_AdjointY;

+

+     /// Data layout of each input tensor, such as NHWC/NDHWC (leave as default for arbitrary layout)

+     DataLayout m_DataLayoutX;

+     DataLayout m_DataLayoutY;

+

+     ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use ABI Stable "

+                                       "GetAxesToMul(DataLayout dataLayout, const TensorShape& tensorShape) instead.",

+                                       "23.05")

+     static std::pair<std::pair<unsigned int, unsigned int>, std::pair<unsigned int, unsigned int>> GetAxesToMul(

+         const BatchMatMulDescriptor& desc,

+         const TensorShape& tensorXShape,

+         const TensorShape& tensorYShape);

+

+     ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use ABI Stable "

+                                       "GetAxesNotMul(DataLayout dataLayout, const TensorShape& tensorShape) instead.",

+                                       "23.05")

+     static std::pair<std::vector<unsigned int>, std::vector<unsigned int>> GetAxesNotMul(

+         const BatchMatMulDescriptor& desc,

+         const TensorShape& inputXShape,

+         const TensorShape& inputYShape);

+

+     /// Static helper to get the two axes (for each input) for multiplication

+     static std::pair<unsigned int, unsigned int> GetAxesToMul(

+         DataLayout dataLayout,

+         const TensorShape& tensorShape);

+

+     /// Static helper to get the axes (for each input) that will not be multiplied together

+     static std::vector<unsigned int> GetAxesNotMul(

+         DataLayout dataLayout,

+         const TensorShape& tensorShape);

+

+     /// Static helper to get the axes which will be transposed

+     static PermutationVector GetPermuteVec(

+         DataLayout dataLayout,

+         const TensorShape& tensorShape);

+ };

+

+ } // namespace armnn