From b9971c9ede0f344cdbf8ae0ed461e47f2ce7c8a1 Mon Sep 17 00:00:00 2001 From: Conor Kennedy Date: Tue, 7 May 2019 07:14:23 +0100 Subject: IVGCVSW-3013 Add unit tests for QSymm16 LSTM * Add unit tests for QSymm16 LSTM * Update supportedTypes in WorkloadData & RefLayerSupport with DataType::QuantisedSymm16 Change-Id: I1a2627b11b707d68d7d7002f63b985f9571ee177 Signed-off-by: Conor Kennedy --- src/backends/backendsCommon/WorkloadData.cpp | 2 + src/backends/backendsCommon/test/LayerTests.cpp | 111 ++++++++++++++++++++- src/backends/backendsCommon/test/LayerTests.hpp | 16 +++ src/backends/backendsCommon/test/LstmTestImpl.hpp | 114 ++++++++++++---------- src/backends/reference/RefLayerSupport.cpp | 3 +- src/backends/reference/test/RefLayerTests.cpp | 9 ++ 6 files changed, 195 insertions(+), 60 deletions(-) diff --git a/src/backends/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp index 61e0d4004d..2cf99371d2 100644 --- a/src/backends/backendsCommon/WorkloadData.cpp +++ b/src/backends/backendsCommon/WorkloadData.cpp @@ -862,7 +862,9 @@ void LstmQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const ValidateTensorNumDimensions(workloadInfo.m_OutputTensorInfos[0], "LstmQueueDescriptor", 2, "output"); std::vector supportedTypes = { + DataType::Float16, DataType::Float32, + DataType::QuantisedSymm16 }; ValidateDataTypes(workloadInfo.m_InputTensorInfos[0], diff --git a/src/backends/backendsCommon/test/LayerTests.cpp b/src/backends/backendsCommon/test/LayerTests.cpp index 525ac1780a..e505b56e7e 100644 --- a/src/backends/backendsCommon/test/LayerTests.cpp +++ b/src/backends/backendsCommon/test/LayerTests.cpp @@ -1019,13 +1019,13 @@ LayerTestResult LstmLayerFloat32WithCifgWithPeepholeNoProjectionTest( boost::multi_array expectedOutput = MakeTensor(outputDesc, std::vector( {-0.36444446f, -0.00352185f, 0.12886585f, -0.05163646f, -0.42734814f, -0.00478661f, 0.13455015f, -0.03560682f})); - return LstmLayerWithCifgWithPeepholeNoProjectionTestImpl( + return LstmLayerWithCifgWithPeepholeNoProjectionTestImpl( workloadFactory, memoryManager, input, expectedOutput); } LayerTestResult LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) { armnn::TensorInfo inputDesc({ 2, 5 }, armnn::DataType::Float32); boost::multi_array input = MakeTensor(inputDesc, std::vector( @@ -1041,7 +1041,8 @@ LayerTestResult LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest( -0.0186926f, 0.0193662f, -0.0115437f, 0.00422612f, -0.0345232f, 0.00223253f, -0.00957321f, 0.0210624f, 0.013331f, 0.0150954f, 0.02168f})); - return LstmLayerNoCifgWithPeepholeWithProjectionTestImpl(workloadFactory, memoryManager, input, expectedOutput); + return LstmLayerNoCifgWithPeepholeWithProjectionTestImpl( + workloadFactory, memoryManager, input, expectedOutput); } LayerTestResult LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest( @@ -1058,10 +1059,110 @@ LayerTestResult LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest( {{-0.02973187f, 0.1229473f, 0.20885126f, -0.15358765f, -0.0185422f, 0.11281417f, 0.24466537f, -0.1826292f}})); - return LstmNoCifgNoPeepholeNoProjectionTestImpl( + return LstmNoCifgNoPeepholeNoProjectionTestImpl( workloadFactory, memoryManager, input, expectedOutput); } +LayerTestResult LstmLayerInt16NoCifgNoPeepholeNoProjectionTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const float qScale = 1.0f; + const int32_t qOffset = 0; + + const armnn::DataType datatype = armnn::DataType::QuantisedSymm16; + const armnn::DataType constantDatatype = armnn::DataType::QuantisedAsymm8; + + armnn::TensorInfo inputDesc({2, 2}, datatype); + boost::multi_array input = MakeTensor(inputDesc, QuantizedVector(qScale, qOffset, + std::vector{2., 3., 3., 4.})); + + armnn::TensorInfo outputDesc({2, 4}, datatype); + boost::multi_array expectedOutput = MakeTensor(outputDesc, QuantizedVector(qScale, + qOffset, std::vector({{-0.02973187f, 0.1229473f, 0.20885126f, -0.15358765f, + -0.0185422f, 0.11281417f, 0.24466537f, -0.1826292f}}))); + + return LstmNoCifgNoPeepholeNoProjectionTestImpl( + workloadFactory, memoryManager, input, expectedOutput, qScale, qOffset, constantDatatype); + +} + +LayerTestResult LstmLayerInt16WithCifgWithPeepholeNoProjectionTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const float qScale = 1.0f; + const int32_t qOffset = 0; + + const armnn::DataType datatype = armnn::DataType::QuantisedSymm16; + const armnn::DataType constantDatatype = armnn::DataType::QuantisedAsymm8; + + armnn::TensorInfo inputDesc({ 2, 2 }, datatype); + boost::multi_array input = MakeTensor(inputDesc, QuantizedVector(qScale, qOffset, + std::vector({ 2., 3., 3., 4. }))); + + armnn::TensorInfo outputDesc({ 2, 4 }, datatype); + boost::multi_array expectedOutput = MakeTensor(outputDesc, QuantizedVector(qScale, + qOffset, std::vector( + {-0.36444446f, -0.00352185f, 0.12886585f, -0.05163646f, + -0.42734814f, -0.00478661f, 0.13455015f, -0.03560682f}))); + + return LstmLayerWithCifgWithPeepholeNoProjectionTestImpl( + workloadFactory, memoryManager, input, expectedOutput, qScale, qOffset, constantDatatype); +} + +LayerTestResult LstmLayerInt16NoCifgWithPeepholeWithProjectionTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const float qScale = 2.0f; + const int32_t qOffset = 0; + + const armnn::DataType datatype = armnn::DataType::QuantisedSymm16; + const armnn::DataType constantDatatype = armnn::DataType::QuantisedAsymm8; + + armnn::TensorInfo inputDesc({ 2, 5 }, datatype); + boost::multi_array input = MakeTensor(inputDesc, QuantizedVector(qScale, + qOffset, std::vector( + {0.787926f, 0.151646f, 0.071352f, 0.118426f, 0.458058f, + 0.295743f, 0.544053f, 0.690064f, 0.858138f, 0.497181f}))); + + armnn::TensorInfo outputDesc({ 2, 16 }, datatype); + boost::multi_array expectedOutput = MakeTensor(outputDesc, QuantizedVector(qScale, + qOffset, std::vector( + {-0.00396806f, 0.029352f, -0.00279226f, 0.0159977f, -0.00835576f, + -0.0211779f, 0.0283512f, -0.0114597f, 0.00907307f, -0.0244004f, + -0.0152191f, -0.0259063f, 0.00914318f, 0.00415118f, 0.017147f, + 0.0134203f, -0.013869f, 0.0287268f, -0.00334693f, 0.00733398f, -0.0287926f, + -0.0186926f, 0.0193662f, -0.0115437f, 0.00422612f, -0.0345232f, + 0.00223253f, -0.00957321f, 0.0210624f, 0.013331f, 0.0150954f, 0.02168f}))); + + return LstmLayerNoCifgWithPeepholeWithProjectionTestImpl( + workloadFactory, memoryManager, input, expectedOutput, qScale, qOffset, constantDatatype); +} + +LayerTestResult LstmLayerInt16NoCifgNoPeepholeNoProjectionInt16ConstantTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const float qScale = 1.0f; + const int32_t qOffset = 0; + + const armnn::DataType datatype = armnn::DataType::QuantisedSymm16; // datatype & constants set to QSymm16 + + armnn::TensorInfo inputDesc({2, 2}, datatype); + boost::multi_array input = MakeTensor(inputDesc, QuantizedVector(qScale, + qOffset, std::vector{2., 3., 3., 4.})); + + armnn::TensorInfo outputDesc({2, 4}, datatype); + boost::multi_array expectedOutput = MakeTensor(outputDesc, QuantizedVector(qScale, + qOffset, std::vector({{-0.02973187f, 0.1229473f, 0.20885126f, -0.15358765f, + -0.0185422f, 0.11281417f, 0.24466537f, -0.1826292f}}))); + + return LstmNoCifgNoPeepholeNoProjectionTestImpl( + workloadFactory, memoryManager, input, expectedOutput, qScale, qOffset, datatype); +} + LayerTestResult MergerTest( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp index 762e581ce4..0e8025ee87 100644 --- a/src/backends/backendsCommon/test/LayerTests.hpp +++ b/src/backends/backendsCommon/test/LayerTests.hpp @@ -1140,6 +1140,22 @@ LayerTestResult LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); +LayerTestResult LstmLayerInt16NoCifgNoPeepholeNoProjectionTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LstmLayerInt16WithCifgWithPeepholeNoProjectionTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LstmLayerInt16NoCifgWithPeepholeWithProjectionTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult LstmLayerInt16NoCifgNoPeepholeNoProjectionInt16ConstantTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + LayerTestResult SimpleConvertFp16ToFp32Test( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); diff --git a/src/backends/backendsCommon/test/LstmTestImpl.hpp b/src/backends/backendsCommon/test/LstmTestImpl.hpp index e300a529ce..dae9c8a3f1 100644 --- a/src/backends/backendsCommon/test/LstmTestImpl.hpp +++ b/src/backends/backendsCommon/test/LstmTestImpl.hpp @@ -16,11 +16,16 @@ #include #include -LayerTestResult LstmNoCifgNoPeepholeNoProjectionTestImpl( +template> +LayerTestResult +LstmNoCifgNoPeepholeNoProjectionTestImpl( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, - const boost::multi_array& input, - const boost::multi_array& outputExpected) + const boost::multi_array& input, + const boost::multi_array& outputExpected, + float qScale = 0.0f, + int32_t qOffset = 0, + armnn::DataType constantDataType = armnn::DataType::Float32) { unsigned int batchSize = boost::numeric_cast(input.shape()[0]); unsigned int inputSize = boost::numeric_cast(input.shape()[1]); @@ -28,19 +33,16 @@ LayerTestResult LstmNoCifgNoPeepholeNoProjectionTestImpl( // cellSize and outputSize have the same size when there is no projection. unsigned numUnits = outputSize; + armnn::TensorInfo inputTensorInfo({batchSize , inputSize}, ArmnnType, qScale, qOffset ); + armnn::TensorInfo cellStateInTensorInfo({batchSize , numUnits}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputStateInTensorInfo({batchSize , outputSize}, ArmnnType, qScale, qOffset); - armnn::TensorInfo inputTensorInfo({batchSize , inputSize}, armnn::DataType::Float32); - armnn::TensorInfo cellStateInTensorInfo({batchSize , numUnits}, armnn::DataType::Float32); - armnn::TensorInfo outputStateInTensorInfo({batchSize , outputSize}, armnn::DataType::Float32); + armnn::TensorInfo scratchBufferTensorInfo({batchSize, numUnits * 4}, ArmnnType, qScale, qOffset); + armnn::TensorInfo cellStateOutTensorInfo({batchSize, numUnits}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputStateOutTensorInfo({batchSize, outputSize}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputTensorInfo({batchSize, outputSize}, ArmnnType, qScale, qOffset); - - armnn::TensorInfo scratchBufferTensorInfo({batchSize, numUnits * 4}, armnn::DataType::Float32); - armnn::TensorInfo cellStateOutTensorInfo({batchSize, numUnits}, armnn::DataType::Float32); - armnn::TensorInfo outputStateOutTensorInfo({batchSize, outputSize}, armnn::DataType::Float32); - armnn::TensorInfo outputTensorInfo({batchSize, outputSize}, armnn::DataType::Float32); - - - LayerTestResult ret(outputTensorInfo); + LayerTestResult ret(outputTensorInfo); std::vector inputVector; inputVector.assign(input.data(), input.data() + (batchSize * inputSize)); @@ -91,9 +93,9 @@ LayerTestResult LstmNoCifgNoPeepholeNoProjectionTestImpl( AddOutputToWorkload(data, info, cellStateOutTensorInfo, cellStateOutHandle.get()); AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get()); - armnn::TensorInfo tensorInfo4({numUnits}, armnn::DataType::Float32); - armnn::TensorInfo tensorInfo8({numUnits, 2}, armnn::DataType::Float32); - armnn::TensorInfo tensorInfo16({numUnits, 4}, armnn::DataType::Float32); + armnn::TensorInfo tensorInfo4({numUnits}, constantDataType , qScale, qOffset); + armnn::TensorInfo tensorInfo8({numUnits, 2}, constantDataType, qScale, qOffset); + armnn::TensorInfo tensorInfo16({numUnits, 4}, constantDataType, qScale, qOffset); auto inputToInputWeights = MakeTensor(tensorInfo8, {-0.45018822f, -0.02338299f, -0.0870589f, -0.34550029f, 0.04266912f, -0.15680569f, @@ -191,14 +193,12 @@ LayerTestResult LstmNoCifgNoPeepholeNoProjectionTestImpl( data.m_CellBias = &cellBiasTensor; data.m_OutputGateBias = &outputGateBiasTensor; - // Flags to set test configuration data.m_Parameters.m_ActivationFunc = 4; data.m_Parameters.m_CifgEnabled = false; data.m_Parameters.m_PeepholeEnabled = false; data.m_Parameters.m_ProjectionEnabled = false; - std::unique_ptr workload = workloadFactory.CreateLstm(data, info); inputHandle->Allocate(); outputStateInHandle->Allocate(); @@ -220,29 +220,32 @@ LayerTestResult LstmNoCifgNoPeepholeNoProjectionTestImpl( return ret; } - -LayerTestResult +template> +LayerTestResult LstmLayerNoCifgWithPeepholeWithProjectionTestImpl(armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, - const boost::multi_array& input, - const boost::multi_array& outputExpected) + const boost::multi_array& input, + const boost::multi_array& outputExpected, + float qScale = 0.0f, + int32_t qOffset = 0, + armnn::DataType constantDataType = armnn::DataType::Float32) { unsigned int batchSize = 2; unsigned int outputSize = 16; unsigned int inputSize = 5; unsigned numUnits = 20; - armnn::TensorInfo inputTensorInfo({batchSize , inputSize}, armnn::DataType::Float32); - armnn::TensorInfo cellStateInTensorInfo({batchSize , numUnits}, armnn::DataType::Float32); - armnn::TensorInfo outputStateInTensorInfo({batchSize , outputSize}, armnn::DataType::Float32); + armnn::TensorInfo inputTensorInfo({batchSize , inputSize}, ArmnnType, qScale, qOffset); + armnn::TensorInfo cellStateInTensorInfo({batchSize , numUnits}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputStateInTensorInfo({batchSize , outputSize}, ArmnnType, qScale, qOffset); // Scratch buffer size without CIFG [batchSize, numUnits * 4] - armnn::TensorInfo scratchBufferTensorInfo({batchSize, numUnits * 4}, armnn::DataType::Float32); - armnn::TensorInfo cellStateOutTensorInfo({batchSize, numUnits}, armnn::DataType::Float32); - armnn::TensorInfo outputStateOutTensorInfo({batchSize, outputSize}, armnn::DataType::Float32); - armnn::TensorInfo outputTensorInfo({batchSize, outputSize}, armnn::DataType::Float32); + armnn::TensorInfo scratchBufferTensorInfo({batchSize, numUnits * 4}, ArmnnType, qScale, qOffset); + armnn::TensorInfo cellStateOutTensorInfo({batchSize, numUnits}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputStateOutTensorInfo({batchSize, outputSize}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputTensorInfo({batchSize, outputSize}, ArmnnType, qScale, qOffset); - LayerTestResult ret(outputTensorInfo); + LayerTestResult ret(outputTensorInfo); std::vector inputVector; inputVector.assign(input.data(), input.data() + (batchSize * inputSize)); @@ -292,11 +295,11 @@ LstmLayerNoCifgWithPeepholeWithProjectionTestImpl(armnn::IWorkloadFactory& workl AddOutputToWorkload(data, info, cellStateOutTensorInfo, cellStateOutHandle.get()); AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get()); - armnn::TensorInfo tensorInfo16({outputSize}, armnn::DataType::Float32); - armnn::TensorInfo tensorInfo20({numUnits}, armnn::DataType::Float32); - armnn::TensorInfo tensorInfo20x5({numUnits, inputSize}, armnn::DataType::Float32); - armnn::TensorInfo tensorInfo20x16({numUnits, outputSize}, armnn::DataType::Float32); - armnn::TensorInfo tensorInfo16x20({outputSize, numUnits}, armnn::DataType::Float32); + armnn::TensorInfo tensorInfo16({outputSize}, constantDataType, qScale, qOffset); + armnn::TensorInfo tensorInfo20({numUnits}, constantDataType, qScale, qOffset); + armnn::TensorInfo tensorInfo20x5({numUnits, inputSize}, constantDataType, qScale, qOffset); + armnn::TensorInfo tensorInfo20x16({numUnits, outputSize}, constantDataType, qScale, qOffset); + armnn::TensorInfo tensorInfo16x20({outputSize, numUnits}, constantDataType, qScale, qOffset); auto inputToInputWeights = MakeTensor(tensorInfo20x5, {0.021393683f,0.06124551f, 0.046905167f,-0.014657677f,-0.03149463f, @@ -931,12 +934,15 @@ LstmLayerNoCifgWithPeepholeWithProjectionTestImpl(armnn::IWorkloadFactory& workl } - -LayerTestResult LstmLayerWithCifgWithPeepholeNoProjectionTestImpl( +template> +LayerTestResult LstmLayerWithCifgWithPeepholeNoProjectionTestImpl( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, - const boost::multi_array& input, - const boost::multi_array& outputExpected) + const boost::multi_array& input, + const boost::multi_array& outputExpected, + float qScale = 0.0f, + int32_t qOffset = 0, + armnn::DataType constantDataType = armnn::DataType::Float32) { bool cifgEnabled = true; bool peepholeEnabled = true; @@ -950,15 +956,15 @@ LayerTestResult LstmLayerWithCifgWithPeepholeNoProjectionTestImpl( const unsigned int cellSize = outputSize; // Decide the shape of all input tensors - armnn::TensorInfo inputTensorInfo({batchSize , inputSize}, armnn::DataType::Float32); - armnn::TensorInfo outputStateInTensorInfo({batchSize, outputSize}, armnn::DataType::Float32); - armnn::TensorInfo cellStateInTensorInfo({batchSize, cellSize}, armnn::DataType::Float32); + armnn::TensorInfo inputTensorInfo({batchSize , inputSize}, ArmnnType, qScale, qOffset); // change to ArmnnType + armnn::TensorInfo outputStateInTensorInfo({batchSize, outputSize}, ArmnnType, qScale, qOffset); + armnn::TensorInfo cellStateInTensorInfo({batchSize, cellSize}, ArmnnType, qScale, qOffset); unsigned int scratchBufferSize = cifgEnabled ? cellSize * 3 : cellSize * 4; - armnn::TensorInfo scratchBufferTensorInfo({batchSize, scratchBufferSize}, armnn::DataType::Float32); - armnn::TensorInfo outputStateOutTensorInfo({batchSize, outputSize}, armnn::DataType::Float32); - armnn::TensorInfo cellStateOutTensorInfo({batchSize, cellSize}, armnn::DataType::Float32); - armnn::TensorInfo outputTensorInfo({batchSize, outputSize}, armnn::DataType::Float32); + armnn::TensorInfo scratchBufferTensorInfo({batchSize, scratchBufferSize}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputStateOutTensorInfo({batchSize, outputSize}, ArmnnType, qScale, qOffset); + armnn::TensorInfo cellStateOutTensorInfo({batchSize, cellSize}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputTensorInfo({batchSize, outputSize}, ArmnnType, qScale, qOffset); // List of inputs std::vector inputData; @@ -974,9 +980,9 @@ LayerTestResult LstmLayerWithCifgWithPeepholeNoProjectionTestImpl( // Prepare all the weights in the descriptor for LSTM armnn::LstmQueueDescriptor data; - armnn::TensorInfo tensorInfoInput({cellSize, inputSize}, armnn::DataType::Float32); - armnn::TensorInfo tensorInfoOutput({cellSize, outputSize}, armnn::DataType::Float32); - armnn::TensorInfo tensorInfoNumUnits({cellSize}, armnn::DataType::Float32); + armnn::TensorInfo tensorInfoInput({cellSize, inputSize}, constantDataType, qScale, qOffset); + armnn::TensorInfo tensorInfoOutput({cellSize, outputSize}, constantDataType, qScale, qOffset); + armnn::TensorInfo tensorInfoNumUnits({cellSize}, constantDataType, qScale, qOffset); auto inputToCellWeights = MakeTensor(tensorInfoInput, {-0.49770179f, -0.27711356f, -0.09624726f, 0.05100781f, @@ -1074,24 +1080,24 @@ LayerTestResult LstmLayerWithCifgWithPeepholeNoProjectionTestImpl( // List of outputs std::vector scratchBufferVector(batchSize * scratchBufferSize, 0.f); auto scratchBufferTensor = MakeTensor(scratchBufferTensorInfo, scratchBufferVector); - LayerTestResult ret0(scratchBufferTensorInfo); + LayerTestResult ret0(scratchBufferTensorInfo); // Output state for a certain time step std::vector outputStateOutVector(batchSize * outputSize, 0.f); auto outputStateOutTensor = MakeTensor(outputStateOutTensorInfo, outputStateOutVector); - LayerTestResult ret1(outputStateOutTensorInfo); + LayerTestResult ret1(outputStateOutTensorInfo); // Cell state for a certain time step std::vector cellStateOutVector(batchSize * cellSize, 0.f); auto cellStateOutTensor = MakeTensor(cellStateOutTensorInfo, cellStateOutVector); - LayerTestResult ret2(cellStateOutTensorInfo); + LayerTestResult ret2(cellStateOutTensorInfo); // Output for a certain time step std::vector outputVector(batchSize * outputSize, 0.f); auto outputTensor = MakeTensor(outputTensorInfo, outputVector); std::vector outputData; outputData.assign(outputExpected.data(), outputExpected.data() + batchSize*outputSize); - LayerTestResult ret3(outputTensorInfo); + LayerTestResult ret3(outputTensorInfo); ret3.outputExpected = MakeTensor(outputTensorInfo, outputData); // Prepare the inputs and outputs for the workload diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp index 67c13c3f84..8eded84e09 100644 --- a/src/backends/reference/RefLayerSupport.cpp +++ b/src/backends/reference/RefLayerSupport.cpp @@ -616,7 +616,8 @@ bool RefLayerSupport::IsLstmSupported(const TensorInfo& input, bool supported = true; std::array supportedTypes = { - DataType::Float32 + DataType::Float32, + DataType::QuantisedSymm16 }; supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported, diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp index 04b215a927..b2600029b1 100644 --- a/src/backends/reference/test/RefLayerTests.cpp +++ b/src/backends/reference/test/RefLayerTests.cpp @@ -458,6 +458,15 @@ ARMNN_AUTO_TEST_CASE(LstmLayerFloat32NoCifgNoPeepholeNoProjection, ARMNN_AUTO_TEST_CASE(LstmLayerFloat32NoCifgWithPeepholeWithProjection, LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest) +ARMNN_AUTO_TEST_CASE(LstmLayerInt16NoCifgNoPeepholeNoProjection, + LstmLayerInt16NoCifgNoPeepholeNoProjectionTest) +ARMNN_AUTO_TEST_CASE(LstmLayerInt16WithCifgWithPeepholeNoProjection, + LstmLayerInt16WithCifgWithPeepholeNoProjectionTest) +ARMNN_AUTO_TEST_CASE(LstmLayerInt16NoCifgWithPeepholeWithProjection, + LstmLayerInt16NoCifgWithPeepholeWithProjectionTest) +ARMNN_AUTO_TEST_CASE(LstmLayerInt16NoCifgNoPeepholeNoProjectionInt16Constant, + LstmLayerInt16NoCifgNoPeepholeNoProjectionInt16ConstantTest) + // Convert from Float16 to Float32 ARMNN_AUTO_TEST_CASE(SimpleConvertFp16ToFp32, SimpleConvertFp16ToFp32Test) // Convert from Float32 to Float16 -- cgit v1.2.1