From 34db1872566a1737fd94305d0b3f3e7741d99b60 Mon Sep 17 00:00:00 2001 From: Sadik Armagan Date: Thu, 3 Sep 2020 15:22:29 +0100 Subject: IVGCVSW-5274 'Update ConvertQuantizedLstm function to use ShapeInferenceMethod' * Enabled Dynamic Tensors in QUANTIZED_LSTM operator. !android-nn-driver:3897 Signed-off-by: Sadik Armagan Change-Id: I415014d19729aac255479099e372e5ff1a6dd3e2 --- ConversionUtils_1_3.hpp | 66 ++++++++++++------- test/1.3/QLstm.cpp | 166 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 208 insertions(+), 24 deletions(-) diff --git a/ConversionUtils_1_3.hpp b/ConversionUtils_1_3.hpp index e6961253..445b9ea7 100644 --- a/ConversionUtils_1_3.hpp +++ b/ConversionUtils_1_3.hpp @@ -600,29 +600,36 @@ bool ConvertQuantizedLstm(const HalOperation& operation, const HalModel& model, } // Check if the layer is supported - - if (IsDynamicTensor(constOutputStateOutInfo) || - IsDynamicTensor(cellStateOutInfo) || - IsDynamicTensor(constOutputInfo)) + bool isSupported = false; + auto validateFunc = [&](const armnn::TensorInfo& cellStateOutInfo, bool& isSupported) + { + FORWARD_LAYER_SUPPORT_FUNC(__func__, + IsQLstmSupported, + data.m_Backends, + isSupported, + inputInfo, + outputStatePrevTimeStepInfo, + cellStatePrevTimeStepInfo, + constOutputStateOutInfo, + cellStateOutInfo, + constOutputInfo, + desc, + paramsInfo); + }; + + bool isDynamic = false; + if (!IsDynamicTensor(constOutputStateOutInfo) && + !IsDynamicTensor(cellStateOutInfo) && + !IsDynamicTensor(constOutputInfo)) + { + validateFunc(outputInfo, isSupported); + } + else { - return Fail("%s: Dynamic output tensors are not supported %d %d %d %d", __func__, - IsDynamicTensor(constOutputStateOutInfo), IsDynamicTensor(cellStateOutInfo), - IsDynamicTensor(constOutputInfo)); + isDynamic = true; + isSupported = AreDynamicTensorsSupported(); } - bool isSupported = false; - FORWARD_LAYER_SUPPORT_FUNC(__func__, - IsQLstmSupported, - data.m_Backends, - isSupported, - inputInfo, - outputStatePrevTimeStepInfo, - cellStatePrevTimeStepInfo, - constOutputStateOutInfo, - cellStateOutInfo, - constOutputInfo, - desc, - paramsInfo); if (!isSupported) { return false; @@ -635,10 +642,21 @@ bool ConvertQuantizedLstm(const HalOperation& operation, const HalModel& model, outputStatePrevTimeStep.Connect(layer->GetInputSlot(1)); cellStatePrevTimeStep.Connect(layer->GetInputSlot(2)); - return ( SetupAndTrackLayerOutputSlot(operation, 0, *layer, 0, model, data, - &constOutputStateOutInfo) && - SetupAndTrackLayerOutputSlot(operation, 1, *layer, 1, model, data) && - SetupAndTrackLayerOutputSlot(operation, 2, *layer, 2, model, data, &constOutputInfo)); + if (!isDynamic) + { + return ( SetupAndTrackLayerOutputSlot( + operation, 0, *layer, 0, model, data, &constOutputStateOutInfo) && + SetupAndTrackLayerOutputSlot(operation, 1, *layer, 1, model, data) && + SetupAndTrackLayerOutputSlot(operation, 2, *layer, 2, model, data, &constOutputInfo)); + } + else + { + return ( SetupAndTrackLayerOutputSlot( + operation, 0, *layer, 0, model, data, &constOutputStateOutInfo) && + SetupAndTrackLayerOutputSlot( + operation, 1, *layer, 1, model, data, nullptr, validateFunc, true) && + SetupAndTrackLayerOutputSlot(operation, 2, *layer, 2, model, data, &constOutputInfo)); + } } template inputDimensions{batchSize, inputSize}; + std::vector inputValue { 90, 102, 13, 26, 38, 102, 13, 26, 51, 64 }; + + hidl_vec inputToInputWeightsDimensions{0, 0}; + std::vector inputToInputWeightsValue; + + hidl_vec inputToForgetWeightsDimensions{numUnits, inputSize}; + std::vector inputToForgetWeightsValue { -77, -13, 38, 25, 115, + -64, -25, -51, 38, -102, + -51, 38, -64, -51, -77, + 38, -51, -77, -64, -64 }; + + hidl_vec inputToCellWeightsDimensions{numUnits, inputSize}; + std::vector inputToCellWeightsValue { -51, -38, -25, -13, -64, + 64, -25, -38, -25, -77, + 77, -13, -51, -38, -89, + 89, -115, -64, 102, 77 }; + + hidl_vec inputToOutputWeightsDimensions{numUnits, inputSize}; + std::vector inputToOutputWeightsValue { -102, -51, -25, -115, -13, + -89, 38, -38, -102, -25, + 77, -25, 51, -89, -38, + -64, 13, 64, -77, -51 }; + + hidl_vec recurrentToInputWeightsDimensions{0, 0}; + std::vector recurrentToInputWeightsValue; + + hidl_vec recurrentToForgetWeightsDimensions{numUnits, outputSize}; + std::vector recurrentToForgetWeightsValue { -64, -38, -64, -25, + 77, 51, 115, 38, + -13, 25, 64, 25, + 25, 38, -13, 51 }; + + hidl_vec recurrentToCellWeightsDimensions{numUnits, outputSize}; + std::vector recurrentToCellWeightsValue { -38, 25, 13, -38, + 102, -10, -25, 38, + 102, -77, -13, 25, + 38, -13, 25, 64 }; + + hidl_vec recurrentToOutputWeightsDimensions{numUnits, outputSize}; + std::vector recurrentToOutputWeightsValue { 38, -13, 13, -25, + -64, -89, -25, -77, + -13, -51, -89, -25, + 13, 64, 25, -38 }; + + hidl_vec cellToInputWeightsDimensions{0}; + std::vector cellToInputWeightsValue; + + hidl_vec cellToForgetWeightsDimensions{0}; + std::vector cellToForgetWeightsValue; + + hidl_vec cellToOutputWeightsDimensions{0}; + std::vector cellToOutputWeightsValue; + + hidl_vec inputGateBiasDimensions{0}; + std::vector inputGateBiasValue; + + hidl_vec forgetGateBiasDimensions{numUnits}; + std::vector forgetGateBiasValue { 2147484, -6442451, -4294968, 2147484 }; + + hidl_vec cellBiasDimensions{numUnits}; + std::vector cellBiasValue { -1073742, 15461883, 5368709, 1717987 }; + + hidl_vec outputGateBiasDimensions{numUnits}; + std::vector outputGateBiasValue { 1073742, -214748, 4294968, 2147484 }; + + hidl_vec projectionWeightsDimensions{0, 0}; + std::vector projectionWeightsValue; + + hidl_vec projectionBiasDimensions{0}; + std::vector projectionBiasValue; + + hidl_vec outputStateInDimensions{batchSize, outputSize}; + std::vector outputStateInValue { 0, 0, 0, 0, 0, 0, 0, 0 }; + + hidl_vec cellStateInDimensions{batchSize, numUnits}; + std::vector cellStateInValue { 0, 0, 0, 0, 0, 0, 0, 0 }; + + // Normalization: + hidl_vec inputLayerNormWeightsDimensions{0}; + std::vector inputLayerNormWeightsValue; + + hidl_vec forgetLayerNormWeightsDimensions{numUnits}; + std::vector forgetLayerNormWeightsValue { 6553, 6553, 13107, 9830 }; + + hidl_vec cellLayerNormWeightsDimensions{numUnits}; + std::vector cellLayerNormWeightsValue { 22937, 6553, 9830, 26214 }; + + hidl_vec outputLayerNormWeightsDimensions{numUnits}; + std::vector 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 outputStateOutDimensions{batchSize, outputSize}; + std::vector outputStateOutValue { -15, 21, 14, 20, -15, 15, 5, 27 }; + + hidl_vec cellStateOutDimensions{}; + std::vector cellStateOutValue { -11692, 9960, 5491, 8861, -9422, 7726, 2056, 13149 }; + + hidl_vec outputDimensions{batchSize, outputSize}; + std::vector 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 @@ -876,4 +1037,9 @@ BOOST_DATA_TEST_CASE(QLSTMWithNoProjectionTest, COMPUTE_DEVICES) QLstmWithNoProjection(sample); } +BOOST_DATA_TEST_CASE(DynamicOutputQLSTMWithNoProjectionTest, COMPUTE_DEVICES) +{ + DynamicOutputQLstmWithNoProjection(sample); +} + BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file -- cgit v1.2.1