BatchMatMul Class Reference

#include <BatchMatMulImpl.hpp>

Public Types
enum	DataSlot { InputX = 0, InputY = 1, Output = 2 }

Public Member Functions
	BatchMatMul (const BatchMatMulDescriptor &params, const TensorInfo &inputXInfo, const TensorInfo &inputYInfo, const TensorInfo &outputInfo, Decoder< float > &inputXDecoder, Decoder< float > &inputYDecoder, Encoder< float > &outputEncoder)
void	BatchMatMulImpl ()
void	RecurseBMM (std::vector< unsigned int > &curIdx, unsigned int curDim)
void	AdjustAxesToMulForUnequalRanks (std::pair< std::pair< unsigned int, unsigned int >, std::pair< unsigned int, unsigned int >> &axesToMul)
float	GetValueAt (DataSlot type, std::vector< unsigned int > idx)
void	SetValueAt (float value, DataSlot type, std::vector< unsigned int > idx)
void	AdjustToSafeIdx (DataSlot type, std::vector< unsigned int > &idx)
unsigned int	CalcFlatIdx (DataSlot type, const std::vector< unsigned int > &idx)
template<typename T >
std::string	StringifyVec (const std::vector< T > &vec)

Detailed Description

Definition at line 16 of file BatchMatMulImpl.hpp.

Member Enumeration Documentation

DataSlot

enum DataSlot

Enumerator
InputX
InputY
Output

Definition at line 18 of file BatchMatMulImpl.hpp.

    {
        InputX = 0,
        InputY = 1,
        Output = 2
    };

Constructor & Destructor Documentation

BatchMatMul()

BatchMatMul ( const BatchMatMulDescriptor &  params, const TensorInfo &  inputXInfo, const TensorInfo &  inputYInfo, const TensorInfo &  outputInfo, Decoder< float > &  inputXDecoder, Decoder< float > &  inputYDecoder, Encoder< float > &  outputEncoder  )

inline

Definition at line 25 of file BatchMatMulImpl.hpp.

References BatchMatMul::AdjustAxesToMulForUnequalRanks(), BatchMatMul::AdjustToSafeIdx(), BatchMatMul::BatchMatMulImpl(), BatchMatMul::CalcFlatIdx(), BatchMatMul::GetValueAt(), BatchMatMul::RecurseBMM(), BatchMatMul::SetValueAt(), and BatchMatMul::StringifyVec().

        : params(params),
          inputXInfo(inputXInfo),
          inputYInfo(inputYInfo),
          outputInfo(outputInfo),
          inputXDecoder(inputXDecoder),
          inputYDecoder(inputYDecoder),
          outputEncoder(outputEncoder)
    {}

Member Function Documentation

AdjustAxesToMulForUnequalRanks()

void AdjustAxesToMulForUnequalRanks

(

std::pair< std::pair< unsigned int, unsigned int >, std::pair< unsigned int, unsigned int >> &

axesToMul

)

Definition at line 73 of file BatchMatMulImpl.cpp.

References TensorInfo::GetNumDimensions().

Referenced by BatchMatMul::BatchMatMul(), and BatchMatMul::RecurseBMM().

{
    int rankDiff = static_cast<int>(inputXInfo.GetNumDimensions()) -
                   static_cast<int>(inputYInfo.GetNumDimensions());
    if(rankDiff == 0)
    {
        return;
    }
    else if(rankDiff < 0)
    {
        // Y is the larger one
        axesToMul.first.first += static_cast<std::make_unsigned<unsigned int>::type>(std::abs(rankDiff));
        axesToMul.first.second += static_cast<std::make_unsigned<unsigned int>::type>(std::abs(rankDiff));
    }
    else if(rankDiff > 0)
    {
        // X is the larger one
        axesToMul.second.first += static_cast<std::make_unsigned<unsigned int>::type>(std::abs(rankDiff));
        axesToMul.second.second += static_cast<std::make_unsigned<unsigned int>::type>(std::abs(rankDiff));
    }
}

AdjustToSafeIdx()

void AdjustToSafeIdx	(	DataSlot	type,
		std::vector< unsigned int > &	idx
	)

Definition at line 147 of file BatchMatMulImpl.cpp.

References TensorInfo::GetNumDimensions(), TensorInfo::GetShape(), and armnn::Output.

Referenced by BatchMatMul::BatchMatMul(), BatchMatMul::GetValueAt(), and BatchMatMul::SetValueAt().

{
    for(unsigned int dim = 0; dim < idx.size(); dim++)
    {
        switch(type)
        {
            case DataSlot::InputX:
            {
                auto xRank = inputXInfo.GetNumDimensions();
                auto xDiff = outputInfo.GetNumDimensions() - xRank;
                if (dim < xDiff ||
                    idx[dim] > inputXInfo.GetShape()[dim-xDiff]-1)
                {
                    idx[dim] = 0; // Broadcasting
                }
                break;
            }
            case DataSlot::InputY:
            {
                auto yRank = inputYInfo.GetNumDimensions();
                auto yDiff = outputInfo.GetNumDimensions() - yRank;
                if (dim < yDiff ||
                    idx[dim] > inputYInfo.GetShape()[dim-yDiff]-1)
                {
                    idx[dim] = 0;
                }
                break;
            }
            case DataSlot::Output:
            {
                // Our indices are based off the output
                break;
            }
            default:
                break;
        }
    }
}

BatchMatMulImpl()

void BatchMatMulImpl

(

)

Definition at line 14 of file BatchMatMulImpl.cpp.

References Decoder< IType >::DecodeTensor(), TensorInfo::GetNumDimensions(), TensorInfo::GetShape(), and BatchMatMul::RecurseBMM().

Referenced by BatchMatMul::BatchMatMul().

{
    inputXData = inputXDecoder.DecodeTensor(inputXInfo.GetShape());
    inputYData = inputYDecoder.DecodeTensor(inputYInfo.GetShape());
    // At this point, we don't touch the input decoders - just the resultant vectors

    // Pre-transpose and pre-adjoint if their vectors aren't empty
    // and also DataLayouts which may change with permutations/adjoints

    // Todo: Have you updated input validation and inferred output shapes to accommodate for these pre-permutes?

    auto idx = std::vector<unsigned int>(outputInfo.GetNumDimensions(), 0);
    RecurseBMM(idx, 0);
}

CalcFlatIdx()

unsigned int CalcFlatIdx	(	DataSlot	type,
		const std::vector< unsigned int > &	idx
	)

Definition at line 186 of file BatchMatMulImpl.cpp.

References TensorInfo::GetNumDimensions(), TensorInfo::GetShape(), and armnn::Output.

Referenced by BatchMatMul::BatchMatMul(), BatchMatMul::GetValueAt(), and BatchMatMul::SetValueAt().

{
    unsigned int result = idx[idx.size()-1];

    unsigned int dimMultiplier = 1;

    unsigned int offset;

    // -2 because final dim is already accounted for in the multiplier (last dim is just a multiplier of 1x)
    for(unsigned int i = static_cast<unsigned int>(idx.size()-2); static_cast<int>(i) >= 0; i--)
    {
        switch(type)
        {
            case DataSlot::InputX:
                offset = outputInfo.GetNumDimensions() - inputXInfo.GetNumDimensions();
                dimMultiplier *= inputXInfo.GetShape()[i + 1 - offset];
                break;
            case DataSlot::InputY:
                offset = outputInfo.GetNumDimensions() - inputYInfo.GetNumDimensions();
                dimMultiplier *= inputYInfo.GetShape()[i + 1 - offset];
                break;
            case DataSlot::Output:
                dimMultiplier *= outputInfo.GetShape()[i+1];
                break;
            default:
                break;
        }
        result += (idx[i] * dimMultiplier);
    }
    return result;
}

GetValueAt()

float GetValueAt	(	DataSlot	type,
		std::vector< unsigned int >	idx
	)

Definition at line 96 of file BatchMatMulImpl.cpp.

References BatchMatMul::AdjustToSafeIdx(), BatchMatMul::CalcFlatIdx(), Encoder< IType >::Get(), and armnn::Output.

Referenced by BatchMatMul::BatchMatMul(), and BatchMatMul::RecurseBMM().

{
    // This gets the data from the input vector that we have, Not the decoder
    // But for the output, it is operating on the encoder itself

    AdjustToSafeIdx(type, idx);
    unsigned int flatIdx = CalcFlatIdx(type, idx);
    float value = 0.0f;

    switch(type)
    {
        case DataSlot::InputX:
            value = inputXData[flatIdx];
            break;
        case DataSlot::InputY:
            value = inputYData[flatIdx];
            break;
        case DataSlot::Output:
            outputEncoder[flatIdx];
            value = outputEncoder.Get();
            break;
        default:
            break;
    }

    return value;
}

RecurseBMM()

void RecurseBMM	(	std::vector< unsigned int > &	curIdx,
		unsigned int	curDim
	)

Definition at line 29 of file BatchMatMulImpl.cpp.

References BatchMatMul::AdjustAxesToMulForUnequalRanks(), BatchMatMulDescriptor::GetAxesToMul(), TensorInfo::GetNumDimensions(), TensorInfo::GetShape(), BatchMatMul::GetValueAt(), armnn::Output, and BatchMatMul::SetValueAt().

Referenced by BatchMatMul::BatchMatMul(), and BatchMatMul::BatchMatMulImpl().

{
    // We're working off of the indexes of the output tensor (the max possible shape)

    if(!(curDim < outputInfo.GetNumDimensions()))
    {
        // We're at the leaf level of this call tree, so we operate here (each leaf is a data point)

        auto axesToMul = BatchMatMulDescriptor::GetAxesToMul(params,
                                                             inputXInfo.GetShape(),
                                                             inputYInfo.GetShape());
        AdjustAxesToMulForUnequalRanks(axesToMul);

        unsigned int inputXColDim = axesToMul.first.second;
        unsigned int inputYRowDim = axesToMul.second.first;

        unsigned int inputYRowSize = inputYInfo.GetShape()[inputYRowDim];

        float sum = 0.0f;

        // You could also use inputXColSize
        for (unsigned int inputYRowIdx = 0; inputYRowIdx < inputYRowSize; inputYRowIdx++) {
            auto xIdx = curIdx;
            xIdx[inputXColDim] = inputYRowIdx;

            auto yIdx = curIdx;
            yIdx[inputYRowDim] = inputYRowIdx;

            sum += (GetValueAt(DataSlot::InputX, xIdx)
                  * GetValueAt(DataSlot::InputY, yIdx));
        }

        SetValueAt(sum, DataSlot::Output, curIdx);

        return;
    }

    for (unsigned int i = 0; i < outputInfo.GetShape()[curDim]; i++)
    {
        curIdx[curDim] = i;
        RecurseBMM(curIdx, curDim+1);
    }
}

SetValueAt()

void SetValueAt	(	float	value,
		DataSlot	type,
		std::vector< unsigned int >	idx
	)

Definition at line 124 of file BatchMatMulImpl.cpp.

References BatchMatMul::AdjustToSafeIdx(), BatchMatMul::CalcFlatIdx(), armnn::Output, and Encoder< IType >::Set().

Referenced by BatchMatMul::BatchMatMul(), and BatchMatMul::RecurseBMM().

{
    AdjustToSafeIdx(type, idx);

    unsigned int flatIdx = CalcFlatIdx(type, idx);

    switch(type)
    {
        case DataSlot::InputX:
            inputXData[flatIdx] = value;
            break;
        case DataSlot::InputY:
            inputYData[flatIdx] = value;
            break;
        case DataSlot::Output:
            outputEncoder[flatIdx];
            outputEncoder.Set(value);
            break;
        default:
            break;
    }
}

StringifyVec()

std::string StringifyVec

(

const std::vector< T > &

vec

)

Definition at line 219 of file BatchMatMulImpl.cpp.

Referenced by BatchMatMul::BatchMatMul().

{
    std::string res = "{ ";
    for(auto x : vec)
    {
        res += std::to_string(x);
        res += " ";
    }
    res += "}";
    return res;
}

---

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

• src/backends/reference/workloads/BatchMatMulImpl.hpp
• src/backends/reference/workloads/BatchMatMulImpl.cpp