1046 lines
53 KiB
C++
1046 lines
53 KiB
C++
//
|
|
// Copyright © 2020 Arm Ltd. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
//
|
|
|
|
#include "../DriverTestHelpers.hpp"
|
|
#include "../TestTensor.hpp"
|
|
|
|
#include "../1.3/HalPolicy.hpp"
|
|
|
|
#include <armnn/utility/IgnoreUnused.hpp>
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
#include <boost/test/data/test_case.hpp>
|
|
#include <boost/math/special_functions/relative_difference.hpp>
|
|
|
|
#include <array>
|
|
|
|
BOOST_AUTO_TEST_SUITE(QLSTMTests)
|
|
|
|
using ArmnnDriver = armnn_driver::ArmnnDriver;
|
|
using DriverOptions = armnn_driver::DriverOptions;
|
|
|
|
using namespace driverTestHelpers;
|
|
using namespace android::hardware;
|
|
|
|
using HalPolicy = hal_1_3::HalPolicy;
|
|
|
|
namespace
|
|
{
|
|
|
|
template<typename T>
|
|
RequestArgument CreateRequestArgument(const std::vector<T>& value, unsigned int poolIndex)
|
|
{
|
|
DataLocation inputInloc = {};
|
|
inputInloc.poolIndex = poolIndex;
|
|
inputInloc.offset = 0;
|
|
inputInloc.length = value.size() * sizeof(T);
|
|
RequestArgument inputRequestArgument = {};
|
|
inputRequestArgument.location = inputInloc;
|
|
inputRequestArgument.dimensions = hidl_vec<uint32_t>{};
|
|
return inputRequestArgument;
|
|
}
|
|
|
|
// Returns true if the relative difference between two float values is less than the tolerance value given.
|
|
// This is used because the floating point comparison tolerance (set on each BOOST_AUTO_TEST_CASE) does not work!
|
|
bool TolerantCompareEqual(float a, float b, float tolerance = 1.0f)
|
|
{
|
|
float rd;
|
|
if (a == 0.0f)
|
|
{
|
|
rd = fabs(b);
|
|
}
|
|
else if (b == 0.0f)
|
|
{
|
|
rd = fabs(a);
|
|
}
|
|
else
|
|
{
|
|
rd = boost::math::relative_difference(a, b);
|
|
}
|
|
return rd < tolerance;
|
|
}
|
|
|
|
// Helper function to create an OperandLifeTime::NO_VALUE for testing.
|
|
// To be used on optional input operands that have no values - these are valid and should be tested.
|
|
HalPolicy::OperandLifeTime CreateNoValueLifeTime(const hidl_vec<uint32_t>& dimensions)
|
|
{
|
|
// Only create a NO_VALUE for optional operands that have no elements
|
|
if (dimensions.size() == 0 || dimensions[0] == 0)
|
|
{
|
|
return HalPolicy::OperandLifeTime::NO_VALUE;
|
|
}
|
|
return HalPolicy::OperandLifeTime::CONSTANT_COPY;
|
|
}
|
|
|
|
void ExecuteModel(const armnn_driver::hal_1_3::HalPolicy::Model& model,
|
|
armnn_driver::ArmnnDriver& driver,
|
|
const V1_0::Request& request)
|
|
{
|
|
android::sp<V1_3::IPreparedModel> preparedModel = PrepareModel_1_3(model, driver);
|
|
if (preparedModel.get() != nullptr)
|
|
{
|
|
Execute(preparedModel, request);
|
|
}
|
|
}
|
|
|
|
#ifndef ARMCOMPUTECL_ENABLED
|
|
static const std::array<armnn::Compute, 1> COMPUTE_DEVICES = {{ armnn::Compute::CpuRef }};
|
|
#else
|
|
static const std::array<armnn::Compute, 2> COMPUTE_DEVICES = {{ armnn::Compute::CpuRef, armnn::Compute::CpuAcc }};
|
|
#endif
|
|
|
|
// Add our own tests here since we skip the qlstm tests which Google supplies (because of non-const weights)
|
|
void QLstmTestImpl(const hidl_vec<uint32_t>& inputDimensions,
|
|
const std::vector<int8_t>& inputValue,
|
|
const hidl_vec<uint32_t>& inputToInputWeightsDimensions,
|
|
const std::vector<int8_t>& inputToInputWeightsValue,
|
|
const hidl_vec<uint32_t>& inputToForgetWeightsDimensions,
|
|
const std::vector<int8_t>& inputToForgetWeightsValue,
|
|
const hidl_vec<uint32_t>& inputToCellWeightsDimensions,
|
|
const std::vector<int8_t>& inputToCellWeightsValue,
|
|
const hidl_vec<uint32_t>& inputToOutputWeightsDimensions,
|
|
const std::vector<int8_t>& inputToOutputWeightsValue,
|
|
const hidl_vec<uint32_t>& recurrentToInputWeightsDimensions,
|
|
const std::vector<int8_t>& recurrentToInputWeightsValue,
|
|
const hidl_vec<uint32_t>& recurrentToForgetWeightsDimensions,
|
|
const std::vector<int8_t>& recurrentToForgetWeightsValue,
|
|
const hidl_vec<uint32_t>& recurrentToCellWeightsDimensions,
|
|
const std::vector<int8_t>& recurrentToCellWeightsValue,
|
|
const hidl_vec<uint32_t>& recurrentToOutputWeightsDimensions,
|
|
const std::vector<int8_t>& recurrentToOutputWeightsValue,
|
|
const hidl_vec<uint32_t>& cellToInputWeightsDimensions,
|
|
const std::vector<int16_t>& cellToInputWeightsValue,
|
|
const hidl_vec<uint32_t>& cellToForgetWeightsDimensions,
|
|
const std::vector<int16_t>& cellToForgetWeightsValue,
|
|
const hidl_vec<uint32_t>& cellToOutputWeightsDimensions,
|
|
const std::vector<int16_t>& cellToOutputWeightsValue,
|
|
const hidl_vec<uint32_t>& inputGateBiasDimensions,
|
|
const std::vector<int32_t>& inputGateBiasValue,
|
|
const hidl_vec<uint32_t>& forgetGateBiasDimensions,
|
|
const std::vector<int32_t>& forgetGateBiasValue,
|
|
const hidl_vec<uint32_t>& cellBiasDimensions,
|
|
const std::vector<int32_t>& cellBiasValue,
|
|
const hidl_vec<uint32_t>& outputGateBiasDimensions,
|
|
const std::vector<int32_t>& outputGateBiasValue,
|
|
const hidl_vec<uint32_t>& projectionWeightsDimensions,
|
|
const std::vector<int8_t>& projectionWeightsValue,
|
|
const hidl_vec<uint32_t>& projectionBiasDimensions,
|
|
const std::vector<int32_t>& projectionBiasValue,
|
|
const hidl_vec<uint32_t>& outputPreviousTimeStepInDimensions,
|
|
const std::vector<int8_t>& outputPreviousTimeStepInValue,
|
|
const hidl_vec<uint32_t>& cellStatePreviousTimeStepInDimensions,
|
|
const std::vector<int16_t>& cellStatePreviousTimeStepInValue,
|
|
const hidl_vec<uint32_t>& inputLayerNormWeightsDimensions,
|
|
const std::vector<int16_t>& inputLayerNormWeightsValue,
|
|
const hidl_vec<uint32_t>& forgetLayerNormWeightsDimensions,
|
|
const std::vector<int16_t>& forgetLayerNormWeightsValue,
|
|
const hidl_vec<uint32_t>& cellLayerNormWeightsDimensions,
|
|
const std::vector<int16_t>& cellLayerNormWeightsValue,
|
|
const hidl_vec<uint32_t>& outputLayerNormWeightsDimensions,
|
|
const std::vector<int16_t>& outputLayerNormWeightsValue,
|
|
const float& cellClipValue,
|
|
const float& projectionClipValue,
|
|
const float& matMulInputGateValue,
|
|
const float& matMulForgetGateValue,
|
|
const float& matMulCellGateValue,
|
|
const float& matMulOutputGateValue,
|
|
const int32_t& projInputZeroPointValue,
|
|
const float& projInputScaleValue,
|
|
const hidl_vec<uint32_t>& outputStateOutDimensions,
|
|
const std::vector<int8_t>& outputStateOutValue,
|
|
const hidl_vec<uint32_t>& cellStateOutDimensions,
|
|
const std::vector<int16_t>& cellStateOutValue,
|
|
const hidl_vec<uint32_t>& outputDimensions,
|
|
const std::vector<int8_t>& outputValue,
|
|
armnn::Compute compute)
|
|
{
|
|
auto driver = std::make_unique<ArmnnDriver>(DriverOptions(compute));
|
|
HalPolicy::Model model = {};
|
|
|
|
// Scale/Offset quantization info
|
|
float inputScale = 0.0078125f;
|
|
int32_t inputOffset = 0;
|
|
|
|
int32_t hiddenStateZeroPoint = 0;
|
|
float hiddenStateScale = 0.007f;
|
|
|
|
float outputScale = hiddenStateScale;
|
|
int32_t outputOffset = hiddenStateZeroPoint;
|
|
|
|
float cellStateScale = 3.05176e-05f;
|
|
float cellWeightsScale = 1.0f;
|
|
int32_t cellStateOffset = 0;
|
|
|
|
float weightsScale = 0.00784314f;
|
|
int32_t weightsOffset = 0;
|
|
|
|
float layerNormScale = 3.05182e-05f;
|
|
int32_t layerNormOffset = 0;
|
|
|
|
float biasScale = layerNormScale / 1024;
|
|
int32_t biasOffset = 0;
|
|
|
|
// Inputs:
|
|
// 00: The input to the LSTM cell. Type: ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED Shape: [batchSize, inputSize]
|
|
AddInputOperand<HalPolicy>(model,
|
|
inputDimensions,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_ASYMM_SIGNED,
|
|
inputScale,
|
|
inputOffset);
|
|
|
|
// 01: The input-to-input weights. Optional. Type: ANEURALNETWORKS_TENSOR_QUANT8_SYMM Shape: [numUnits, inputSize]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
inputToInputWeightsDimensions,
|
|
inputToInputWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_SYMM,
|
|
CreateNoValueLifeTime(inputToInputWeightsDimensions),
|
|
weightsScale,
|
|
weightsOffset);
|
|
|
|
// 02: The input-to-forget weights. Type: ANEURALNETWORKS_TENSOR_QUANT8_SYMM Shape: [numUnits, inputSize]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
inputToForgetWeightsDimensions,
|
|
inputToForgetWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_SYMM,
|
|
CreateNoValueLifeTime(inputToForgetWeightsDimensions),
|
|
weightsScale,
|
|
weightsOffset);
|
|
|
|
// 03: The input-to-cell weights. Type: ANEURALNETWORKS_TENSOR_QUANT8_SYMM Shape: [numUnits, inputSize]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
inputToCellWeightsDimensions,
|
|
inputToCellWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_SYMM,
|
|
CreateNoValueLifeTime(inputToCellWeightsDimensions),
|
|
weightsScale,
|
|
weightsOffset);
|
|
|
|
// 04: The input-to-output weights. Type: ANEURALNETWORKS_TENSOR_QUANT8_SYMM Shape: [numUnits, inputSize]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
inputToOutputWeightsDimensions,
|
|
inputToOutputWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_SYMM,
|
|
CreateNoValueLifeTime(inputToOutputWeightsDimensions),
|
|
weightsScale,
|
|
weightsOffset);
|
|
|
|
// 05: The recurrent-to-input weights. Optional. Type: ANEURALNETWORKS_TENSOR_QUANT8_SYMM
|
|
// Shape: [numUnits, outputSize]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
recurrentToInputWeightsDimensions,
|
|
recurrentToInputWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_SYMM,
|
|
CreateNoValueLifeTime(recurrentToInputWeightsDimensions),
|
|
weightsScale,
|
|
weightsOffset);
|
|
|
|
// 06: The recurrent-to-forget weights. Type: ANEURALNETWORKS_TENSOR_QUANT8_SYMM Shape: [numUnits, outputSize]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
recurrentToForgetWeightsDimensions,
|
|
recurrentToForgetWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_SYMM,
|
|
CreateNoValueLifeTime(recurrentToForgetWeightsDimensions),
|
|
weightsScale,
|
|
weightsOffset);
|
|
|
|
// 07: The recurrent-to-cell weights. Type: ANEURALNETWORKS_TENSOR_QUANT8_SYMM Shape: [numUnits, outputSize]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
recurrentToCellWeightsDimensions,
|
|
recurrentToCellWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_SYMM,
|
|
CreateNoValueLifeTime(recurrentToCellWeightsDimensions),
|
|
weightsScale,
|
|
weightsOffset);
|
|
|
|
// 08: The recurrent-to-output weights. Type: ANEURALNETWORKS_TENSOR_QUANT8_SYMM Shape: [numUnits, outputSize]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
recurrentToOutputWeightsDimensions,
|
|
recurrentToOutputWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_SYMM,
|
|
CreateNoValueLifeTime(recurrentToOutputWeightsDimensions),
|
|
weightsScale,
|
|
weightsOffset);
|
|
|
|
// 09: The cell-to-input weights (for peephole). Optional. Type: ANEURALNETWORKS_TENSOR_QUANT16_SYMM
|
|
// Shape: [numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
cellToInputWeightsDimensions,
|
|
cellToInputWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT16_SYMM ,
|
|
CreateNoValueLifeTime(cellToInputWeightsDimensions),
|
|
cellWeightsScale,
|
|
weightsOffset);
|
|
|
|
// 10: The cell-to-forget weights (for peephole). Optional. Type: ANEURALNETWORKS_TENSOR_QUANT16_SYMM
|
|
// Shape: [numUnits].
|
|
AddTensorOperand<HalPolicy>(model,
|
|
cellToForgetWeightsDimensions,
|
|
cellToForgetWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT16_SYMM,
|
|
CreateNoValueLifeTime(cellToForgetWeightsDimensions),
|
|
cellWeightsScale,
|
|
weightsOffset);
|
|
|
|
// 11: The cell-to-output weights (for peephole). Optional. Type: ANEURALNETWORKS_TENSOR_QUANT16_SYMM
|
|
// Shape: [numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
cellToOutputWeightsDimensions,
|
|
cellToOutputWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT16_SYMM,
|
|
CreateNoValueLifeTime(cellToOutputWeightsDimensions),
|
|
cellWeightsScale,
|
|
weightsOffset);
|
|
|
|
// 12: The input gate bias. Quantized with scale being the product of input and weights scales
|
|
// and zeroPoint equal to 0. Optional. Type: ANEURALNETWORKS_TENSOR_INT32 Shape: [numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
inputGateBiasDimensions,
|
|
inputGateBiasValue,
|
|
HalPolicy::OperandType::TENSOR_INT32,
|
|
CreateNoValueLifeTime(inputGateBiasDimensions),
|
|
biasScale,
|
|
biasOffset);
|
|
|
|
// 13: The forget gate bias. Quantized with scale being the product of input and weights scales
|
|
// and zeroPoint equal to 0. Type: ANEURALNETWORKS_TENSOR_INT32 Shape: [numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
forgetGateBiasDimensions,
|
|
forgetGateBiasValue,
|
|
HalPolicy::OperandType::TENSOR_INT32,
|
|
CreateNoValueLifeTime(forgetGateBiasDimensions),
|
|
biasScale,
|
|
biasOffset);
|
|
|
|
// 14: The cell bias. Quantized with scale being the product of input and weights scales and zeroPoint equal to 0.
|
|
// Type: ANEURALNETWORKS_TENSOR_INT32 Shape: [numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
cellBiasDimensions,
|
|
cellBiasValue,
|
|
HalPolicy::OperandType::TENSOR_INT32,
|
|
CreateNoValueLifeTime(cellBiasDimensions),
|
|
biasScale,
|
|
biasOffset);
|
|
|
|
// 15: The output gate bias. Quantized with scale being the product of input and weights scales
|
|
// and zeroPoint equal to 0. Type: ANEURALNETWORKS_TENSOR_INT32 Shape: [numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
outputGateBiasDimensions,
|
|
outputGateBiasValue,
|
|
HalPolicy::OperandType::TENSOR_INT32,
|
|
CreateNoValueLifeTime(outputGateBiasDimensions),
|
|
biasScale,
|
|
biasOffset);
|
|
|
|
// 16: The projection weights. Optional. Type: ANEURALNETWORKS_TENSOR_QUANT8_SYMM Shape: [outputSize, numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
projectionWeightsDimensions,
|
|
projectionWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_SYMM,
|
|
CreateNoValueLifeTime(projectionWeightsDimensions),
|
|
0.00392157f,
|
|
weightsOffset);
|
|
|
|
// 17: The projection bias. Quantized with scale being the product of input and weights scales
|
|
// and zeroPoint equal to 0. Optional. Type: ANEURALNETWORKS_TENSOR_INT32 Shape: [outputSize]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
projectionBiasDimensions,
|
|
projectionBiasValue,
|
|
HalPolicy::OperandType::TENSOR_INT32,
|
|
CreateNoValueLifeTime(projectionBiasDimensions),
|
|
0.0f,
|
|
biasOffset);
|
|
|
|
// 18: The output from the previous time step. Type: ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED
|
|
// Shape: [batchSize, outputSize]
|
|
AddInputOperand<HalPolicy>(model,
|
|
outputPreviousTimeStepInDimensions,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_ASYMM_SIGNED,
|
|
cellStateScale,
|
|
inputOffset);
|
|
|
|
// 19: The cell state from the previous time step. Type: ANEURALNETWORKS_TENSOR_QUANT16_SYMM
|
|
// Shape: [batchSize, numUnits]
|
|
AddInputOperand<HalPolicy>(model,
|
|
cellStatePreviousTimeStepInDimensions,
|
|
HalPolicy::OperandType::TENSOR_QUANT16_SYMM,
|
|
cellStateScale,
|
|
cellStateOffset);
|
|
|
|
// If any of the tensors have a value all normalization tensors are set
|
|
if (!inputLayerNormWeightsValue.empty() ||
|
|
!forgetLayerNormWeightsValue.empty() ||
|
|
!cellLayerNormWeightsValue.empty() ||
|
|
!outputLayerNormWeightsValue.empty())
|
|
{
|
|
// Normalization:
|
|
// 20: The input layer normalization weights. Used to rescale normalized inputs to activation at input gate.
|
|
// Optional. Type: ANEURALNETWORKS_TENSOR_QUANT16_SYMM Shape: [numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
inputLayerNormWeightsDimensions,
|
|
inputLayerNormWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT16_SYMM,
|
|
CreateNoValueLifeTime(inputLayerNormWeightsDimensions),
|
|
layerNormScale,
|
|
layerNormOffset);
|
|
|
|
// 21: The forget layer normalization weights. Used to rescale normalized inputs to activation at forget gate.
|
|
// Optional. Type: ANEURALNETWORKS_TENSOR_QUANT16_SYMM Shape: [numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
forgetLayerNormWeightsDimensions,
|
|
forgetLayerNormWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT16_SYMM,
|
|
CreateNoValueLifeTime(forgetLayerNormWeightsDimensions),
|
|
layerNormScale,
|
|
layerNormOffset);
|
|
|
|
// 22: The cell layer normalization weights. Used to rescale normalized inputs to activation at cell gate.
|
|
// Optional. Type: ANEURALNETWORKS_TENSOR_QUANT16_SYMM Shape: [numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
cellLayerNormWeightsDimensions,
|
|
cellLayerNormWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT16_SYMM,
|
|
CreateNoValueLifeTime(cellLayerNormWeightsDimensions),
|
|
layerNormScale,
|
|
layerNormOffset);
|
|
|
|
// 23: The output layer normalization weights. Used to rescale normalized inputs to activation at output gate.
|
|
// Optional. Type: ANEURALNETWORKS_TENSOR_QUANT16_SYMM Shape: [numUnits]
|
|
AddTensorOperand<HalPolicy>(model,
|
|
outputLayerNormWeightsDimensions,
|
|
outputLayerNormWeightsValue,
|
|
HalPolicy::OperandType::TENSOR_QUANT16_SYMM,
|
|
CreateNoValueLifeTime(outputLayerNormWeightsDimensions),
|
|
layerNormScale,
|
|
layerNormOffset);
|
|
}
|
|
|
|
// Constant scalar values
|
|
// 24: The cell clip. If provided the cell state is clipped by this value prior to the cell output activation.
|
|
// Optional. Type: ANEURALNETWORKS_FLOAT32.
|
|
AddFloatOperand<HalPolicy>(model, cellClipValue);
|
|
|
|
// Constant scalar values
|
|
// 25: The projection clip. If provided and projection is enabled, this is used for clipping the projected values.
|
|
// Optional. Type: ANEURALNETWORKS_FLOAT32.
|
|
AddFloatOperand<HalPolicy>(model, projectionClipValue);
|
|
|
|
// Constant scalar values
|
|
// 26: The scale of the intermediate result of matmul, i.e. input to layer normalization, at input gate.
|
|
// Type: ANEURALNETWORKS_FLOAT32.
|
|
AddFloatOperand<HalPolicy>(model, matMulInputGateValue);
|
|
|
|
// Constant scalar values
|
|
// 27: The scale of the intermediate result of matmul, i.e. input to layer normalization, at forget gate.
|
|
// Type: ANEURALNETWORKS_FLOAT32.
|
|
AddFloatOperand<HalPolicy>(model, matMulForgetGateValue);
|
|
|
|
// Constant scalar values
|
|
// 28: The scale of the intermediate result of matmul, i.e. input to layer normalization, at cell gate.
|
|
// Type: ANEURALNETWORKS_FLOAT32.
|
|
AddFloatOperand<HalPolicy>(model, matMulCellGateValue);
|
|
|
|
// Constant scalar values
|
|
// 29: The scale of the intermediate result of matmul, i.e. input to layer normalization, at output gate.
|
|
// Type: ANEURALNETWORKS_FLOAT32.
|
|
AddFloatOperand<HalPolicy>(model, matMulOutputGateValue);
|
|
|
|
// Constant scalar values
|
|
// 30: The zero point of the hidden state, i.e. input to projection. Type: ANEURALNETWORKS_INT32.
|
|
AddIntOperand<HalPolicy>(model, projInputZeroPointValue);
|
|
|
|
// Constant scalar values
|
|
// 31: The scale of the hidden state, i.e. input to projection. Type: ANEURALNETWORKS_FLOAT32.
|
|
AddFloatOperand<HalPolicy>(model, projInputScaleValue);
|
|
|
|
// Outputs:
|
|
// 0: The output state (out). Type: ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED Shape: [batchSize, outputSize]
|
|
AddOutputOperand<HalPolicy>(model,
|
|
outputStateOutDimensions,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_ASYMM_SIGNED,
|
|
cellStateScale,
|
|
cellStateScale);
|
|
|
|
// 1: The cell state (out). Type: ANEURALNETWORKS_TENSOR_QUANT16_SYMM Shape: [batchSize, numUnits].
|
|
AddOutputOperand<HalPolicy>(model,
|
|
cellStateOutDimensions,
|
|
HalPolicy::OperandType::TENSOR_QUANT16_SYMM,
|
|
cellStateScale,
|
|
cellStateOffset);
|
|
|
|
// 2: The output. This is effectively the same as the current "output state (out)" value.
|
|
// Type: ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED Shape: [batchSize, outputSize]
|
|
AddOutputOperand<HalPolicy>(model,
|
|
outputDimensions,
|
|
HalPolicy::OperandType::TENSOR_QUANT8_ASYMM_SIGNED,
|
|
cellStateScale,
|
|
cellStateScale);
|
|
|
|
// make the QUANTIZED_LSTM operation
|
|
model.main.operations.resize(1);
|
|
model.main.operations[0].type = HalPolicy::OperationType::QUANTIZED_LSTM;
|
|
|
|
model.main.operations[0].inputs = hidl_vec<uint32_t> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
|
|
24, 25, 26, 27, 28, 29, 30, 31};
|
|
model.main.operations[0].outputs = hidl_vec<uint32_t> {32, 33, 34};
|
|
|
|
// define the input values
|
|
hidl_vec<RequestArgument> inputArguments;
|
|
inputArguments.resize(3);
|
|
|
|
inputArguments[0] = CreateRequestArgument<int8_t>(inputValue, 0);
|
|
inputArguments[1] = CreateRequestArgument<int8_t>(outputPreviousTimeStepInValue, 1);
|
|
inputArguments[2] = CreateRequestArgument<int16_t>(cellStatePreviousTimeStepInValue, 2);
|
|
|
|
// define the expected output values
|
|
hidl_vec<RequestArgument> outputArguments;
|
|
outputArguments.resize(3);
|
|
|
|
outputArguments[0] = CreateRequestArgument<int8_t>(outputStateOutValue, 3);
|
|
outputArguments[1] = CreateRequestArgument<int16_t>(cellStateOutValue, 4);
|
|
outputArguments[2] = CreateRequestArgument<int8_t>(outputValue, 5);
|
|
|
|
android::hardware::neuralnetworks::V1_0::Request request = {};
|
|
request.inputs = inputArguments;
|
|
request.outputs = outputArguments;
|
|
|
|
// set the input data
|
|
AddPoolAndSetData(inputValue.size(), request, inputValue.data());
|
|
AddPoolAndSetData(outputPreviousTimeStepInValue.size(), request, outputPreviousTimeStepInValue.data());
|
|
AddPoolAndSetData(cellStatePreviousTimeStepInValue.size(), request, cellStatePreviousTimeStepInValue.data());
|
|
|
|
// add memory for the outputs
|
|
android::sp<IMemory> outputStateOutMemory = AddPoolAndGetData<int8_t>(outputStateOutValue.size(), request);
|
|
int8_t* outputStateOutData = static_cast<int8_t*>(static_cast<void*>(outputStateOutMemory->getPointer()));
|
|
|
|
android::sp<IMemory> cellStateOutMemory = AddPoolAndGetData<int16_t>(cellStateOutValue.size(), request);
|
|
int16_t* cellStateOutData = static_cast<int16_t*>(static_cast<void*>(cellStateOutMemory->getPointer()));
|
|
|
|
android::sp<IMemory> outputMemory = AddPoolAndGetData<int8_t>(outputValue.size(), request);
|
|
int8_t* outputData = static_cast<int8_t*>(static_cast<void*>(outputMemory->getPointer()));
|
|
|
|
// make the prepared model and run the execution
|
|
ExecuteModel(model, *driver, request);
|
|
|
|
// check the results
|
|
for (size_t i = 0; i < outputStateOutValue.size(); ++i)
|
|
{
|
|
BOOST_TEST(TolerantCompareEqual(outputStateOutValue[i], outputStateOutData[i]),
|
|
"outputStateOut[" << i << "]: " << outputStateOutValue[i] << " != " << outputStateOutData[i]);
|
|
}
|
|
|
|
// CELL STATE OUTPUT Does not match currently: IVGCVSW-4860 Verify remaining VTS tests (2) for QLSTM
|
|
// Comment out for now
|
|
// for (size_t i = 0; i < cellStateOutValue.size(); ++i)
|
|
// {
|
|
// BOOST_TEST(TolerantCompareEqual(cellStateOutValue[i], cellStateOutData[i]),
|
|
// "cellStateOut[" << i << "]: " << cellStateOutValue[i] << " != " << cellStateOutData[i]);
|
|
//}
|
|
|
|
for (size_t i = 0; i < outputValue.size(); ++i)
|
|
{
|
|
BOOST_TEST(TolerantCompareEqual(outputValue[i], outputData[i]),
|
|
"output[" << i << "]: " << outputValue[i] << " != " << outputData[i]);
|
|
}
|
|
}
|
|
|
|
void QLstmWithProjection(armnn::Compute compute)
|
|
{
|
|
// This replicates android/frameworks/ml/nn/runtime/test/specs/V1_3/qlstm_projection.mod.py
|
|
// with values from android/frameworks/ml/nn/runtime/test/generated/spec_V1_3/qlstm_projection.example.cpp
|
|
// and weights, biases and scalars passed as CONSTANT_COPY tensors (instead of SUBGRAPH_INPUT tensors).
|
|
|
|
uint32_t batchSize = 2;
|
|
uint32_t inputSize = 5;
|
|
uint32_t outputSize = 3;
|
|
uint32_t numUnits = 4;
|
|
|
|
// Inputs:
|
|
hidl_vec<uint32_t> inputDimensions{batchSize, inputSize};
|
|
std::vector<int8_t> inputValue{ 90, 102, 13, 26, 38, 102, 13, 26, 51, 64};
|
|
|
|
hidl_vec<uint32_t> inputToInputWeightsDimensions{numUnits, inputSize};
|
|
std::vector<int8_t> inputToInputWeightsValue{ 64, 77, 89, -102,
|
|
-115, 13, 25, 38,
|
|
-51, 64, -102, 89,
|
|
-77, 64, -51, -64,
|
|
-51, -38, -25, -13 };
|
|
|
|
hidl_vec<uint32_t> inputToForgetWeightsDimensions{numUnits, inputSize};
|
|
std::vector<int8_t> inputToForgetWeightsValue{ -77, -13, 38, 25,
|
|
115, -64, -25, -51,
|
|
38, -102, -51, 38,
|
|
-64, -51, -77, 38,
|
|
-51, -77, -64, -64 };
|
|
|
|
hidl_vec<uint32_t> inputToCellWeightsDimensions{numUnits, inputSize};
|
|
std::vector<int8_t> inputToCellWeightsValue{ -51, -38, -25, -13,
|
|
-64, 64, -25, -38,
|
|
-25, -77, 77, -13,
|
|
-51, -38, -89, 89,
|
|
-115, -64, 102, 77 };
|
|
|
|
hidl_vec<uint32_t> inputToOutputWeightsDimensions{numUnits, inputSize};
|
|
std::vector<int8_t> inputToOutputWeightsValue{ -102, -51, -25, -115,
|
|
-13, -89, 38, -38,
|
|
-102, -25, 77, -25,
|
|
51, -89, -38, -64,
|
|
13, 64, -77, -51 };
|
|
|
|
hidl_vec<uint32_t> recurrentToInputWeightsDimensions{numUnits, outputSize};
|
|
std::vector<int8_t> recurrentToInputWeightsValue{ -25, -38, 51, 13, -64, 115, -25, -38, -89, 6, -25, -77 };
|
|
|
|
hidl_vec<uint32_t> recurrentToForgetWeightsDimensions{numUnits, outputSize};
|
|
std::vector<int8_t> recurrentToForgetWeightsValue{ -64, -38, -64, -25, 77, 51, 115, 38, -13, 25, 64, 25 };
|
|
|
|
hidl_vec<uint32_t> recurrentToCellWeightsDimensions{numUnits, outputSize};
|
|
std::vector<int8_t> recurrentToCellWeightsValue{ -38, 25, 13, -38, 102, -10, -25, 38, 102, -77, -13, 25 };
|
|
|
|
hidl_vec<uint32_t> recurrentToOutputWeightsDimensions{numUnits, outputSize};
|
|
std::vector<int8_t> recurrentToOutputWeightsValue{ 38, -13, 13, -25, -64, -89, -25, -77, -13, -51, -89, -25 };
|
|
|
|
hidl_vec<uint32_t> cellToInputWeightsDimensions{0};
|
|
std::vector<int16_t> cellToInputWeightsValue;
|
|
|
|
hidl_vec<uint32_t> cellToForgetWeightsDimensions{0};
|
|
std::vector<int16_t> cellToForgetWeightsValue;
|
|
|
|
hidl_vec<uint32_t> cellToOutputWeightsDimensions{0};
|
|
std::vector<int16_t> cellToOutputWeightsValue;
|
|
|
|
hidl_vec<uint32_t> inputGateBiasDimensions{numUnits};
|
|
std::vector<int32_t> inputGateBiasValue{ 644245, 3221226, 4724464, 8160438 };
|
|
|
|
hidl_vec<uint32_t> forgetGateBiasDimensions{numUnits};
|
|
std::vector<int32_t> forgetGateBiasValue{ 2147484, -6442451, -4294968, 2147484 };
|
|
|
|
hidl_vec<uint32_t> cellBiasDimensions{numUnits};
|
|
std::vector<int32_t> cellBiasValue{-1073742, 15461883, 5368709, 1717987 };
|
|
|
|
hidl_vec<uint32_t> outputGateBiasDimensions{numUnits};
|
|
std::vector<int32_t> outputGateBiasValue{ 1073742, -214748, 4294968, 2147484 };
|
|
|
|
hidl_vec<uint32_t> projectionWeightsDimensions{outputSize, numUnits};
|
|
std::vector<int8_t> projectionWeightsValue{ -25, 51, 3, -51, 25, 127, 77, 20, 18, 51, -102, 51 };
|
|
|
|
hidl_vec<uint32_t> projectionBiasDimensions{outputSize};
|
|
std::vector<int32_t> projectionBiasValue{ 0, 0, 0 };
|
|
|
|
hidl_vec<uint32_t> outputStateInDimensions{batchSize, outputSize};
|
|
std::vector<int8_t> outputStateInValue{ 0, 0, 0, 0, 0, 0 };
|
|
|
|
hidl_vec<uint32_t> cellStateInDimensions{batchSize, numUnits};
|
|
std::vector<int16_t> cellStateInValue{ 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
|
|
// Normalization:
|
|
hidl_vec<uint32_t> inputLayerNormWeightsDimensions{numUnits};
|
|
std::vector<int16_t> inputLayerNormWeightsValue{ 3277, 6553, 9830, 16384 };
|
|
|
|
hidl_vec<uint32_t> forgetLayerNormWeightsDimensions{numUnits};
|
|
std::vector<int16_t> forgetLayerNormWeightsValue{ 6553, 6553, 13107, 9830 };
|
|
|
|
hidl_vec<uint32_t> cellLayerNormWeightsDimensions{numUnits};
|
|
std::vector<int16_t> cellLayerNormWeightsValue{ 22937, 6553, 9830, 26214 };
|
|
|
|
hidl_vec<uint32_t> outputLayerNormWeightsDimensions{numUnits};
|
|
std::vector<int16_t> outputLayerNormWeightsValue{ 19660, 6553, 6553, 16384 };
|
|
|
|
float cellClipValue = 0.0f;
|
|
float projectionClipValue = 0.0f;
|
|
float inputIntermediateScale = 0.007059f;
|
|
float forgetIntermediateScale = 0.007812f;
|
|
float cellIntermediateScale = 0.007059f;
|
|
float outputIntermediateScale = 0.007812f;
|
|
int32_t hiddenStateZeroPoint = 0;
|
|
float hiddenStateScale = 0.007f;
|
|
|
|
// Outputs:
|
|
hidl_vec<uint32_t> outputStateOutDimensions{batchSize, outputSize};
|
|
std::vector<int8_t> outputStateOutValue{ 127, 127, -108, -67, 127, 127 };
|
|
|
|
hidl_vec<uint32_t> cellStateOutDimensions{batchSize, numUnits};
|
|
std::vector<int16_t> cellStateOutValue { -14650, 8939, 5771, 6715, -11843, 7847, 1508, 12939 };
|
|
|
|
hidl_vec<uint32_t> outputDimensions{batchSize, outputSize};
|
|
std::vector<int8_t> outputValue { 127, 127, -108, -67, 127, 127 };
|
|
|
|
QLstmTestImpl(inputDimensions, inputValue,
|
|
inputToInputWeightsDimensions, inputToInputWeightsValue,
|
|
inputToForgetWeightsDimensions, inputToForgetWeightsValue,
|
|
inputToCellWeightsDimensions, inputToCellWeightsValue,
|
|
inputToOutputWeightsDimensions, inputToOutputWeightsValue,
|
|
recurrentToInputWeightsDimensions, recurrentToInputWeightsValue,
|
|
recurrentToForgetWeightsDimensions, recurrentToForgetWeightsValue,
|
|
recurrentToCellWeightsDimensions, recurrentToCellWeightsValue,
|
|
recurrentToOutputWeightsDimensions, recurrentToOutputWeightsValue,
|
|
cellToInputWeightsDimensions, cellToInputWeightsValue,
|
|
cellToForgetWeightsDimensions, cellToForgetWeightsValue,
|
|
cellToOutputWeightsDimensions, cellToOutputWeightsValue,
|
|
inputGateBiasDimensions, inputGateBiasValue,
|
|
forgetGateBiasDimensions, forgetGateBiasValue,
|
|
cellBiasDimensions, cellBiasValue,
|
|
outputGateBiasDimensions, outputGateBiasValue,
|
|
projectionWeightsDimensions, projectionWeightsValue,
|
|
projectionBiasDimensions, projectionBiasValue,
|
|
outputStateInDimensions, outputStateInValue,
|
|
cellStateInDimensions, cellStateInValue,
|
|
inputLayerNormWeightsDimensions, inputLayerNormWeightsValue,
|
|
forgetLayerNormWeightsDimensions, forgetLayerNormWeightsValue,
|
|
cellLayerNormWeightsDimensions, cellLayerNormWeightsValue,
|
|
outputLayerNormWeightsDimensions, outputLayerNormWeightsValue,
|
|
cellClipValue,
|
|
projectionClipValue,
|
|
inputIntermediateScale,
|
|
forgetIntermediateScale,
|
|
cellIntermediateScale,
|
|
outputIntermediateScale,
|
|
hiddenStateZeroPoint,
|
|
hiddenStateScale,
|
|
outputStateOutDimensions, outputStateOutValue,
|
|
cellStateOutDimensions, cellStateOutValue,
|
|
outputDimensions, outputValue,
|
|
compute);
|
|
}
|
|
|
|
void QLstmWithNoProjection(armnn::Compute compute)
|
|
{
|
|
// This replicates android/frameworks/ml/nn/runtime/test/specs/V1_3/qlstm_noprojection.mod.py
|
|
// with values from android/frameworks/ml/nn/runtime/test/generated/spec_V1_3/qlstm_noprojection.example.cpp
|
|
// and weights, biases and scalars passed as CONSTANT_COPY tensors (instead of SUBGRAPH_INPUT tensors).
|
|
|
|
uint32_t batchSize = 2;
|
|
uint32_t inputSize = 5;
|
|
uint32_t outputSize = 4;
|
|
uint32_t numUnits = 4;
|
|
|
|
// Inputs:
|
|
hidl_vec<uint32_t> inputDimensions{batchSize, inputSize};
|
|
std::vector<int8_t> inputValue { 90, 102, 13, 26, 38, 102, 13, 26, 51, 64 };
|
|
|
|
hidl_vec<uint32_t> inputToInputWeightsDimensions{0, 0};
|
|
std::vector<int8_t> inputToInputWeightsValue;
|
|
|
|
hidl_vec<uint32_t> inputToForgetWeightsDimensions{numUnits, inputSize};
|
|
std::vector<int8_t> inputToForgetWeightsValue { -77, -13, 38, 25, 115,
|
|
-64, -25, -51, 38, -102,
|
|
-51, 38, -64, -51, -77,
|
|
38, -51, -77, -64, -64 };
|
|
|
|
hidl_vec<uint32_t> inputToCellWeightsDimensions{numUnits, inputSize};
|
|
std::vector<int8_t> inputToCellWeightsValue { -51, -38, -25, -13, -64,
|
|
64, -25, -38, -25, -77,
|
|
77, -13, -51, -38, -89,
|
|
89, -115, -64, 102, 77 };
|
|
|
|
hidl_vec<uint32_t> inputToOutputWeightsDimensions{numUnits, inputSize};
|
|
std::vector<int8_t> inputToOutputWeightsValue { -102, -51, -25, -115, -13,
|
|
-89, 38, -38, -102, -25,
|
|
77, -25, 51, -89, -38,
|
|
-64, 13, 64, -77, -51 };
|
|
|
|
hidl_vec<uint32_t> recurrentToInputWeightsDimensions{0, 0};
|
|
std::vector<int8_t> recurrentToInputWeightsValue;
|
|
|
|
hidl_vec<uint32_t> recurrentToForgetWeightsDimensions{numUnits, outputSize};
|
|
std::vector<int8_t> recurrentToForgetWeightsValue { -64, -38, -64, -25,
|
|
77, 51, 115, 38,
|
|
-13, 25, 64, 25,
|
|
25, 38, -13, 51 };
|
|
|
|
hidl_vec<uint32_t> recurrentToCellWeightsDimensions{numUnits, outputSize};
|
|
std::vector<int8_t> recurrentToCellWeightsValue { -38, 25, 13, -38,
|
|
102, -10, -25, 38,
|
|
102, -77, -13, 25,
|
|
38, -13, 25, 64 };
|
|
|
|
hidl_vec<uint32_t> recurrentToOutputWeightsDimensions{numUnits, outputSize};
|
|
std::vector<int8_t> recurrentToOutputWeightsValue { 38, -13, 13, -25,
|
|
-64, -89, -25, -77,
|
|
-13, -51, -89, -25,
|
|
13, 64, 25, -38 };
|
|
|
|
hidl_vec<uint32_t> cellToInputWeightsDimensions{0};
|
|
std::vector<int16_t> cellToInputWeightsValue;
|
|
|
|
hidl_vec<uint32_t> cellToForgetWeightsDimensions{0};
|
|
std::vector<int16_t> cellToForgetWeightsValue;
|
|
|
|
hidl_vec<uint32_t> cellToOutputWeightsDimensions{0};
|
|
std::vector<int16_t> cellToOutputWeightsValue;
|
|
|
|
hidl_vec<uint32_t> inputGateBiasDimensions{0};
|
|
std::vector<int32_t> inputGateBiasValue;
|
|
|
|
hidl_vec<uint32_t> forgetGateBiasDimensions{numUnits};
|
|
std::vector<int32_t> forgetGateBiasValue { 2147484, -6442451, -4294968, 2147484 };
|
|
|
|
hidl_vec<uint32_t> cellBiasDimensions{numUnits};
|
|
std::vector<int32_t> cellBiasValue { -1073742, 15461883, 5368709, 1717987 };
|
|
|
|
hidl_vec<uint32_t> outputGateBiasDimensions{numUnits};
|
|
std::vector<int32_t> outputGateBiasValue { 1073742, -214748, 4294968, 2147484 };
|
|
|
|
hidl_vec<uint32_t> projectionWeightsDimensions{0, 0};
|
|
std::vector<int8_t> projectionWeightsValue;
|
|
|
|
hidl_vec<uint32_t> projectionBiasDimensions{0};
|
|
std::vector<int32_t> projectionBiasValue;
|
|
|
|
hidl_vec<uint32_t> outputStateInDimensions{batchSize, outputSize};
|
|
std::vector<int8_t> outputStateInValue { 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
|
|
hidl_vec<uint32_t> cellStateInDimensions{batchSize, numUnits};
|
|
std::vector<int16_t> cellStateInValue { 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
|
|
// Normalization:
|
|
hidl_vec<uint32_t> inputLayerNormWeightsDimensions{0};
|
|
std::vector<int16_t> inputLayerNormWeightsValue;
|
|
|
|
hidl_vec<uint32_t> forgetLayerNormWeightsDimensions{numUnits};
|
|
std::vector<int16_t> forgetLayerNormWeightsValue { 6553, 6553, 13107, 9830 };
|
|
|
|
hidl_vec<uint32_t> cellLayerNormWeightsDimensions{numUnits};
|
|
std::vector<int16_t> cellLayerNormWeightsValue { 22937, 6553, 9830, 26214 };
|
|
|
|
hidl_vec<uint32_t> outputLayerNormWeightsDimensions{numUnits};
|
|
std::vector<int16_t> outputLayerNormWeightsValue { 19660, 6553, 6553, 16384 };
|
|
|
|
float cellClipValue = 0.0f;
|
|
float projectionClipValue = 0.0f;
|
|
float inputIntermediateScale = 0.007059f;
|
|
float forgetIntermediateScale = 0.007812f;
|
|
float cellIntermediateScale = 0.007059f;
|
|
float outputIntermediateScale = 0.007812f;
|
|
int32_t hiddenStateZeroPoint = 0;
|
|
float hiddenStateScale = 0.007f;
|
|
|
|
// Outputs:
|
|
hidl_vec<uint32_t> outputStateOutDimensions{batchSize, outputSize};
|
|
std::vector<int8_t> outputStateOutValue { -15, 21, 14, 20, -15, 15, 5, 27 };
|
|
|
|
hidl_vec<uint32_t> cellStateOutDimensions{batchSize, numUnits};
|
|
std::vector<int16_t> cellStateOutValue { -11692, 9960, 5491, 8861, -9422, 7726, 2056, 13149 };
|
|
|
|
hidl_vec<uint32_t> outputDimensions{batchSize, outputSize};
|
|
std::vector<int8_t> outputValue { -15, 21, 14, 20, -15, 15, 5, 27 };
|
|
|
|
QLstmTestImpl(inputDimensions, inputValue,
|
|
inputToInputWeightsDimensions, inputToInputWeightsValue,
|
|
inputToForgetWeightsDimensions, inputToForgetWeightsValue,
|
|
inputToCellWeightsDimensions, inputToCellWeightsValue,
|
|
inputToOutputWeightsDimensions, inputToOutputWeightsValue,
|
|
recurrentToInputWeightsDimensions, recurrentToInputWeightsValue,
|
|
recurrentToForgetWeightsDimensions, recurrentToForgetWeightsValue,
|
|
recurrentToCellWeightsDimensions, recurrentToCellWeightsValue,
|
|
recurrentToOutputWeightsDimensions, recurrentToOutputWeightsValue,
|
|
cellToInputWeightsDimensions, cellToInputWeightsValue,
|
|
cellToForgetWeightsDimensions, cellToForgetWeightsValue,
|
|
cellToOutputWeightsDimensions, cellToOutputWeightsValue,
|
|
inputGateBiasDimensions, inputGateBiasValue,
|
|
forgetGateBiasDimensions, forgetGateBiasValue,
|
|
cellBiasDimensions, cellBiasValue,
|
|
outputGateBiasDimensions, outputGateBiasValue,
|
|
projectionWeightsDimensions, projectionWeightsValue,
|
|
projectionBiasDimensions, projectionBiasValue,
|
|
outputStateInDimensions, outputStateInValue,
|
|
cellStateInDimensions, cellStateInValue,
|
|
inputLayerNormWeightsDimensions, inputLayerNormWeightsValue,
|
|
forgetLayerNormWeightsDimensions, forgetLayerNormWeightsValue,
|
|
cellLayerNormWeightsDimensions, cellLayerNormWeightsValue,
|
|
outputLayerNormWeightsDimensions, outputLayerNormWeightsValue,
|
|
cellClipValue,
|
|
projectionClipValue,
|
|
inputIntermediateScale,
|
|
forgetIntermediateScale,
|
|
cellIntermediateScale,
|
|
outputIntermediateScale,
|
|
hiddenStateZeroPoint,
|
|
hiddenStateScale,
|
|
outputStateOutDimensions, outputStateOutValue,
|
|
cellStateOutDimensions, cellStateOutValue,
|
|
outputDimensions, outputValue,
|
|
compute);
|
|
}
|
|
|
|
void DynamicOutputQLstmWithNoProjection(armnn::Compute compute)
|
|
{
|
|
// This replicates android/frameworks/ml/nn/runtime/test/specs/V1_3/qlstm_noprojection.mod.py
|
|
// with values from android/frameworks/ml/nn/runtime/test/generated/spec_V1_3/qlstm_noprojection.example.cpp
|
|
// and weights, biases and scalars passed as CONSTANT_COPY tensors (instead of SUBGRAPH_INPUT tensors)
|
|
// and made cellStateOutput dynamic.
|
|
|
|
uint32_t batchSize = 2;
|
|
uint32_t inputSize = 5;
|
|
uint32_t outputSize = 4;
|
|
uint32_t numUnits = 4;
|
|
|
|
// Inputs:
|
|
hidl_vec<uint32_t> inputDimensions{batchSize, inputSize};
|
|
std::vector<int8_t> inputValue { 90, 102, 13, 26, 38, 102, 13, 26, 51, 64 };
|
|
|
|
hidl_vec<uint32_t> inputToInputWeightsDimensions{0, 0};
|
|
std::vector<int8_t> inputToInputWeightsValue;
|
|
|
|
hidl_vec<uint32_t> inputToForgetWeightsDimensions{numUnits, inputSize};
|
|
std::vector<int8_t> inputToForgetWeightsValue { -77, -13, 38, 25, 115,
|
|
-64, -25, -51, 38, -102,
|
|
-51, 38, -64, -51, -77,
|
|
38, -51, -77, -64, -64 };
|
|
|
|
hidl_vec<uint32_t> inputToCellWeightsDimensions{numUnits, inputSize};
|
|
std::vector<int8_t> inputToCellWeightsValue { -51, -38, -25, -13, -64,
|
|
64, -25, -38, -25, -77,
|
|
77, -13, -51, -38, -89,
|
|
89, -115, -64, 102, 77 };
|
|
|
|
hidl_vec<uint32_t> inputToOutputWeightsDimensions{numUnits, inputSize};
|
|
std::vector<int8_t> inputToOutputWeightsValue { -102, -51, -25, -115, -13,
|
|
-89, 38, -38, -102, -25,
|
|
77, -25, 51, -89, -38,
|
|
-64, 13, 64, -77, -51 };
|
|
|
|
hidl_vec<uint32_t> recurrentToInputWeightsDimensions{0, 0};
|
|
std::vector<int8_t> recurrentToInputWeightsValue;
|
|
|
|
hidl_vec<uint32_t> recurrentToForgetWeightsDimensions{numUnits, outputSize};
|
|
std::vector<int8_t> recurrentToForgetWeightsValue { -64, -38, -64, -25,
|
|
77, 51, 115, 38,
|
|
-13, 25, 64, 25,
|
|
25, 38, -13, 51 };
|
|
|
|
hidl_vec<uint32_t> recurrentToCellWeightsDimensions{numUnits, outputSize};
|
|
std::vector<int8_t> recurrentToCellWeightsValue { -38, 25, 13, -38,
|
|
102, -10, -25, 38,
|
|
102, -77, -13, 25,
|
|
38, -13, 25, 64 };
|
|
|
|
hidl_vec<uint32_t> recurrentToOutputWeightsDimensions{numUnits, outputSize};
|
|
std::vector<int8_t> recurrentToOutputWeightsValue { 38, -13, 13, -25,
|
|
-64, -89, -25, -77,
|
|
-13, -51, -89, -25,
|
|
13, 64, 25, -38 };
|
|
|
|
hidl_vec<uint32_t> cellToInputWeightsDimensions{0};
|
|
std::vector<int16_t> cellToInputWeightsValue;
|
|
|
|
hidl_vec<uint32_t> cellToForgetWeightsDimensions{0};
|
|
std::vector<int16_t> cellToForgetWeightsValue;
|
|
|
|
hidl_vec<uint32_t> cellToOutputWeightsDimensions{0};
|
|
std::vector<int16_t> cellToOutputWeightsValue;
|
|
|
|
hidl_vec<uint32_t> inputGateBiasDimensions{0};
|
|
std::vector<int32_t> inputGateBiasValue;
|
|
|
|
hidl_vec<uint32_t> forgetGateBiasDimensions{numUnits};
|
|
std::vector<int32_t> forgetGateBiasValue { 2147484, -6442451, -4294968, 2147484 };
|
|
|
|
hidl_vec<uint32_t> cellBiasDimensions{numUnits};
|
|
std::vector<int32_t> cellBiasValue { -1073742, 15461883, 5368709, 1717987 };
|
|
|
|
hidl_vec<uint32_t> outputGateBiasDimensions{numUnits};
|
|
std::vector<int32_t> outputGateBiasValue { 1073742, -214748, 4294968, 2147484 };
|
|
|
|
hidl_vec<uint32_t> projectionWeightsDimensions{0, 0};
|
|
std::vector<int8_t> projectionWeightsValue;
|
|
|
|
hidl_vec<uint32_t> projectionBiasDimensions{0};
|
|
std::vector<int32_t> projectionBiasValue;
|
|
|
|
hidl_vec<uint32_t> outputStateInDimensions{batchSize, outputSize};
|
|
std::vector<int8_t> outputStateInValue { 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
|
|
hidl_vec<uint32_t> cellStateInDimensions{batchSize, numUnits};
|
|
std::vector<int16_t> cellStateInValue { 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
|
|
// Normalization:
|
|
hidl_vec<uint32_t> inputLayerNormWeightsDimensions{0};
|
|
std::vector<int16_t> inputLayerNormWeightsValue;
|
|
|
|
hidl_vec<uint32_t> forgetLayerNormWeightsDimensions{numUnits};
|
|
std::vector<int16_t> forgetLayerNormWeightsValue { 6553, 6553, 13107, 9830 };
|
|
|
|
hidl_vec<uint32_t> cellLayerNormWeightsDimensions{numUnits};
|
|
std::vector<int16_t> cellLayerNormWeightsValue { 22937, 6553, 9830, 26214 };
|
|
|
|
hidl_vec<uint32_t> outputLayerNormWeightsDimensions{numUnits};
|
|
std::vector<int16_t> outputLayerNormWeightsValue { 19660, 6553, 6553, 16384 };
|
|
|
|
float cellClipValue = 0.0f;
|
|
float projectionClipValue = 0.0f;
|
|
float inputIntermediateScale = 0.007059f;
|
|
float forgetIntermediateScale = 0.007812f;
|
|
float cellIntermediateScale = 0.007059f;
|
|
float outputIntermediateScale = 0.007812f;
|
|
int32_t hiddenStateZeroPoint = 0;
|
|
float hiddenStateScale = 0.007f;
|
|
|
|
// Outputs:
|
|
hidl_vec<uint32_t> outputStateOutDimensions{batchSize, outputSize};
|
|
std::vector<int8_t> outputStateOutValue { -15, 21, 14, 20, -15, 15, 5, 27 };
|
|
|
|
hidl_vec<uint32_t> cellStateOutDimensions{};
|
|
std::vector<int16_t> cellStateOutValue { -11692, 9960, 5491, 8861, -9422, 7726, 2056, 13149 };
|
|
|
|
hidl_vec<uint32_t> outputDimensions{batchSize, outputSize};
|
|
std::vector<int8_t> outputValue { -15, 21, 14, 20, -15, 15, 5, 27 };
|
|
|
|
QLstmTestImpl(inputDimensions, inputValue,
|
|
inputToInputWeightsDimensions, inputToInputWeightsValue,
|
|
inputToForgetWeightsDimensions, inputToForgetWeightsValue,
|
|
inputToCellWeightsDimensions, inputToCellWeightsValue,
|
|
inputToOutputWeightsDimensions, inputToOutputWeightsValue,
|
|
recurrentToInputWeightsDimensions, recurrentToInputWeightsValue,
|
|
recurrentToForgetWeightsDimensions, recurrentToForgetWeightsValue,
|
|
recurrentToCellWeightsDimensions, recurrentToCellWeightsValue,
|
|
recurrentToOutputWeightsDimensions, recurrentToOutputWeightsValue,
|
|
cellToInputWeightsDimensions, cellToInputWeightsValue,
|
|
cellToForgetWeightsDimensions, cellToForgetWeightsValue,
|
|
cellToOutputWeightsDimensions, cellToOutputWeightsValue,
|
|
inputGateBiasDimensions, inputGateBiasValue,
|
|
forgetGateBiasDimensions, forgetGateBiasValue,
|
|
cellBiasDimensions, cellBiasValue,
|
|
outputGateBiasDimensions, outputGateBiasValue,
|
|
projectionWeightsDimensions, projectionWeightsValue,
|
|
projectionBiasDimensions, projectionBiasValue,
|
|
outputStateInDimensions, outputStateInValue,
|
|
cellStateInDimensions, cellStateInValue,
|
|
inputLayerNormWeightsDimensions, inputLayerNormWeightsValue,
|
|
forgetLayerNormWeightsDimensions, forgetLayerNormWeightsValue,
|
|
cellLayerNormWeightsDimensions, cellLayerNormWeightsValue,
|
|
outputLayerNormWeightsDimensions, outputLayerNormWeightsValue,
|
|
cellClipValue,
|
|
projectionClipValue,
|
|
inputIntermediateScale,
|
|
forgetIntermediateScale,
|
|
cellIntermediateScale,
|
|
outputIntermediateScale,
|
|
hiddenStateZeroPoint,
|
|
hiddenStateScale,
|
|
outputStateOutDimensions, outputStateOutValue,
|
|
cellStateOutDimensions, cellStateOutValue,
|
|
outputDimensions, outputValue,
|
|
compute);
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
// Support is not added yet
|
|
//BOOST_DATA_TEST_CASE(QLSTMWithProjectionTest, COMPUTE_DEVICES)
|
|
//{
|
|
// QLstmWithProjection(sample);
|
|
//}
|
|
|
|
BOOST_DATA_TEST_CASE(QLSTMWithNoProjectionTest, COMPUTE_DEVICES)
|
|
{
|
|
QLstmWithNoProjection(sample);
|
|
}
|
|
|
|
BOOST_DATA_TEST_CASE(DynamicOutputQLSTMWithNoProjectionTest, COMPUTE_DEVICES)
|
|
{
|
|
DynamicOutputQLstmWithNoProjection(sample);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END() |