20 #include <boost/test/unit_test.hpp> 22 #include <type_traits> 27 using MultiArray =
const boost::multi_array<uint8_t, 2>&;
30 MultiArray expectedOutput)
36 float inputOutputScale = 0.0078125f;
37 int32_t inputOutputOffset = 128;
39 float weightsScale = 0.00408021f;
40 int32_t weightsOffset = 100;
42 float biasScale = 3.1876640625e-05f;
43 int32_t biasOffset = 0;
45 float cellStateScale = 0.00048828125f;
46 int32_t cellStateOffset = 0;
62 const std::vector<uint8_t> inputToInputWeightsVector = {146, 250, 235, 171, 10, 218, 171, 108};
63 armnn::ConstTensor inputToInputWeightsTensor(inputWeightsInfo, inputToInputWeightsVector.data());
65 const std::vector<uint8_t> inputToForgetWeightsVector = {24, 50, 132, 179, 158, 110, 3, 169};
66 armnn::ConstTensor inputToForgetWeightsTensor(inputWeightsInfo, inputToForgetWeightsVector.data());
68 const std::vector<uint8_t> inputToCellWeightsTensorVector = {133, 34, 29, 49, 206, 109, 54, 183};
69 armnn::ConstTensor inputToCellWeightsTensor(inputWeightsInfo, inputToCellWeightsTensorVector.data());
71 const std::vector<uint8_t> inputToOutputWeightsTensorVector = {195, 187, 11, 99, 109, 10, 218, 48};
72 armnn::ConstTensor inputToOutputWeightsTensor(inputWeightsInfo, inputToOutputWeightsTensorVector.data());
74 const std::vector<uint8_t> recurrentToInputWeightsTensorVector =
75 {254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26};
76 armnn::ConstTensor recurrentToInputWeightsTensor(recurrentWeightsInfo, recurrentToInputWeightsTensorVector.data());
78 const std::vector<uint8_t> recurrentToForgetWeightsTensorVector =
79 {137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253};
81 recurrentToForgetWeightsTensorVector.data());
83 const std::vector<uint8_t> recurrentToCellWeightsTensorVector =
84 {172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216};
85 armnn::ConstTensor recurrentToCellWeightsTensor(recurrentWeightsInfo, recurrentToCellWeightsTensorVector.data());
87 const std::vector<uint8_t> recurrentToOutputWeightsTensorVector =
88 {106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98};
90 recurrentToOutputWeightsTensorVector.data());
92 const std::vector<int32_t> inputGateBiasTensorVector = {-7876, 13488, -726, 32839};
95 const std::vector<int32_t> forgetGateBiasTensorVector = {9206, -46884, -11693, -38724};
98 const std::vector<int32_t> cellBiasTensorVector = {39481, 48624, 48976, -21419};
101 const std::vector<int32_t> outputGateBiasTensorVector = {-58999, -17050, -41852, -40538};
104 data.m_InputToInputWeights = &inputToInputWeightsTensor;
105 data.m_InputToForgetWeights = &inputToForgetWeightsTensor;
106 data.m_InputToCellWeights = &inputToCellWeightsTensor;
107 data.m_InputToOutputWeights = &inputToOutputWeightsTensor;
108 data.m_RecurrentToInputWeights = &recurrentToInputWeightsTensor;
109 data.m_RecurrentToForgetWeights = &recurrentToForgetWeightsTensor;
110 data.m_RecurrentToCellWeights = &recurrentToCellWeightsTensor;
111 data.m_RecurrentToOutputWeights = &recurrentToOutputWeightsTensor;
112 data.m_InputGateBias = &inputGateBiasTensor;
113 data.m_ForgetGateBias = &forgetGateBiasTensor;
114 data.m_CellBias = &cellBiasTensor;
115 data.m_OutputGateBias = &outputGateBiasTensor;
153 Connect(inputLayer, quantizedLstmLayer, inputTensorInfo, 0, 0);
154 Connect(cellStateIn, quantizedLstmLayer, cellStateInTensorInfo, 0, 1);
155 Connect(outputStateIn, quantizedLstmLayer, outputStateInTensorInfo, 0, 2);
158 Connect(quantizedLstmLayer, cellStateOut, cellStateOutTensorInfo, 0, 0);
159 Connect(quantizedLstmLayer, outputStateOut, outputTensorInfo, 1, 0);
167 typename std::enable_if<std::is_arithmetic<T>::value,
bool>::type
168 IsCloseEnough(T value1, T value2, T tolerance)
175 T diff = value1 >= value2 ?
static_cast<T
>(value1 - value2) : static_cast<T>(value2 - value1);
176 return diff <= tolerance;
183 std::vector<uint8_t> inputVector = {166, 179, 50, 150};
185 boost::multi_array<uint8_t, 2> input = MakeTensor<uint8_t, 2>(inputDesc, inputVector);
187 std::vector<int16_t> cellStateInVector = {876, 1034, 955, -909, 761, 1029, 796, -1036};
189 boost::multi_array<int16_t, 2> cellStateIn = MakeTensor<int16_t, 2>(cellStateInDesc, cellStateInVector);
191 std::vector<uint8_t> outputStateInVector = {136, 150, 140, 115, 135, 152, 138, 112};
193 boost::multi_array<uint8_t, 2> outputStateIn = MakeTensor<uint8_t, 2>(outputStateInDesc, outputStateInVector);
195 std::vector<int16_t> cellStateOutVector = {1485, 1177, 1373, -1023, 1019, 1355, 1097, -1235};
197 boost::multi_array<int16_t, 2> cellStateOut = MakeTensor<int16_t, 2>(cellStateOutVectorDesc, cellStateOutVector);
199 std::vector<uint8_t> outputStateOutVector = {140, 151, 146, 112, 136, 156, 142, 112};
201 boost::multi_array<uint8_t, 2> outputStateOut = MakeTensor<uint8_t, 2>(outputDesc, outputStateOutVector);
206 BOOST_TEST_CHECKPOINT(
"create a network");
216 runtime->LoadNetwork(netId, std::move(optNet));
219 inputTensors.reserve(3);
222 inputTensors.push_back({0,
ConstTensor(runtime->GetInputTensorInfo(netId, 0), inputVector.data())});
223 inputTensors.push_back({1,
ConstTensor(runtime->GetInputTensorInfo(netId, 1), cellStateInVector.data())});
224 inputTensors.push_back({2,
ConstTensor(runtime->GetInputTensorInfo(netId, 2), outputStateInVector.data())});
227 outputTensors.reserve(2);
230 std::vector<int16_t > cellStateOutResult(cellStateOutVector.size());
231 std::vector<uint8_t > outputStateOutResult(outputStateOutVector.size());
232 outputTensors.push_back({0,
Tensor(runtime->GetOutputTensorInfo(netId, 0), cellStateOutResult.data())});
233 outputTensors.push_back({1,
Tensor(runtime->GetOutputTensorInfo(netId, 1), outputStateOutResult.data())});
236 runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
239 constexpr int16_t toleranceInt16 = 2;
240 for (
unsigned int i = 0u; i < cellStateOutResult.size(); ++i)
242 BOOST_CHECK(IsCloseEnough(cellStateOutVector[i], cellStateOutResult[i], toleranceInt16));
245 constexpr uint8_t toleranceUint8 = 1;
246 for (
unsigned int i = 0u; i < outputStateOutResult.size(); ++i)
248 BOOST_TEST(IsCloseEnough(outputStateOutVector[i], outputStateOutResult[i], toleranceUint8));
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
std::unique_ptr< IRuntime, void(*)(IRuntime *runtime)> IRuntimePtr
std::vector< std::pair< LayerBindingId, class ConstTensor > > InputTensors
A tensor defined by a TensorInfo (shape and data type) and a mutable backing store.
IOptimizedNetworkPtr Optimize(const INetwork &network, const std::vector< BackendId > &backendPreferences, const IDeviceSpec &deviceSpec, const OptimizerOptions &options=OptimizerOptions(), Optional< std::vector< std::string > &> messages=EmptyOptional())
Create an optimized version of the network.
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
std::vector< std::pair< LayerBindingId, class Tensor > > OutputTensors
std::unique_ptr< IOptimizedNetwork, void(*)(IOptimizedNetwork *network)> IOptimizedNetworkPtr
void QuantizedLstmEndToEnd(const std::vector< armnn::BackendId > &backends)
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
void Connect(armnn::IConnectableLayer *from, armnn::IConnectableLayer *to, const armnn::TensorInfo &tensorInfo, unsigned int fromIndex, unsigned int toIndex)
std::unique_ptr< INetwork, void(*)(INetwork *network)> INetworkPtr
static INetworkPtr Create(NetworkOptions networkOptions={})