EthosnRefTransposeConvolutionImpl.hpp

Go to the documentation of this file.

//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//

#pragma once

#include "EthosnRefWorkloadUtils.hpp"
#include "TensorBufferArrayView.hpp"

#include <armnn/Tensor.hpp>

#include <armnnUtils/DataLayoutIndexed.hpp>

#include <armnn/utility/NumericCast.hpp>

#include <cmath>
#include <limits>
#include "EthosnRefConvImpl.hpp"

namespace armnn
{

template<typename TransConvData, typename InputType, typename FilterType, typename BiasType, typename AccumulatorType>
static void EthosnRefTransposeConvolutionImpl(TransConvData data,
                                        const InputType* inputData,
                                        float inputScale,
                                        int32_t inputOffset,
                                        const FilterType* filterData,
                                        float filterScale,
                                        int32_t filterOffset,
                                        const BiasType* biasData,
                                        float outputScale,
                                        int32_t outputOffset,
                                        const TensorInfo& filterInfo)

{

    if (data.m_Parameters.m_BiasEnabled && !biasData)
    {
        throw InvalidArgumentException("Biases enabled but no bias data provided");
    }

    const TensorInfo& inputInfo  = armnn::ethosnref::GetTensorInfo(data.m_Inputs[0]);
    const TensorInfo& outputInfo = armnn::ethosnref::GetTensorInfo(data.m_Outputs[0]);

    TensorBufferArrayView<InputType> output(outputInfo.GetShape(),
                                            armnn::ethosnref::GetOutputTensorData<InputType>(0, data),
                                            data.m_Parameters.m_DataLayout);

    const armnnUtils::DataLayoutIndexed dataLayoutIndexed(data.m_Parameters.m_DataLayout);

    const unsigned int channelsIndex = dataLayoutIndexed.GetChannelsIndex();
    const unsigned int heightIndex   = dataLayoutIndexed.GetHeightIndex();
    const unsigned int widthIndex    = dataLayoutIndexed.GetWidthIndex();

    unsigned int numBatches = inputInfo.GetShape()[0];

    unsigned int inputWidth  = inputInfo.GetShape()[widthIndex];
    unsigned int inputHeight = inputInfo.GetShape()[heightIndex];
    unsigned int inputDepth  = inputInfo.GetShape()[channelsIndex];

    unsigned int filterHeight = filterInfo.GetShape()[heightIndex];
    unsigned int filterWidth  = filterInfo.GetShape()[widthIndex];

    unsigned int outputHeight = outputInfo.GetShape()[heightIndex];
    unsigned int outputWidth  = outputInfo.GetShape()[widthIndex];
    unsigned int outputDepth  = outputInfo.GetShape()[channelsIndex];

    unsigned int paddingLeft = data.m_Parameters.m_PadLeft;
    unsigned int paddingTop  = data.m_Parameters.m_PadTop;

    unsigned int strideX = data.m_Parameters.m_StrideX;
    unsigned int strideY = data.m_Parameters.m_StrideY;

    std::vector<AccumulatorType> outputBuffer(outputInfo.GetShape().GetNumElements(), 0);

    for (unsigned int batch = 0u; batch < numBatches; ++batch)
    {
        for (unsigned int yInput = 0u; yInput < inputHeight; ++yInput)
        {
            for (unsigned int xInput = 0u; xInput < inputWidth; ++xInput)
            {
                unsigned int xOutputOrigin = xInput * strideX - paddingLeft;
                unsigned int yOutputOrigin = yInput * strideY - paddingTop;

                for (unsigned int dOutput = 0u; dOutput < outputDepth; ++dOutput)
                {
                    for (unsigned int yFilters = 0u; yFilters < filterHeight; ++yFilters)
                    {
                        for (unsigned int xFilters = 0u; xFilters < filterWidth; ++xFilters)
                        {
                            unsigned int yOutput = yOutputOrigin + yFilters;
                            unsigned int xOutput = xOutputOrigin + xFilters;

                            if (yOutput < outputHeight && xOutput< outputWidth)
                            {
                                for (unsigned int dInput = 0u; dInput < inputDepth; dInput++)
                                {
                                    const unsigned int inputIndex =
                                        dataLayoutIndexed.GetIndex(inputInfo.GetShape(), batch, dInput, yInput, xInput);

                                    const unsigned int filterIndex =
                                        dataLayoutIndexed.GetIndex(filterInfo.GetShape(), dOutput, dInput, yFilters, xFilters);

                                    const unsigned int outputIndex = batch * outputDepth * outputHeight * outputWidth +
                                                                     dOutput * outputHeight * outputWidth +
                                                                     yOutput * outputWidth +
                                                                     xOutput;

                                    outputBuffer[outputIndex] += (inputData[inputIndex] - numeric_cast<AccumulatorType>(inputOffset)) * (filterData[filterIndex] - numeric_cast<AccumulatorType>(filterOffset));
                                }
                            }
                        }
                    }
                }
            }
        }
    }


    // Apply bias (if enabled)
    for (unsigned int batch = 0u; batch < numBatches; ++batch)
    {
        for (unsigned int dOutput = 0u; dOutput < outputDepth; ++dOutput)
        {
            for (unsigned int yOutput = 0u; yOutput < outputHeight; ++yOutput)
            {
                for (unsigned int xOutput = 0u; xOutput < outputWidth; ++xOutput)
                {
                    const unsigned int biaspass_outputIndex = batch * outputDepth * outputHeight * outputWidth +
                                                              dOutput * outputHeight * outputWidth +
                                                              yOutput * outputWidth +
                                                              xOutput;

                    if (data.m_Parameters.m_BiasEnabled)
                    {
                        outputBuffer[biaspass_outputIndex] += biasData[dOutput];
                    }

                    if (outputScale != 0.0f)
                    {
                        float multiplier = (inputScale * filterScale) / outputScale;
                        outputBuffer[biaspass_outputIndex] = numeric_cast<AccumulatorType>(EthosnRefQuantizedMultiplierSmallerThanOne(multiplier) * outputBuffer[biaspass_outputIndex])
                              + numeric_cast<AccumulatorType>(outputOffset);
                        outputBuffer[biaspass_outputIndex] = std::min<AccumulatorType>(std::max<AccumulatorType>(outputBuffer[biaspass_outputIndex], std::numeric_limits<InputType>::min()), std::numeric_limits<InputType>::max());
                    }

                    output.Get(batch, dOutput, yOutput, xOutput) = numeric_cast<InputType>( outputBuffer[biaspass_outputIndex] );
                }
            }
        }
    }
}

} // namespace arm