BatchMatMulDescriptor Struct Reference

A BatchMatMulDescriptor for the BatchMatMul operator. More...

#include <Descriptors.hpp>

Inheritance diagram for BatchMatMulDescriptor:

Public Member Functions
	BatchMatMulDescriptor (Optional< DataLayout > dataLayoutX=EmptyOptional(), Optional< DataLayout > dataLayoutY=EmptyOptional(), std::vector< unsigned int > transposeX={}, std::vector< unsigned int > transposeY={}, std::vector< unsigned int > adjointX={}, std::vector< unsigned int > adjointY={})
bool	operator== (const BatchMatMulDescriptor &rhs) const
Public Member Functions inherited from BaseDescriptor
virtual bool	IsNull () const
virtual	~BaseDescriptor ()=default

Static Public Member Functions
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)
	Static helper to get the two axes (for each input) for multiplication. More...
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 axes (for each input) that will not be multiplied together. More...

Public Attributes
Optional< DataLayout >	m_DataLayoutX
	Data layout of each input tensor, such as NHWC/NDHWC (or leave as EmptyOptional for arbitrary layout) More...
Optional< DataLayout >	m_DataLayoutY
std::vector< unsigned int >	m_TransposeX
	Transpose vector for each input tensor (leave as empty vector for no pre-transposing) Transpose and Adjoint can not both be set to true for the same tensor at the same time. More...
std::vector< unsigned int >	m_TransposeY
std::vector< unsigned int >	m_AdjointX
	Adjoint vector for each input tensor (leave as empty vector for no pre-adjoint) Transpose and Adjoint can not both be set to true for the same tensor at the same time. More...
std::vector< unsigned int >	m_AdjointY

Detailed Description

A BatchMatMulDescriptor for the BatchMatMul operator.

Definition at line 1554 of file Descriptors.hpp.

Constructor & Destructor Documentation

BatchMatMulDescriptor()

BatchMatMulDescriptor ( Optional< DataLayout >  dataLayoutX = EmptyOptional(), Optional< DataLayout >  dataLayoutY = EmptyOptional(), std::vector< unsigned int >  transposeX = {}, std::vector< unsigned int >  transposeY = {}, std::vector< unsigned int >  adjointX = {}, std::vector< unsigned int >  adjointY = {}  )

inline

Definition at line 1556 of file Descriptors.hpp.

                                                               {},
                          std::vector<unsigned int> transposeY = {},
                          std::vector<unsigned int> adjointX = {},
                          std::vector<unsigned int> adjointY = {})
        : m_DataLayoutX(dataLayoutX)
        , m_DataLayoutY(dataLayoutY)
        , m_TransposeX(transposeX)
        , m_TransposeY(transposeY)
        , m_AdjointX(adjointX)
        , m_AdjointY(adjointY)
    {}

Member Function Documentation

GetAxesNotMul()

std::pair< std::vector< unsigned int >, std::vector< unsigned int > > GetAxesNotMul ( const BatchMatMulDescriptor &  desc, const TensorShape &  inputXShape, const TensorShape &  inputYShape  )

static

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

Definition at line 508 of file Descriptors.cpp.

References BatchMatMulDescriptor::GetAxesToMul(), and TensorShape::GetNumDimensions().

Referenced by BatchMatMulQueueDescriptor::Validate().

{
    // May refactor to just work on one input per call - makes it less confusing and also
    // allows more flexibility (i.e. in Layer output shape inference)
    auto axesToMul = BatchMatMulDescriptor::GetAxesToMul(desc, inputXShape, inputYShape);

    std::vector<unsigned int> axesXNotMul;
    std::vector<unsigned int> axesYNotMul;

    for(unsigned int i = 0; i < inputXShape.GetNumDimensions(); i++)
    {
        if(i == axesToMul.first.first || i == axesToMul.first.second)
        {
            continue;
        }
        axesXNotMul.push_back(i);
    }
    for(unsigned int i = 0; i < inputYShape.GetNumDimensions(); i++)
    {
        if(i == axesToMul.second.first || i == axesToMul.second.second)
        {
            continue;
        }
        axesYNotMul.push_back(i);
    }

    return { axesXNotMul, axesYNotMul };
}

GetAxesToMul()

std::pair< std::pair< unsigned int, unsigned int >, std::pair< unsigned int, unsigned int > > GetAxesToMul ( const BatchMatMulDescriptor &  desc, const TensorShape &  tensorXShape, const TensorShape &  tensorYShape  )

static

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

Definition at line 459 of file Descriptors.cpp.

References TensorShape::GetNumDimensions(), OptionalBase::has_value(), BatchMatMulDescriptor::m_DataLayoutX, BatchMatMulDescriptor::m_DataLayoutY, armnn::NCDHW, armnn::NCHW, armnn::NDHWC, armnn::NHWC, and OptionalReferenceSwitch< IsReference, T >::value().

Referenced by BatchMatMulDescriptor::GetAxesNotMul(), BatchMatMulLayer::InferOutputShapes(), BatchMatMul::RecurseBMM(), and BatchMatMulQueueDescriptor::Validate().

{
    // May refactor to just work on one input per call - makes it less confusing and also
    // allows more flexibility (i.e. in Layer output shape inference)

    auto xNumDims = tensorXShape.GetNumDimensions();
    auto yNumDims = tensorYShape.GetNumDimensions();

    std::pair<unsigned int, unsigned int> xAxes = { xNumDims-2, xNumDims-1 };
    std::pair<unsigned int, unsigned int> yAxes = { yNumDims-2, yNumDims-1 };

    if(desc.m_DataLayoutX.has_value())
    {
        switch(desc.m_DataLayoutX.value())
        {
            case DataLayout::NDHWC:
            case DataLayout::NHWC:
                xAxes.first -= 1;
                xAxes.second -= 1;
                break;
            case DataLayout::NCDHW:
            case DataLayout::NCHW:
            default:
                break;
        }
    }

    if(desc.m_DataLayoutY.has_value())
    {
        switch(desc.m_DataLayoutY.value())
        {
            case DataLayout::NDHWC:
            case DataLayout::NHWC:
                yAxes.first -= 1;
                yAxes.second -= 1;
                break;
            case DataLayout::NCDHW:
            case DataLayout::NCHW:
            default:
                break;
        }
    }

    return { xAxes, yAxes};
}

operator==()

bool operator== ( const BatchMatMulDescriptor &  rhs ) const

inline

Definition at line 1570 of file Descriptors.hpp.

References BatchMatMulDescriptor::m_AdjointX, BatchMatMulDescriptor::m_AdjointY, BatchMatMulDescriptor::m_DataLayoutX, BatchMatMulDescriptor::m_DataLayoutY, BatchMatMulDescriptor::m_TransposeX, and BatchMatMulDescriptor::m_TransposeY.

    {
        return m_DataLayoutX == rhs.m_DataLayoutX &&
               m_DataLayoutY == rhs.m_DataLayoutY &&
               m_TransposeX == rhs.m_TransposeX &&
               m_TransposeY == rhs.m_TransposeY &&
               m_AdjointX == rhs.m_AdjointX &&
               m_AdjointY == rhs.m_AdjointY;
    }

Member Data Documentation

m_AdjointX

std::vector<unsigned int> m_AdjointX

Adjoint vector for each input tensor (leave as empty vector for no pre-adjoint) Transpose and Adjoint can not both be set to true for the same tensor at the same time.

Definition at line 1591 of file Descriptors.hpp.

Referenced by BatchMatMulDescriptor::operator==().

m_AdjointY

std::vector<unsigned int> m_AdjointY

Definition at line 1592 of file Descriptors.hpp.

Referenced by BatchMatMulDescriptor::operator==().

m_DataLayoutX

Optional<DataLayout> m_DataLayoutX

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

Definition at line 1581 of file Descriptors.hpp.

Referenced by BatchMatMulDescriptor::GetAxesToMul(), and BatchMatMulDescriptor::operator==().

m_DataLayoutY

Optional<DataLayout> m_DataLayoutY

Definition at line 1582 of file Descriptors.hpp.

Referenced by BatchMatMulDescriptor::GetAxesToMul(), and BatchMatMulDescriptor::operator==().

m_TransposeX

std::vector<unsigned int> m_TransposeX

Transpose vector for each input tensor (leave as empty vector for no pre-transposing) Transpose and Adjoint can not both be set to true for the same tensor at the same time.

Definition at line 1586 of file Descriptors.hpp.

Referenced by BatchMatMulDescriptor::operator==().

m_TransposeY

std::vector<unsigned int> m_TransposeY

Definition at line 1587 of file Descriptors.hpp.

Referenced by BatchMatMulDescriptor::operator==().

---

The documentation for this struct was generated from the following files:

• include/armnn/Descriptors.hpp
• src/armnn/Descriptors.cpp