QuantizedLstmEndToEndTestImpl.cpp File Reference

#include "QuantizedLstmEndToEndTestImpl.hpp"
#include <CommonTestUtils.hpp>
#include "EndToEndTestImpl.hpp"
#include <ResolveType.hpp>
#include <armnn/INetwork.hpp>
#include <armnn/QuantizedLstmParams.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <armnnTestUtils/TensorHelpers.hpp>
#include <doctest/doctest.h>
#include <type_traits>

Go to the source code of this file.

Functions
void	QuantizedLstmEndToEnd (const std::vector< armnn::BackendId > &backends)

Function Documentation

QuantizedLstmEndToEnd()

void QuantizedLstmEndToEnd

(

const std::vector< armnn::BackendId > &

backends

)

Definition at line 181 of file QuantizedLstmEndToEndTestImpl.cpp.

References armnn::Optimize(), armnn::QAsymmU8, armnn::QSymmS16, and TensorInfo::SetConstant().

Referenced by TEST_SUITE().

{
    std::vector<uint8_t> inputVector = {166, 179, 50, 150};
    armnn::TensorInfo inputDesc({2, 2}, armnn::DataType::QAsymmU8);

    std::vector<int16_t> cellStateInVector = {876, 1034, 955, -909, 761, 1029, 796, -1036};
    armnn::TensorInfo cellStateInDesc({2, 4}, armnn::DataType::QSymmS16);

    std::vector<uint8_t> outputStateInVector = {136, 150, 140, 115, 135, 152, 138, 112};
    armnn::TensorInfo outputStateInDesc({2, 4}, armnn::DataType::QAsymmU8);

    std::vector<int16_t> cellStateOutVector = {1485, 1177, 1373, -1023, 1019, 1355, 1097, -1235};
    armnn::TensorInfo cellStateOutVectorDesc({2, 4}, armnn::DataType::QSymmS16);

    std::vector<uint8_t> outputStateOutVector = {140, 151, 146, 112, 136, 156, 142, 112};
    armnn::TensorInfo outputDesc({2, 4}, armnn::DataType::QAsymmU8);

    // Builds up the structure of the network
    armnn::INetworkPtr net = CreateQuantizedLstmNetwork(inputDesc.GetShape(), outputDesc.GetShape());

    IRuntime::CreationOptions options;
    IRuntimePtr runtime(IRuntime::Create(options));

    // optimize the network
    IOptimizedNetworkPtr optNet = Optimize(*net, backends, runtime->GetDeviceSpec());

    // Loads it into the runtime.
    NetworkId netId;
    runtime->LoadNetwork(netId, std::move(optNet));

    InputTensors inputTensors;
    inputTensors.reserve(3);

    // input
    TensorInfo inputTensorInfo0 = runtime->GetInputTensorInfo(netId, 0);
    TensorInfo inputTensorInfo1 = runtime->GetInputTensorInfo(netId, 1);
    TensorInfo inputTensorInfo2 = runtime->GetInputTensorInfo(netId, 2);
    inputTensorInfo0.SetConstant(true);
    inputTensorInfo1.SetConstant(true);
    inputTensorInfo2.SetConstant(true);

    inputTensors.push_back({0, ConstTensor(inputTensorInfo0, inputVector.data())});
    inputTensors.push_back({1, ConstTensor(inputTensorInfo1, cellStateInVector.data())});
    inputTensors.push_back({2, ConstTensor(inputTensorInfo2, outputStateInVector.data())});

    OutputTensors outputTensors;
    outputTensors.reserve(2);

    //output
    std::vector<int16_t> cellStateOutResult(cellStateOutVector.size());
    std::vector<uint8_t> outputStateOutResult(outputStateOutVector.size());
    outputTensors.push_back({0, Tensor(runtime->GetOutputTensorInfo(netId, 0), cellStateOutResult.data())});
    outputTensors.push_back({1, Tensor(runtime->GetOutputTensorInfo(netId, 1), outputStateOutResult.data())});

    // Does the inference.
    runtime->EnqueueWorkload(netId, inputTensors, outputTensors);

    // Checks the results
    constexpr int16_t toleranceInt16 = 2;
    for (unsigned int i = 0u; i < cellStateOutResult.size(); ++i)
    {
        CHECK(IsCloseEnough(cellStateOutVector[i], cellStateOutResult[i], toleranceInt16));
    }

    constexpr uint8_t toleranceUint8 = 1;
    for (unsigned int i = 0u; i < outputStateOutResult.size(); ++i)
    {
        CHECK(IsCloseEnough(outputStateOutVector[i], outputStateOutResult[i], toleranceUint8));
    }
}